shell bypass 403
�
LTfMc @ s� d Z d Z Z e a d d l Z d d l Z d d l Z d d l Z d d l Z d d l
m Z m Z d d l
Z
d � Z d e f d � � YZ d e f d � � YZ e d
� Z e e � e j j Z e j j Z e j j Z e j j Z d e f d � � YZ d
e f d � � YZ d e f d � � YZ d e f d � � YZ d e f d � � YZ d e f d � � YZ d e f d � � YZ i e e e � 6e e e � 6e d 6e d 6e d 6Z e! d � Z" e j d d d � Z# d � Z$ e! e! e! e! e! e! e! e! d � Z% d! � Z& d" � Z' d# f d$ � � YZ( d% e f d& � � YZ) d' f d( � � YZ* d) e* f d* � � YZ+ d+ e* f d, � � YZ, d- f d. � � YZ- d/ f d0 � � YZ. d1 f d2 � � YZ/ d
Z0 d3 d3 d3 d3 d3 d3 e! d3 d3 d3 d3 e e d4 �
Z1 e1 Z2 e! e! e! e! e! e! e! d5 � Z3 d6 � Z4 d3 d3 d3 d3 d3 d3 d3 d7 e! d8 � Z5 e! d9 d: e! e! e! d; � Z6 e7 d< k r�e2 � Z8 xV e8 j9 � D]H Z: d= e: j; f GHx1 e8 j< � D]# Z= e= j> e= j? e= j@ p�d3 f GHq�Wq�Wn d S(> s�
Windows Management Instrumentation (WMI) is Microsoft's answer to
the DMTF's Common Information Model. It allows you to query just
about any conceivable piece of information from any computer which
is running the necessary agent and over which have you the
necessary authority.
Since the COM implementation doesn't give much away to Python
programmers, I've wrapped it in some lightweight classes with
some getattr / setattr magic to ease the way. In particular:
* The :class:`_wmi_namespace` object itself will determine its classes
and allow you to return all instances of any of them by
using its name as an attribute::
disks = wmi.WMI ().Win32_LogicalDisk ()
* In addition, you can specify what would become the WHERE clause
as keyword parameters::
fixed_disks = wmi.WMI ().Win32_LogicalDisk (DriveType=3)
* The objects returned by a WMI lookup are wrapped in a Python
class which determines their methods and classes and allows
you to access them as though they were Python classes. The
methods only allow named parameters::
for p in wmi.WMI ().Win32_Process (Name="notepad.exe"):
p.Terminate (Result=1)
* Doing a print on one of the WMI objects will result in its
`GetObjectText\_` method being called, which usually produces
a meaningful printout of current values.
The repr of the object will include its full WMI path,
which lets you get directly to it if you need to.
* You can get the associators and references of an object as
a list of python objects by calling the associators () and
references () methods on a WMI Python object::
for p in wmi.WMI ().Win32_Process (Name="notepad.exe"):
for r in p.references ():
print r
.. note::
Don't do this on a Win32_ComputerSystem object; it will
take all day and kill your machine!
* WMI classes (as opposed to instances) are first-class
objects, so you can get hold of a class, and call
its methods or set up a watch against it::
process = wmi.WMI ().Win32_Process
process.Create (CommandLine="notepad.exe")
* To make it easier to use in embedded systems and py2exe-style
executable wrappers, the module will not force early Dispatch.
To do this, it uses a handy hack by Thomas Heller for easy access
to constants.
Typical usage will be::
import wmi
vodev1 = wmi.WMI ("vodev1")
for disk in vodev1.Win32_LogicalDisk ():
if disk.DriveType == 3:
space = 100 * long (disk.FreeSpace) / long (disk.Size)
print "%s has %d%% free" % (disk.Name, space)
Many thanks, obviously to Mark Hammond for creating the win32all
extensions, but also to Alex Martelli and Roger Upole, whose
c.l.py postings pointed me in the right direction.
Thanks especially in release 1.2 to Paul Tiemann for his code
contributions and robust testing.
s 1.4.9i����N( t GetObjectt Dispatchc C s% t j d t j d | � � \ } | S( s� Convert a (possibly signed) long to unsigned hex. Useful
when converting a COM error code to the more conventional
8-digit hex::
print "%08X" % signed_to_unsigned (-2147023174)
t Lt l( t structt unpackt pack( t signedt unsigned( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt signed_to_unsigned[ s !t SelfDeprecatingDictc B se e Z d Z e e e � � j e e � � Z d � Z d � Z
d � Z d � Z d � Z
d � Z RS( s< Provides for graceful degradation of objects which
are currently dictionaries (and therefore accessed via
`.keys`, `.items`, etc.) into lists. Wraps an existing
`dict` and allows it to be addressed as a `dict` or as a
`list` during an interregnum, issuing a `DeprecationWarning`
if accessed as a `dict`.
c C s% t | � | _ t | j � | _ d S( N( t dictt list( t selft dictlike( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt __init__p s c C sC | | j k r/ t j d t � t | j | � St | j | � Sd S( Ns2 In future this will be a list and not a dictionary( t dict_onlyt warningst warnt DeprecationWarningt getattrR R ( R
t attribute( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt __getattr__t s c C s
t | j � S( N( t iterR ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt __iter__{ s c C s
t | j � S( N( t strR ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt __str__~ s c C s
t | j � S( N( t reprR ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt __repr__� s c C s/ y | j | SWn t k
r* | j | SXd S( N( R t TypeErrorR ( R
t item( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt __getitem__� s
( t __name__t
__module__t __doc__t sett dirR t
differenceR R R R R R R R ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR
e s ! t ProvideConstantsc B s e Z d Z d � Z d � Z RS( s� When called on a ``win32com.client.Dispatch`` object,
provides lazy access to constants defined in the typelib.
They can then be accessed as attributes of the :attr:`_constants`
property. (From Thomas Heller on c.l.py).
c C s3 | | j d <| j j � j � d j � | _ d S( Nt
_constantsi ( t __dict__t _oleobj_t GetTypeInfot GetContainingTypeLibt GetTypeCompt _ProvideConstants__typecomp( R
t comobj( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s
c C sc | j d � r- | j d � r- t | � � n | j j | � } | d sX t | � � n | d j S( Nt __i i ( t
startswitht endswitht AttributeErrorR- t Bindt value( R
t namet result( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s
( R R! R" R R ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR& � s s winmgmts:t x_wmic B s& e Z d Z d d d � Z d � Z RS( s� Ancestor of all wmi-related exceptions. Keeps track of
an info message and the underlying COM error if any, exposed
as the :attr:`com_error` attribute.
t c C s | | _ | | _ d S( N( t infot com_error( R
R9 R: ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s c C s d | j p d | j p d f S( Ns <x_wmi: %s %s>s Unexpected COM Errors (no underlying exception)( R9 R: ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s N( R R! R" t NoneR R ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR7 � s t x_wmi_invalid_queryc B s e Z d Z RS( s/ Raised when a WMI returns `wbemErrInvalidQuery`( R R! R" ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR< � s t x_wmi_timed_outc B s e Z d Z RS( s Raised when a watcher times out( R R! R" ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR= � s t x_wmi_no_namespacec B s e Z d Z RS( sW Raised when an attempt is made to query or watch
from a class without a namespace.
( R R! R" ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR> � s t x_access_deniedc B s e Z d Z RS( s Raised when WMI raises 80070005( R R! R" ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR? � s t x_wmi_authenticationc B s e Z d Z RS( s\ Raised when an invalid combination of authentication properties is attempted when connecting( R R! R" ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR@ � s t x_wmi_uninitialised_threadc B s e Z d Z RS( sx Raised when WMI returns 800401E4 on connection, usually
indicating that no COM threading model has been initialised
( R R! R" ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyRA � s l l l � c C s | d k r$ t j � \ } } } n | j \ } } } } t | � } d t | � | f g } d } | r� | \ } } }
} } } t | � } | j d | � | j d t | � |
p� d j � f � n x6 t j � D]" \ }
} |
| | f k r� Pq� q� Wt
} | d | � � d S( s� Convenience wrapper for displaying all manner of COM errors.
Raises a :exc:`x_wmi` exception with more useful information attached
:param err: The structure attached to a `pywintypes.com_error`
s %s - %ss Error in: %ss %s - %sR8 R: N( R; t syst exc_infot argsR t hext appendt stript WMI_EXCEPTIONSt itemsR7 ( t errt _t hresult_codet hresult_namet additional_infot parameter_in_errort exception_stringt scodet wcodet source_of_errort error_descriptiont whlp_filet whlp_contextt
error_codet klass( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt handle_com_error� s ,iA i c C s t t j d t | � d � S( Nt microsecondsi
( t BASEt datetimet timedeltat int( t ns100( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt from_1601� s c
C s� d � } d } | | | d � 7} | | | d � 7} | | | d � 7} | | | d � 7} | | | d � 7} | | | d � 7} | d 7} | | | d � 7} | d k r� | d 7} n | d 7} t | � } | | | d
� 7} | S( s Convenience wrapper to take a series of date/time elements and return a WMI time
of the form `yyyymmddHHMMSS.mmmmmm+UUU`. All elements may be int, string or
omitted altogether. If omitted, they will be replaced in the output string
by a series of stars of the appropriate length.
:param year: The year element of the date/time
:param month: The month element of the date/time
:param day: The day element of the date/time
:param hours: The hours element of the date/time
:param minutes: The minutes element of the date/time
:param seconds: The seconds element of the date/time
:param microseconds: The microseconds element of the date/time
:param timezone: The timeezone element of the date/time
:returns: A WMI datetime string of the form: `yyyymmddHHMMSS.mmmmmm+UUU`
c S s. | d k r d | St | � j | d � Sd S( Nt *t 0( R; R t rjust( t it length( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt str_or_stars s R8 i i t .i i t +t -i ( t abs(
t yeart montht dayt hourst minutest secondsRZ t timezoneRf t wmi_time( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt from_time� s
c
C s� d � } | | d d � } | | d d � } | | d d � } | | d d � } | | d d � } | | d d � } | | d d
� } | d } | d k r� d
} n | | | | | | | | f S( sz Convenience wrapper to take a WMI datetime string of the form
yyyymmddHHMMSS.mmmmmm+UUU and return a 9-tuple containing the
individual elements, or None where string contains placeholder
stars.
:param wmi_time: The WMI datetime string in `yyyymmddHHMMSS.mmmmmm+UUU` format
:returns: A 9-tuple of (year, month, day, hours, minutes, seconds, microseconds, timezone)
c S s. y t | | | !� SWn t k
r) d SXd S( N( R^ t
ValueErrorR; ( t st startt end( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt int_or_none+ s
i i i i i
i i i i i s ***N( R; (
Rr Rx Rk Rl Rm Rn Ro Rp RZ Rq ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt to_time! s
c C s | | j | <d S( s� Helper function to add an attribute directly into the instance
dictionary, bypassing possible `__getattr__` calls
:param obj: Any python object
:param attribute: String containing attribute name
:param value: Any python object
N( R( ( t objR R4 ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt _set> s t _wmi_methodc B s) e Z d Z d � Z d � Z d � Z RS( s� A currying sort of wrapper around a WMI method name. It
abstract's the method's parameters and can be called like
a normal Python object passing in the parameter values.
Output parameters are returned from the call as a tuple.
In addition, the docstring is set up as the method's
signature, including an indication as to whether any
given parameter is expecting an array, and what
special privileges are required to call the method.
c C s� y�t | � | _ | j | � | _ i | _ x' | j j D] } | j | j | j <q: Wd j | j j d g � � | _
| j j | _ | j j
| _ | j d k r� g | _ n. g | j j D] } | j | j f ^ q� | _ | j d k r� g | _ n. g | j j D] } | j | j f ^ q| _ d | d j g | j D] \ } } | d
| ^ q>� d j g | j D] \ } } | d | ^ qn� f } | j j d g � } | r�| d d j | � 7} n | | _ Wn t j k
r�t � n Xd S( s�
:param ole_object: The WMI class/instance whose method is to be called
:param method_name: The name of the method to be called
s
t MappingStringss %s (%s) => (%s)s , R8 s []t
Privilegess
| Needs: N( R8 s []( R8 s []( R t
ole_objectt Methods_t methodt
qualifierst Qualifiers_t Valuet Namet joint gett
provenancet InParameterst
in_parameterst
OutParameterst out_parametersR; t in_parameter_namest Properties_t IsArrayt out_parameter_namesR" t
pywintypesR: RY ( R
R t method_namet qRd R5 t is_arrayt doct
privileges( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR T s2 ! . .07
c O s" y | j r|i } x! | j D] \ } } | | | <q W| j } xx t t | � � D]d } | | } | j | } | j r� y t | � Wq� t k
r� t d | � � q� Xn | | _ qR Wx� | j � D]� \ }
} | j
|
� } | d k r
t d |
| j
f � � n; | rEy t | � WqEt k
rAt d |
� � qEXn | | j |
� _ q� W| j j | j j | j � } n | j j | j j � } g }
xX | j D]M \ } } | j | � j } | r�|
j t | p�g � � q�|
j | � q�Wt |
� SWn t j k
r t � n Xd S( s� Execute the call to a WMI method, returning
a tuple (even if is of only one value) containing
the out and return parameters.
s parameter %d must be iterables" %s is not a valid parameter for %ss %s must be iterableN( R� R� t ranget lenR� R� R R R� RI R� R; R2 R" R t ExecMethod_R� R� R� RF t tupleR� R: RY ( R
RD t kwargst parameter_namesR5 R� t
parameterst n_argt argt parametert kt vR6 t resultsR4 ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt __call__x sH
! c C s d | j S( Ns
<function %s>( R" ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s ( R R! R" R R� R ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR| H s
$ 9t
_wmi_propertyc B s, e Z d � Z d � Z d � Z d � Z RS( c C sY | | _ | j | _ | j | _ t d � | j D� � | _ | j j d d � | _
d S( Nc s s! | ] } | j | j f Vq d S( N( R� R� ( t .0R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pys <genexpr>� s t CIMTYPE( t propertyR� R5 R� R4 R R� R� R� R; t type( R
R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s
c C s | | j _ d S( N( R� R� ( R
R4 ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR# � s c C s d | j S( Ns <wmi_property: %s>( R5 ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s c C s t | j | � S( N( R R� ( R
t attr( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s ( R R! R R# R R ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR� � s t _wmi_objectc B s� e Z d Z d g i d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d
� Z
d � Z d � Z e e � Z d
� Z d � Z d � Z d � Z d � Z d � Z e e � Z d d d � Z d d � Z RS( s� The heart of the WMI module: wraps the objects returned by COM
ISWbemObject interface and provide readier access to their properties
and methods resulting in a more Pythonic interface. Not usually
instantiated directly, rather as a result of calling a :class:`_wmi_class`
on the parent :class:`_wmi_namespace`.
If you get hold of a WMI-related COM object from some other
source than this module, you can wrap it in one of these objects
to get the benefits of the module::
import win32com.client
import wmi
wmiobj = win32com.client.GetObject ("winmgmts:Win32_LogicalDisk.DeviceID='C:'")
c_drive = wmi._wmi_object (wmiobj)
print c_drive
c C sy yWt | d | � t | d | j j j � � t | d | � t | d i � t | d i � t | d | � t | d d � t | d d � | r� xB | D] } d | j | <q� Wn$ x! | j D] } d | j | j <q� Wx! | j D] } d | j | j <q� Wt | d | j j
� � t | d
| j j
� � t | d t d � | j j
D� � � Wn t j k
rtt � n Xd S(
NR t idt _instance_oft
propertiest methodst property_mapt _associated_classest _keyst _propertiest _methodsR� c s s! | ] } | j | j f Vq d S( N( R� R� ( R� R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pys <genexpr>� s ( R{ t Path_t DisplayNamet lowerR; R� R� R� R� R� t keysR R R� R� R: RY ( R
R t instance_oft fieldsR� t fieldt pt m( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s*
*c C s | j | j k S( N( R� ( R
t other( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt __lt__� s c C s3 y | j j � SWn t j k
r. t � n Xd S( si For a call to print [object] return the OLE description
of the properties / values of the object
N( R t GetObjectText_R� R: RY ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s c C sL y* d | j j | j j j d d � f SWn t j k
rG t � n Xd S( sr
Indicate both the fact that this is a wrapped WMI object
and the WMI object's own identifying class.
s <%s: %s>t asciit backslashreplaceN( t __class__R R� t Patht encodeR� R: RY ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR s *c C s@ | j | d k r5 t | j j | � � | j | <n | j | S( N( R� R; R� R R� ( R
R ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt _cached_properties s "c C s: | j | d k r/ t | j | � | j | <n | j | S( N( R� R; R| R ( R
R ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt _cached_methods s c C s� y� | | j k r� | j | � } | j j | | j j | j d � � � } | | j � } | j j d � ry t d | � S| Sn, | | j k r� | j | � St
| j | � SWn t j
k
r� t � n Xd S( s.
Attempt to pass attribute calls to the proxied COM object.
If the attribute is recognised as a property, return its value;
if it is recognised as a method, return a method wrapper which
can then be called with parameters; otherwise pass the lookup
on to the underlying object.
c S s | S( N( ( t x( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt <lambda># R8 s ref:t monikerN( R� R� R� R� R� R4 R0 t WMIR� R� R R R� R: RY ( R
R R� t factoryR4 ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR s *
c C sy yW | | j k rJ | j | � j | � | j j j rV | j j � qV n t | � � Wn t j k
rt t
� n Xd S( s� If the attribute to be set is valid for the proxied
COM object, set that objects's parameter value; if not,
raise an exception.
N( R� R� R# R R� R� t Put_R2 R� R: RY ( R
R R4 ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt __setattr__5 s c C s | j | j k S( N( R� ( R
R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt __eq__D s c C s
t | j � S( N( t hashR� ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt __hash__G s c C s[ g | j j � D] } t | � ^ q } | j g | j j � D] } t | � ^ q> � | S( s8 Return list of methods/properties for IPython completion( R� R� R t extendR� ( R
R� t attribs( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt _getAttributeNamesJ s (/c C s� | j d k r{ t | d g � xY | j j D]H } x? | j D]4 } | j d k r< | j r< | j j | j � q< q< Wq, Wn | j S( s� A WMI object is uniquely defined by a set of properties
which constitute its keys. Lazily retrieves the keys for this
instance or class.
:returns: list of key property names
R� t keyN( R� R; R{ R R� R� R� R� RF ( R
R� t qualifier( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt _get_keysP s
!c C s t | j j | � � S( sJ Return the cached object representing one property
of this object
( R� R R� ( R
t
property_name( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt wmi_propertyc s c C s | j j � d S( sH Push all outstanding property updates back to the
WMI database.
N( R R� ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt puti s c K s� | r� yt xN | j � D]@ \ } } | | j k rJ | j | � j | � q t | � � q W| j j j ry | j j � n Wq� t j
k
r� t � q� Xn d S( s) Set several properties of the underlying object
at one go. This is particularly useful in combination
with the new () method below. However, an instance
which has been spawned in this way won't have enough
information to write pack, so only try if the
instance has a path.
N( RI R� R� R# R2 R R� R� R� R� R: RY ( R
R� R R4 ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR# o s c C s0 y | j j SWn t j k
r+ t � n Xd S( s� Return the WMI URI to this object. Can be used to
determine the path relative to the parent namespace::
pp0 = wmi.WMI ().Win32_ParallelPort ()[0]
print pp0.path ().RelPath
.. Do more with this
N( R R� R� R: RY ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt path� s c C s0 y | j j SWn t j k
r+ t � n Xd S( s� Return a tuple representing the object derivation for
this object, with the most specific object first::
pp0 = wmi.WMI ().Win32_ParallelPort ()[0]
print ' <- '.join (pp0.derivation ())
N( R t Derivation_R� R: RY ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt
derivation� s c s� � j d k r� t � t � r. i t d 6} n
i t d 6} y< t � f d � � j j | � D� � } t � d | � Wq� t j
k
r� t � q� Xn � j S( Nt bSchemaOnlyt bClassesOnlyc 3 s- | ]# } | j j t � j | � f Vq d S( N( R� t Classt
_wmi_classt
_namespace( R� t assoc( R
( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pys <genexpr>� s R� ( R� R; t
isinstanceR� t TrueR R t Associators_R{ R� R: RY ( R
t paramst associated_classes( ( R
sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt _cached_associated_classes� s
R8 c C sX y6 g | j j d | d | � D] } t | � ^ q SWn t j k
rS t � n Xd S( s� Return a list of objects related to this one, optionally limited
either by association class (ie the name of the class which relates
them) or by result class (ie the name of the class which would be
retrieved)::
c = wmi.WMI ()
pp = c.Win32_ParallelPort ()[0]
for i in pp.associators (wmi_association_class="Win32_PortResource"):
print i
for i in pp.associators (wmi_result_class="Win32_PnPEntity"):
print i
t
strAssocClasst strResultClassN( R R� R� R� R: RY ( R
t wmi_association_classt wmi_result_classRd ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt associators� s !c C sR y0 g | j j d | � D] } t | � ^ q SWn t j k
rM t � n Xd S( s Return a list of associations involving this object, optionally
limited by the result class (the name of the association class).
NB Associations are treated specially; although WMI only returns
the string corresponding to the instance of each associated object,
this module will automatically convert that to the object itself::
c = wmi.WMI ()
sp = c.Win32_SerialPort ()[0]
for i in sp.references ():
print i
for i in sp.references (wmi_class="Win32_SerialPortSetting"):
print i
R� N( R t References_R� R� R: RY ( R
t wmi_classRd ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt
references� s 0N( R R! R" R; R R� R R R� R� R R� R� R� R� R� R� R� R� R� R# R� R� R� R� R� R� ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR� � s.
t
_wmi_eventc B s) e Z d Z e j d � Z g d � Z RS( s� Slight extension of the _wmi_object class to allow
objects which are the result of events firing to return
extra information such as the type of event.
s/ __Instance(Creation|Modification|Deletion)Eventc C s� t j | | d | �t | d d � t | d d � t | d d � | r� | j j | j j � j d � j � } t | d | � t
| d � r� t | d t | j � � n t
| d � r� t | d | j
� q� n d S( NR� t
event_typet timestampt previousi t TIME_CREATEDt PreviousInstance( R� R R{ R; t
event_type_ret matchR� R� t groupR� t hasattrR` R� R� ( R
t eventt
event_infoR� R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s ' ( R R! R" t ret compileR� R ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR� � s R� c B sV e Z d Z d � Z d � Z g d � Z e Z d d g d � Z d � Z d � Z RS( s� Currying class to assist in issuing queries against
a WMI namespace. The idea is that when someone issues
an otherwise unknown method against the WMI object, if
it matches a known WMI class a query object will be
returned which may then be called with one or more params
which will form the WHERE clause::
c = wmi.WMI ()
c_drives = c.Win32_LogicalDisk (Name='C:')
c C s� t j | | � t | d | j j � | r? t | d | � nQ | j j } | j d � \ } } } t t | d | � t � } t | d | � d S( Nt _class_nameR� t :(
R� R R{ R� R� R� t splitt _wmi_namespaceR t False( R
t namespaceR� t
class_monikert winmgmtst namespace_monikert
class_name( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR s c C sX y6 | | j k r% t | j | � � St j | | � SWn t j k
rS t � n Xd S( N( R� R� R� R� R R� R: RY ( R
R ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR s c K s� | j d k r t d � � n y� d j | � p3 d } d | d | j } | r� | d d j g | j � D]" \ } } d | t | � f ^ qj � 7} n | j j | | | � SWn t j k
r� t
� n Xd S(
s� Make it slightly easier to query against the class,
by calling the namespace's query with the class preset.
Won't work if the class has been instantiated directly.
s* You cannot query directly from a WMI classs , Ra s SELECT s FROM s WHERE s AND s %s = %rN( R� R; R> R� R RI R t queryR� R: RY ( R
R� t where_clauset
field_listt wqlR� R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR
! s It operationi c
K sz | j d k r t d � � n d } | j � | k rR t d d j | � � � n | j j d | d | d
| d | | � S(
Ns* You cannot watch directly from a WMI classR t creationt deletiont modifications# notification_type must be one of %ss , t notification_typeR� t
delay_secsR� ( R R R R ( R� R; R> R� R7 R� t watch_for( R
R R R� R t valid_notification_types( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR 7 s c C sL y* g | j � D] } t | | � ^ q SWn t j k
rG t � n Xd S( s0 Return a list of instances of the WMI class
N( t
Instances_R� R� R: RY ( R
t instance( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt instancesM s *c K sL y* t | j � | � } | j | � | SWn t j k
rG t � n Xd S( s� This is the equivalent to the raw-WMI SpawnInstance\_
method. Note that there are relatively few uses for
this, certainly fewer than you might imagine. Most
classes which need to create a new *real* instance
of themselves, eg Win32_Process, offer a .Create
method. SpawnInstance\_ is generally reserved for
instances which are passed as parameters to such
`.Create` methods, a common example being the
`Win32_SecurityDescriptor`, passed to `Win32_Share.Create`
and other instances which need security.
The example here is `Win32_ProcessStartup`, which
controls the shown/hidden state etc. of a new
`Win32_Process` instance::
import win32con
import wmi
c = wmi.WMI ()
startup = c.Win32_ProcessStartup.new (ShowWindow=win32con.SW_SHOWMINIMIZED)
pid, retval = c.Win32_Process.Create (
CommandLine="notepad.exe",
ProcessStartupInformation=startup
)
.. warning::
previous versions of this docstring illustrated using this function
to create a new process. This is *not* a good example of its use;
it is better handled with something like the example above.
N( R� t SpawnInstance_R# R� R: RY ( R
R� Rz ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt newU s
(
R R! R" R R R
R� R R R ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR� s
t _wmi_resultc B s e Z d Z d � Z RS( ss Simple, data only result for targeted WMI queries which request
data only result classes via fetch_as_classes.
c C sm | r3 x` | D] } | j | � j | j | <q
Wn6 x3 | j D]( } | j } | j | � j | j | <q= Wd S( N( R� R� R( R� ( R
Rz t
attributesR� R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s
( R R! R" R ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR } s R c B s� e Z d Z d � Z d � Z d � Z d � Z e e � Z d � Z d � Z
d d d � Z d
� Z d � Z
e
Z d � Z d g d
� Z d d � Z d � Z d d d d g d � Z d � Z d � Z d � Z RS( s� A WMI root of a computer system. The classes attribute holds a list
of the classes on offer. This means you can explore a bit with
things like this::
c = wmi.WMI ()
for i in c.classes:
if "user" in i.lower ():
print i
c C sH t | d | � t | d | � d | _ i | _ | rD | j } n d S( NR� t wmi( R{ R; t _classest _classes_mapt classes( R
R t find_classesRK ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s c C s d | j S( Ns <_wmi_namespace: %s>( R ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s c C s
t | � S( N( R ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s c C s7 | j d k r! | j � | _ n t t j | j � � S( N( R R; t
subclasses_ofR
R t fromkeys( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt _get_classes� s c C s< y t | j j | � � SWn t j k
r7 t � n Xd S( N( R� R t GetR� R: RY ( R
R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR� � s c C s | j S( s1 The raw OLE object representing the WMI namespace( R� ( R
( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt handle� s R8 s .*c sL y | j j } Wn t k
r' t � SXt � f d � | | � D� � Sd S( Nc 3 s3 | ]) } t j � | j j � r | j j Vq d S( N( R� R� R� R� ( R� t c( t regex( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pys <genexpr>� s ( R� t SubclassesOfR2 R# ( R
t rootR( R) ( ( R( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR" � s
c C sO y- g | j j | � D] } t | � ^ q SWn t j k
rJ t � n Xd S( s� Return a list of instances of the WMI class. This is
(probably) equivalent to querying with no qualifiers::
wmi.WMI ().instances ("Win32_LogicalDisk")
# should be the same as
wmi.WMI ().Win32_LogicalDisk ()
N( R� t InstancesOfR� R� R: RY ( R
R Rz ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s -c K s t | | � j | � S( s; This is now implemented by a call to :meth:`_wmi_class.new`( R R ( R
R� R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s c C s[ t t B} | j d d � } y | j j d | d | � SWn t j k
rV t � n Xd S( s� Execute a WQL query and return its raw results. Use the flags
recommended by Microsoft to achieve a read-only, semi-synchronous
query where the time is taken while looping through.
NB Backslashes need to be doubled up.
s \s \\t strQueryt iFlagsN( t wbemFlagReturnImmediatelyt wbemFlagForwardOnlyt replaceR� t ExecQueryR� R: RY ( R
R
t flags( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt
_raw_query� s
c C s, g | j | � D] } t | | | � ^ q S( sz Perform an arbitrary query against a WMI object, and return
a list of _wmi_object representations of the results.
( R3 R� ( R
R
R� R� Rz ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR
� s c K s� d | r d j | � p d | f } | rn | d d j g | j � D] \ } } d | | f ^ qD � 7} n g | j | � D] } t | | � ^ q~ S( sH Build and execute a wql query to fetch the specified list of fields from
the specified wmi_classname + where_clause, then return the results as
a list of simple class instances with attributes matching field_list.
If fields is left empty, select * and pre-load all class attributes for
each class returned.
s SELECT %s FROM %ss , Ra s WHERE s AND s %s = '%s'( R� RI R3 R ( R
t
wmi_classnameR� R R
R� R� Rz ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt fetch_as_classes� s %Cc
K s� d d j | � | f } | rb | d d j g | j � D] \ } } d | | f ^ q8 � 7} n g } xC | j | � D]2 } | j g | D] } | j | � j ^ q� � qx W| S( s� Build and execute a wql query to fetch the specified list of fields from
the specified wmi_classname + where_clause, then return the results as
a list of lists whose values correspond to field_list.
s SELECT %s FROM %ss , s WHERE s AND s %s = '%s'( R� RI R3 RF R� R� (
R
R4 R� R R
R� R� R� Rz R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt fetch_as_lists s C0R i c K s� t | t � r | j } n | } t | | � } d | j � k } | rQ | } n� t d g | pf d g � } d j | � }
| r� | r� d d j g | j � D] \ } } d | | f ^ q� � }
n d }
d |
d
| |
} nd | r+d d j g | j � D] \ } } d | | f ^ q� }
n d }
d |
| | | |
f } y& t | j j
| � d
| d | �SWn t j k
r�t
� n Xd S( sV Set up an event tracker on a WMI event. This function
returns an wmi_watcher which can be called to get the
next event::
c = wmi.WMI ()
raw_wql = "SELECT * FROM __InstanceCreationEvent WITHIN 2 WHERE TargetInstance ISA 'Win32_Process'"
watcher = c.watch_for (raw_wql=raw_wql)
while 1:
process_created = watcher ()
print process_created.Name
# or
watcher = c.watch_for (
notification_type="Creation",
wmi_class="Win32_Process",
delay_secs=2,
Name='calc.exe'
)
calc_created = watcher ()
Now supports timeout on the call to watcher::
import pythoncom
import wmi
c = wmi.WMI (privileges=["Security"])
watcher1 = c.watch_for (
notification_type="Creation",
wmi_class="Win32_NTLogEvent",
Type="error"
)
watcher2 = c.watch_for (
notification_type="Creation",
wmi_class="Win32_NTLogEvent",
Type="warning"
)
while 1:
try:
error_log = watcher1 (500)
except wmi.x_wmi_timed_out:
pythoncom.PumpWaitingMessages ()
else:
print error_log
try:
warning_log = watcher2 (500)
except wmi.x_wmi_timed_out:
pythoncom.PumpWaitingMessages ()
else:
print warning_log
t __ExtrinsicEventt TargetInstanceRa s , s WHERE s AND s %s = '%s'R8 s SELECT s FROM s TargetInstance.%s = '%s'sK SELECT %s FROM __Instance%sEvent WITHIN %d WHERE TargetInstance ISA '%s' %st is_extrinsicR� N( R� R� R R R� R# R� RI t _wmi_watcherR� t ExecNotificationQueryR� R: RY ( R
t raw_wqlR R� R R� R R R9 R
R R� R� t where( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR
s4 > ?? c C s9 y | j | � SWn! t j k
r4 t | j | � SXd S( s� Offer WMI classes as simple attributes. Pass through any untrapped
unattribute to the underlying OLE object. This means that new or
unmapped functionality is still available to the module user.
N( t _cached_classesR� R: R R� ( R
R ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR n s
c C s? | | j k r4 t | | j j | � � | j | <n | j | S( s� Standard caching helper which keeps track of classes
already retrieved by name and returns the existing object
if found. If this is the first retrieval, store it and
pass it back
( R R� R� R% ( R
R ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR> } s %c C s) g | j D] } | j d � s
| ^ q
S( s4 Return list of classes for IPython completion engineR/ ( R R0 ( R
R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR� � s N( ( R R! R" R R R R$ R� R R� R& R" R R t new_instance_ofR3 R; R
R5 R6 R R R> R� ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s0
[
R: c B s: e Z d Z i e d 6e d 6Z g d � Z d d � Z RS( s) Helper class for WMI.watch_for below (qv)R8 R� c C s | | _ | | _ | | _ d S( N( t wmi_eventR9 R� ( R
R@ R9 R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR � s i����c C s� y` | j j | � } | j r1 t | d | j � St | j d � j t | d | j �| j � SWn t
j k
r} t � n Xd S( s When called, return the instance which caused the event. Supports
timeout in milliseconds (defaulting to infinite). If the watcher
times out, :exc:`x_wmi_timed_out` is raised. This makes it easy to support
watching for multiple objects.
R8 R� N(
R@ t NextEventR9 R� R; R� R� R� R� t _event_property_mapR� R: RY ( R
t
timeout_msR� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR� � s ( R R! R" R� RB R R� ( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyR: � s
R8 c
C s� | a ywyU| r | }
n� | rL | j t � s= t | } n t | � }
n� | r� | s^ | rm t d � � q� | d k r� t d � � q� t d | d | d | d |
d | d
| d | � }
n? t d | d
| d | d | d
| d | d | � } t | � }
t |
� } | d k r"t |
| � S| d k r;t
d |
� S| d k rQt |
� St d � � Wn t
j k
r{t � n XWn t k
r�t d � � n Xd S( s� The WMI constructor can either take a ready-made moniker or as many
parts of one as are necessary. Eg::
c = wmi.WMI (moniker="winmgmts:{impersonationLevel=Delegate}//remote")
# or
c = wmi.WMI (computer="remote", privileges=["!RemoteShutdown", "Security"])
I daren't link to a Microsoft URL; they change so often. Try Googling for
WMI construct moniker and see what it comes back with.
For complete control, a named argument "wmi" can be supplied, which
should be a SWbemServices object, which you create yourself. Eg::
loc = win32com.client.Dispatch("WbemScripting.SWbemLocator")
svc = loc.ConnectServer(...)
c = wmi.WMI(wmi=svc)
This is the only way of connecting to a remote computer with a different
username, as the moniker syntax does not allow specification of a user
name.
If the `wmi` parameter is supplied, all other parameters are ignored.
s> You can't specify privileges or a suffix as well as a usernameR8 Rg s: You can only specify user/password for a remote connectiont serverR t usert passwordt authorityt impersonation_levelt authentication_levelt computerR� t suffixt classR s Unknown moniker typesu WMI returned a syntax error: you're probably running inside a thread without first calling pythoncom.CoInitialize[Ex]N( NR8 Rg ( t _DEBUGR0 t PROTOCOLR R@ R; t connect_servert construct_monikert get_wmi_typeR R� R� R7 R� R: RY RA ( RJ RH RI RG R� R� R R RK RE RF R! t debugRz t wmi_type( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt connect� sV '
c
C s> g } | r | j d | � n | r: | j d | � n | rZ | rZ | j d | � n | r} | j d d j | � � n t g } | r� | j d d j | � � n | r� | j d | � n | rt j d | � } | d
d k r� | j d
d � n | j d j | � � n | r1| j d
| � n d j | � S( Ns impersonationLevel=%ss authenticationLevel=%ss authority=%ss (%s)s , s {%s}!t ,s //%s/s [/\\]i R* t /s :%sR8 ( RF R� RN R� R t insert(
RJ RH RI RG R� R RK t securityR� t parts( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyRP s, c C s7 y
| j } Wn t k
r! d SX| j r/ d Sd Sd S( NR RL R ( R� R2 t IsClass( Rz R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyRQ . s
i� c
C s� | rM y t t j d | j � � }
WqS t k
rI t d | � � qS Xn d }
| r� y t t j d | j � � } Wq� t k
r� t d | � � q� Xn d } t d � j | | | | | | | | � } |
r� |
| j _
n | r� | | j _ n | S( s{ Return a remote server running WMI
:param server: name of the server
:param namespace: namespace to connect to - defaults to whatever's defined as default
:param user: username to connect as, either local or domain (dom\name or user@domain for XP)
:param password: leave blank to use current context
:param locale: desired locale in form MS_XXXX (eg MS_409 for Am En)
:param authority: either "Kerberos:" or an NT domain. Not needed if included in user
:param impersonation_level: valid WMI impersonation level
:param security_flags: if 0, connect will wait forever; if 0x80, connect will timeout at 2 mins
:param named_value_set: typically empty, otherwise a context-specific `SWbemNamedValueSet`
Example::
remote_connetion = wmi.connect_server (
server="remote_machine", user="myname", password="mypassword"
)
c = wmi.WMI (wmi=remote_connection)
s wbemImpersonationLevel%ss No such impersonation level: %ss wbemAuthenticationLevel%ss WbemScripting.SWbemLocatorN( R Rz R' t titleR2 R@ R; R t
ConnectServert Security_t ImpersonationLevelt AuthenticationLevel( RD R RE RF t localeRG RH RI t security_flagst named_value_sett
impersonationt authentication( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyRO 9 s4 #
t Impersonatet Defaultc C s� t j d t � | sL t d | d | d | d | d | d d d d
� } n y t t | � � SWn t j k
r} t � n Xd S( NsO This function can be implemented using wmi.WMI (namespace='DEFAULT').StdRegProvRJ RH RI RG R� R t defaultRK t
StdRegProv( R R R RP R� R R� R: RY ( RJ RH RI RG R� R� ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt Registry} s t __main__s Disks on(A R" t __VERSION__t __version__R RM RB R\ R� R R t win32com.clientR R R� R t objectR
R& Rz R' t wbemErrInvalidQueryt wbemErrTimedoutR. R/ t ExceptionR7 R< R= R> R? R@ RA RH R; RY R[ R` Rs Ry R{ R| R� R� R� R� R R R: RN RT R� RP RQ RO Ri R t systemt Win32_ComputerSystemt my_computerR� t Win32_LogicalDiskt diskt Captiont Descriptiont ProviderName( ( ( sD C:/Program Files (x86)/Alibaba/Aegis/PythonLoader/third_party\wmi.pyt <module>M s�
%
!)
l� "|� T
;