py2docfx 0.1.15.dev2025501__py3-none-any.whl → 0.1.15.dev2038808__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/win32comext/adsi/demos/search.py

@@ -1,151 +0,0 @@
-import pythoncom
-import pywintypes
-from win32com.adsi import adsi, adsicon
-from win32com.adsi.adsicon import *
-
-options = None  # set to optparse options object
-
-ADsTypeNameMap = {}
-
-
-def getADsTypeName(type_val):
-    # convert integer type to the 'typename' as known in the headerfiles.
-    if not ADsTypeNameMap:
-        for n, v in adsicon.__dict__.items():
-            if n.startswith("ADSTYPE_"):
-                ADsTypeNameMap[v] = n
-    return ADsTypeNameMap.get(type_val, hex(type_val))
-
-
-def _guid_from_buffer(b):
-    return pywintypes.IID(b, True)
-
-
-def _sid_from_buffer(b):
-    return str(pywintypes.SID(b))
-
-
-_null_converter = lambda x: x
-
-converters = {
-    "objectGUID": _guid_from_buffer,
-    "objectSid": _sid_from_buffer,
-    "instanceType": getADsTypeName,
-}
-
-
-def log(level, msg, *args):
-    if options.verbose >= level:
-        print("log:", msg % args)
-
-
-def getGC():
-    cont = adsi.ADsOpenObject(
-        "GC:", options.user, options.password, 0, adsi.IID_IADsContainer
-    )
-    enum = adsi.ADsBuildEnumerator(cont)
-    # Only 1 child of the global catalog.
-    for e in enum:
-        gc = e.QueryInterface(adsi.IID_IDirectorySearch)
-        return gc
-    return None
-
-
-def print_attribute(col_data):
-    prop_name, prop_type, values = col_data
-    if values is not None:
-        log(2, "property '%s' has type '%s'", prop_name, getADsTypeName(prop_type))
-        value = [converters.get(prop_name, _null_converter)(v[0]) for v in values]
-        if len(value) == 1:
-            value = value[0]
-        print(f" {prop_name}={value!r}")
-    else:
-        print(f" {prop_name} is None")
-
-
-def search():
-    gc = getGC()
-    if gc is None:
-        log(0, "Can't find the global catalog")
-        return
-
-    prefs = [(ADS_SEARCHPREF_SEARCH_SCOPE, (ADS_SCOPE_SUBTREE,))]
-    hr, statuses = gc.SetSearchPreference(prefs)
-    log(3, "SetSearchPreference returned %d/%r", hr, statuses)
-
-    if options.attributes:
-        attributes = options.attributes.split(",")
-    else:
-        attributes = None
-
-    h = gc.ExecuteSearch(options.filter, attributes)
-    hr = gc.GetNextRow(h)
-    while hr != S_ADS_NOMORE_ROWS:
-        print("-- new row --")
-        if attributes is None:
-            # Loop over all columns returned
-            while 1:
-                col_name = gc.GetNextColumnName(h)
-                if col_name is None:
-                    break
-                data = gc.GetColumn(h, col_name)
-                print_attribute(data)
-        else:
-            # loop over attributes specified.
-            for a in attributes:
-                try:
-                    data = gc.GetColumn(h, a)
-                    print_attribute(data)
-                except adsi.error as details:
-                    if details[0] != E_ADS_COLUMN_NOT_SET:
-                        raise
-                    print_attribute((a, None, None))
-        hr = gc.GetNextRow(h)
-    gc.CloseSearchHandle(h)
-
-
-def main():
-    global options
-    from optparse import OptionParser
-
-    parser = OptionParser()
-    parser.add_option(
-        "-f", "--file", dest="filename", help="write report to FILE", metavar="FILE"
-    )
-    parser.add_option(
-        "-v",
-        "--verbose",
-        action="count",
-        default=1,
-        help="increase verbosity of output",
-    )
-    parser.add_option(
-        "-q", "--quiet", action="store_true", help="suppress output messages"
-    )
-
-    parser.add_option("-U", "--user", help="specify the username used to connect")
-    parser.add_option("-P", "--password", help="specify the password used to connect")
-    parser.add_option(
-        "",
-        "--filter",
-        default="(&(objectCategory=person)(objectClass=User))",
-        help="specify the search filter",
-    )
-    parser.add_option(
-        "", "--attributes", help="comma sep'd list of attribute names to print"
-    )
-
-    options, args = parser.parse_args()
-    if options.quiet:
-        if options.verbose != 1:
-            parser.error("Can not use '--verbose' and '--quiet'")
-        options.verbose = 0
-
-    if args:
-        parser.error("You need not specify args")
-
-    search()
-
-
-if __name__ == "__main__":
-    main()

py2docfx/venv/venv1/Lib/site-packages/win32comext/adsi/demos/test.py

@@ -1,274 +0,0 @@
-import sys
-from collections.abc import Callable
-
-import pythoncom
-import win32api
-from win32com.adsi import *
-
-verbose_level = 0
-
-server = ""  # Must have trailing /
-local_name = win32api.GetComputerName()
-
-
-def DumpRoot():
-    "Dumps the root DSE"
-    path = "LDAP://%srootDSE" % server
-    rootdse = ADsGetObject(path)
-
-    for item in rootdse.Get("SupportedLDAPVersion"):
-        print(f"{path} supports ldap version {item}")
-
-    attributes = ["CurrentTime", "defaultNamingContext"]
-    for attr in attributes:
-        val = rootdse.Get(attr)
-        print(f" {attr}={val}")
-
-
-###############################################
-#
-# Code taken from article titled:
-# Reading attributeSchema and classSchema Objects
-def _DumpClass(child):
-    attrs = "Abstract lDAPDisplayName schemaIDGUID schemaNamingContext attributeSyntax oMSyntax"
-    _DumpTheseAttributes(child, attrs.split())
-
-
-def _DumpAttribute(child):
-    attrs = "lDAPDisplayName schemaIDGUID adminDescription adminDisplayName rDNAttID defaultHidingValue defaultObjectCategory systemOnly defaultSecurityDescriptor"
-    _DumpTheseAttributes(child, attrs.split())
-
-
-def _DumpTheseAttributes(child, attrs):
-    for attr in attrs:
-        try:
-            val = child.Get(attr)
-        except pythoncom.com_error as details:
-            continue
-            # ###
-            (hr, msg, exc, arg) = details
-            if exc and exc[2]:
-                msg = exc[2]
-            val = f"<Error: {msg}>"
-        if verbose_level >= 2:
-            print(f" {child.Class}: {attr}={val}")
-
-
-def DumpSchema():
-    "Dumps the default DSE schema"
-    # Bind to rootDSE to get the schemaNamingContext property.
-    path = "LDAP://%srootDSE" % server
-    rootdse = ADsGetObject(path)
-    name = rootdse.Get("schemaNamingContext")
-
-    # Bind to the actual schema container.
-    path = "LDAP://" + server + name
-    print("Binding to", path)
-    ob = ADsGetObject(path)
-    nclasses = nattr = nsub = nunk = 0
-
-    # Enumerate the attribute and class objects in the schema container.
-    for child in ob:
-        # Find out if this is a class, attribute, or subSchema object.
-        class_name = child.Class
-        if class_name == "classSchema":
-            _DumpClass(child)
-            nclasses += 1
-        elif class_name == "attributeSchema":
-            _DumpAttribute(child)
-            nattr += 1
-        elif class_name == "subSchema":
-            nsub += 1
-        else:
-            print("Unknown class:", class_name)
-            nunk += 1
-    if verbose_level:
-        print("Processed", nclasses, "classes")
-        print("Processed", nattr, "attributes")
-        print("Processed", nsub, "sub-schema's")
-        print("Processed", nunk, "unknown types")
-
-
-def _DumpObject(ob, level=0):
-    prefix = "  " * level
-    print(f"{prefix}{ob.Class} object: {ob.Name}")
-    # Do the directory object thing
-    try:
-        dir_ob = ADsGetObject(ob.ADsPath, IID_IDirectoryObject)
-    except pythoncom.com_error:
-        dir_ob = None
-    if dir_ob is not None:
-        info = dir_ob.GetObjectInformation()
-        print(f"{prefix} RDN='{info.RDN}', ObjectDN='{info.ObjectDN}'")
-        # Create a list of names to fetch
-        names = ["distinguishedName"]
-        attrs = dir_ob.GetObjectAttributes(names)
-        for attr in attrs:
-            for val, typ in attr.Values:
-                print(f"{prefix} Attribute '{attr.AttrName}' = {val}")
-
-    for child in ob:
-        _DumpObject(child, level + 1)
-
-
-def DumpAllObjects():
-    "Recursively dump the entire directory!"
-    path = "LDAP://%srootDSE" % server
-    rootdse = ADsGetObject(path)
-    name = rootdse.Get("defaultNamingContext")
-
-    # Bind to the actual schema container.
-    path = "LDAP://" + server + name
-    print("Binding to", path)
-    ob = ADsGetObject(path)
-
-    # Enumerate the attribute and class objects in the schema container.
-    _DumpObject(ob)
-
-
-##########################################################
-#
-# Code taken from article:
-# Example Code for Enumerating Schema Classes, Attributes, and Syntaxes
-
-# Fill a map with VT_ datatypes, to give us better names:
-vt_map = {}
-for name, val in pythoncom.__dict__.items():
-    if name[:3] == "VT_":
-        vt_map[val] = name
-
-
-def DumpSchema2():
-    "Dumps the schema using an alternative technique"
-    path = f"LDAP://{server}schema"
-    schema = ADsGetObject(path, IID_IADsContainer)
-    nclass = nprop = nsyntax = 0
-    for item in schema:
-        item_class = item.Class.lower()
-        if item_class == "class":
-            items = []
-            if item.Abstract:
-                items.append("Abstract")
-            if item.Auxiliary:
-                items.append("Auxiliary")
-            # 			if item.Structural: items.append("Structural")
-            desc = ", ".join(items)
-            import win32com.util
-
-            iid_name = win32com.util.IIDToInterfaceName(item.PrimaryInterface)
-            if verbose_level >= 2:
-                print(
-                    "Class: Name={}, Flags={}, Primary Interface={}".format(
-                        item.Name, desc, iid_name
-                    )
-                )
-            nclass += 1
-        elif item_class == "property":
-            if item.MultiValued:
-                val_type = "Multi-Valued"
-            else:
-                val_type = "Single-Valued"
-            if verbose_level >= 2:
-                print(f"Property: Name={item.Name}, {val_type}")
-            nprop += 1
-        elif item_class == "syntax":
-            data_type = vt_map.get(item.OleAutoDataType, "<unknown type>")
-            if verbose_level >= 2:
-                print(f"Syntax: Name={item.Name}, Datatype = {data_type}")
-            nsyntax += 1
-    if verbose_level >= 1:
-        print("Processed", nclass, "classes")
-        print("Processed", nprop, "properties")
-        print("Processed", nsyntax, "syntax items")
-
-
-def DumpGC():
-    "Dumps the GC: object (whatever that is!)"
-    ob = ADsGetObject("GC:", IID_IADsContainer)
-    for sub_ob in ob:
-        print(f"GC ob: {sub_ob.Name} ({sub_ob.ADsPath})")
-
-
-def DumpLocalUsers():
-    "Dumps the local machine users"
-    path = f"WinNT://{local_name},computer"
-    ob = ADsGetObject(path, IID_IADsContainer)
-    ob.put_Filter(["User", "Group"])
-    for sub_ob in ob:
-        print(f"User/Group: {sub_ob.Name} ({sub_ob.ADsPath})")
-
-
-def DumpLocalGroups():
-    "Dumps the local machine groups"
-    path = f"WinNT://{local_name},computer"
-    ob = ADsGetObject(path, IID_IADsContainer)
-
-    ob.put_Filter(["Group"])
-    for sub_ob in ob:
-        print(f"Group: {sub_ob.Name} ({sub_ob.ADsPath})")
-        # get the members
-        members = sub_ob.Members()
-        for member in members:
-            print(f"  Group member: {member.Name} ({member.ADsPath})")
-
-
-def usage(tests):
-    import os
-
-    print("Usage: %s [-s server ] [-v] [Test ...]" % os.path.basename(sys.argv[0]))
-    print("  -v : Verbose - print more information")
-    print("  -s : server - execute the tests against the named server")
-    print("where Test is one of:")
-    for t in tests:
-        print(t.__name__, ":", t.__doc__)
-    print()
-    print("If not tests are specified, all tests are run")
-    sys.exit(1)
-
-
-def main():
-    import getopt
-    import traceback
-
-    tests = []
-    for ob in globals().values():
-        if isinstance(ob, Callable) and ob.__doc__:
-            tests.append(ob)
-    opts, args = getopt.getopt(sys.argv[1:], "s:hv")
-    for opt, val in opts:
-        if opt == "-s":
-            if val[-1] not in "\\/":
-                val += "/"
-            global server
-            server = val
-        if opt == "-h":
-            usage(tests)
-        if opt == "-v":
-            global verbose_level
-            verbose_level += 1
-
-    if len(args) == 0:
-        print("Running all tests - use '-h' to see command-line options...")
-        dotests = tests
-    else:
-        dotests = []
-        for arg in args:
-            for t in tests:
-                if t.__name__ == arg:
-                    dotests.append(t)
-                    break
-            else:
-                print("Test '%s' unknown - skipping" % arg)
-    if not len(dotests):
-        print("Nothing to do!")
-        usage(tests)
-    for test in dotests:
-        try:
-            test()
-        except:
-            print("Test %s failed" % test.__name__)
-            traceback.print_exc()
-
-
-if __name__ == "__main__":
-    main()

py2docfx/venv/venv1/Lib/site-packages/win32comext/authorization/__init__.py

@@ -1,6 +0,0 @@
-# This is a python package
-# __PackageSupportBuildPath__ not needed for distutil based builds,
-# but not everyone is there yet.
-import win32com
-
-win32com.__PackageSupportBuildPath__(__path__)

py2docfx/venv/venv1/Lib/site-packages/win32comext/authorization/demos/EditSecurity.py

@@ -1,229 +0,0 @@
-import os
-
-import pythoncom
-import win32api
-import win32com.server.policy
-import win32con
-import win32security
-from ntsecuritycon import (
-    FILE_ALL_ACCESS,
-    FILE_APPEND_DATA,
-    FILE_GENERIC_EXECUTE,
-    FILE_GENERIC_READ,
-    FILE_GENERIC_WRITE,
-    FILE_WRITE_DATA,
-    READ_CONTROL,
-    SI_ACCESS_GENERAL,
-    SI_ACCESS_SPECIFIC,
-    SI_ADVANCED,
-    SI_CONTAINER,
-    SI_EDIT_ALL,
-    SI_PAGE_TITLE,
-    SI_RESET,
-    WRITE_DAC,
-    WRITE_OWNER,
-)
-from pythoncom import IID_NULL
-from win32com.authorization import authorization
-from win32security import CONTAINER_INHERIT_ACE, OBJECT_INHERIT_ACE
-
-
-class SecurityInformation(win32com.server.policy.DesignatedWrapPolicy):
-    _com_interfaces_ = [authorization.IID_ISecurityInformation]
-    _public_methods_ = [
-        "GetObjectInformation",
-        "GetSecurity",
-        "SetSecurity",
-        "GetAccessRights",
-        "GetInheritTypes",
-        "MapGeneric",
-        "PropertySheetPageCallback",
-    ]
-
-    def __init__(self, FileName):
-        self.FileName = FileName
-        self._wrap_(self)
-
-    def GetObjectInformation(self):
-        """Identifies object whose security will be modified, and determines options available
-        to the end user"""
-        flags = SI_ADVANCED | SI_EDIT_ALL | SI_PAGE_TITLE | SI_RESET
-        if os.path.isdir(self.FileName):
-            flags |= SI_CONTAINER
-        hinstance = 0  ## handle to module containing string resources
-        servername = ""  ## name of authenticating server if not local machine
-        objectname = os.path.split(self.FileName)[1]
-        pagetitle = "Python ACL Editor"
-        if os.path.isdir(self.FileName):
-            pagetitle += " (dir)"
-        else:
-            pagetitle += " (file)"
-        objecttype = IID_NULL
-        return flags, hinstance, servername, objectname, pagetitle, objecttype
-
-    def GetSecurity(self, requestedinfo, bdefault):
-        """Requests the existing permissions for object"""
-        if bdefault:
-            ## This is invoked if the 'Default' button is pressed (only present if SI_RESET is passed
-            ## with the flags in GetObjectInfo). Passing an empty SD with a NULL Dacl
-            ##  should cause inherited ACL from parent dir or default dacl from user's token to be used
-            return win32security.SECURITY_DESCRIPTOR()
-        else:
-            ## GetFileSecurity sometimes fails to return flags indicating that an ACE is inherited
-            return win32security.GetNamedSecurityInfo(
-                self.FileName, win32security.SE_FILE_OBJECT, requestedinfo
-            )
-
-    def SetSecurity(self, requestedinfo, sd):
-        """Applies permissions to the object"""
-        owner = sd.GetSecurityDescriptorOwner()
-        group = sd.GetSecurityDescriptorGroup()
-        dacl = sd.GetSecurityDescriptorDacl()
-        sacl = sd.GetSecurityDescriptorSacl()
-        win32security.SetNamedSecurityInfo(
-            self.FileName,
-            win32security.SE_FILE_OBJECT,
-            requestedinfo,
-            owner,
-            group,
-            dacl,
-            sacl,
-        )
-        ## should also handle recursive operations here
-
-    def GetAccessRights(self, objecttype, flags):
-        """Returns a tuple of (AccessRights, DefaultAccess), where AccessRights is a sequence of tuples representing
-        SI_ACCESS structs, containing (guid, access mask, Name, flags). DefaultAccess indicates which of the
-        AccessRights will be used initially when a new ACE is added (zero based).
-        Flags can contain SI_ACCESS_SPECIFIC,SI_ACCESS_GENERAL,SI_ACCESS_CONTAINER,SI_ACCESS_PROPERTY,
-              CONTAINER_INHERIT_ACE,INHERIT_ONLY_ACE,OBJECT_INHERIT_ACE
-        """
-        ## input flags: SI_ADVANCED,SI_EDIT_AUDITS,SI_EDIT_PROPERTIES indicating which property sheet is requesting the rights
-        if (objecttype is not None) and (objecttype != IID_NULL):
-            ## Should not be true for file objects.  Usually only used with DS objects that support security for
-            ## their properties
-            raise NotImplementedError("Object type is not supported")
-
-        if os.path.isdir(self.FileName):
-            file_append_data_desc = "Create subfolders"
-            file_write_data_desc = "Create Files"
-        else:
-            file_append_data_desc = "Append data"
-            file_write_data_desc = "Write data"
-
-        accessrights = [
-            (
-                IID_NULL,
-                FILE_GENERIC_READ,
-                "Generic read",
-                SI_ACCESS_GENERAL
-                | SI_ACCESS_SPECIFIC
-                | OBJECT_INHERIT_ACE
-                | CONTAINER_INHERIT_ACE,
-            ),
-            (
-                IID_NULL,
-                FILE_GENERIC_WRITE,
-                "Generic write",
-                SI_ACCESS_GENERAL
-                | SI_ACCESS_SPECIFIC
-                | OBJECT_INHERIT_ACE
-                | CONTAINER_INHERIT_ACE,
-            ),
-            (
-                IID_NULL,
-                win32con.DELETE,
-                "Delete",
-                SI_ACCESS_SPECIFIC | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
-            ),
-            (
-                IID_NULL,
-                WRITE_OWNER,
-                "Change owner",
-                SI_ACCESS_SPECIFIC | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
-            ),
-            (
-                IID_NULL,
-                READ_CONTROL,
-                "Read Permissions",
-                SI_ACCESS_SPECIFIC | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
-            ),
-            (
-                IID_NULL,
-                WRITE_DAC,
-                "Change permissions",
-                SI_ACCESS_SPECIFIC | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
-            ),
-            (
-                IID_NULL,
-                FILE_APPEND_DATA,
-                file_append_data_desc,
-                SI_ACCESS_SPECIFIC | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
-            ),
-            (
-                IID_NULL,
-                FILE_WRITE_DATA,
-                file_write_data_desc,
-                SI_ACCESS_SPECIFIC | OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE,
-            ),
-        ]
-        return (accessrights, 0)
-
-    def MapGeneric(self, guid, aceflags, mask):
-        """Converts generic access rights to specific rights.  This implementation uses standard file system rights,
-        but you can map them any way that suits your application.
-        """
-        return win32security.MapGenericMask(
-            mask,
-            (
-                FILE_GENERIC_READ,
-                FILE_GENERIC_WRITE,
-                FILE_GENERIC_EXECUTE,
-                FILE_ALL_ACCESS,
-            ),
-        )
-
-    def GetInheritTypes(self):
-        """Specifies which types of ACE inheritance are supported.
-        Returns a sequence of tuples representing SI_INHERIT_TYPE structs, containing
-        (object type guid, inheritance flags, display name).  Guid is usually only used with
-        Directory Service objects.
-        """
-        return (
-            (IID_NULL, 0, "Only current object"),
-            (IID_NULL, OBJECT_INHERIT_ACE, "Files inherit permissions"),
-            (IID_NULL, CONTAINER_INHERIT_ACE, "Sub Folders inherit permissions"),
-            (
-                IID_NULL,
-                CONTAINER_INHERIT_ACE | OBJECT_INHERIT_ACE,
-                "Files and subfolders",
-            ),
-        )
-
-    def PropertySheetPageCallback(self, hwnd, msg, pagetype):
-        """Invoked each time a property sheet page is created or destroyed."""
-        ## page types from SI_PAGE_TYPE enum: SI_PAGE_PERM SI_PAGE_ADVPERM SI_PAGE_AUDIT SI_PAGE_OWNER
-        ## msg: PSPCB_CREATE, PSPCB_RELEASE, PSPCB_SI_INITDIALOG
-        return None
-
-    def EditSecurity(self, owner_hwnd=0):
-        """Creates an ACL editor dialog based on parameters returned by interface methods"""
-        isi = pythoncom.WrapObject(
-            self, authorization.IID_ISecurityInformation, pythoncom.IID_IUnknown
-        )
-        authorization.EditSecurity(owner_hwnd, isi)
-
-
-## folder permissions
-temp_dir = win32api.GetTempPath()
-dir_name = win32api.GetTempFileName(temp_dir, "isi")[0]
-print(dir_name)
-os.remove(dir_name)
-os.mkdir(dir_name)
-si = SecurityInformation(dir_name)
-si.EditSecurity()
-
-## file permissions
-fname = win32api.GetTempFileName(dir_name, "isi")[0]
-si = SecurityInformation(fname)
-si.EditSecurity()