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

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

@@ -1,219 +0,0 @@
-r"""
-Implements a permissions editor for services.
-Service can be specified as plain name for local machine,
-or as a remote service of the form \\machinename\service
-"""
-
-import os
-
-import pythoncom
-import win32com.server.policy
-import win32con
-import win32security
-import win32service
-from win32com.authorization import authorization
-
-SERVICE_GENERIC_EXECUTE = (
-    win32service.SERVICE_START
-    | win32service.SERVICE_STOP
-    | win32service.SERVICE_PAUSE_CONTINUE
-    | win32service.SERVICE_USER_DEFINED_CONTROL
-)
-SERVICE_GENERIC_READ = (
-    win32service.SERVICE_QUERY_CONFIG
-    | win32service.SERVICE_QUERY_STATUS
-    | win32service.SERVICE_INTERROGATE
-    | win32service.SERVICE_ENUMERATE_DEPENDENTS
-)
-SERVICE_GENERIC_WRITE = win32service.SERVICE_CHANGE_CONFIG
-
-from ntsecuritycon import (
-    READ_CONTROL,
-    SI_ACCESS_GENERAL,
-    SI_ACCESS_SPECIFIC,
-    SI_ADVANCED,
-    SI_EDIT_ALL,
-    SI_PAGE_TITLE,
-    SI_RESET,
-    WRITE_DAC,
-    WRITE_OWNER,
-)
-from pythoncom import IID_NULL
-
-
-class ServiceSecurity(win32com.server.policy.DesignatedWrapPolicy):
-    _com_interfaces_ = [authorization.IID_ISecurityInformation]
-    _public_methods_ = [
-        "GetObjectInformation",
-        "GetSecurity",
-        "SetSecurity",
-        "GetAccessRights",
-        "GetInheritTypes",
-        "MapGeneric",
-        "PropertySheetPageCallback",
-    ]
-
-    def __init__(self, ServiceName):
-        self.ServiceName = ServiceName
-        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
-        hinstance = 0  ## handle to module containing string resources
-        servername = ""  ## name of authenticating server if not local machine
-
-        ## service name can contain remote machine name of the form \\Server\ServiceName
-        objectname = os.path.split(self.ServiceName)[1]
-        pagetitle = "Service Permissions for " + self.ServiceName
-        objecttype = IID_NULL
-        return flags, hinstance, servername, objectname, pagetitle, objecttype
-
-    def GetSecurity(self, requestedinfo, bdefault):
-        """Requests the existing permissions for object"""
-        if bdefault:
-            return win32security.SECURITY_DESCRIPTOR()
-        else:
-            return win32security.GetNamedSecurityInfo(
-                self.ServiceName, win32security.SE_SERVICE, 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.ServiceName,
-            win32security.SE_SERVICE,
-            requestedinfo,
-            owner,
-            group,
-            dacl,
-            sacl,
-        )
-
-    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):
-            ## Not relevent for services
-            raise NotImplementedError("Object type is not supported")
-
-        ## ???? for some reason, the DACL for a service will not retain ACCESS_SYSTEM_SECURITY in an ACE ????
-        ## (IID_NULL, win32con.ACCESS_SYSTEM_SECURITY, 'View/change audit settings', SI_ACCESS_SPECIFIC),
-
-        accessrights = [
-            (
-                IID_NULL,
-                win32service.SERVICE_ALL_ACCESS,
-                "Full control",
-                SI_ACCESS_GENERAL,
-            ),
-            (IID_NULL, SERVICE_GENERIC_READ, "Generic read", SI_ACCESS_GENERAL),
-            (IID_NULL, SERVICE_GENERIC_WRITE, "Generic write", SI_ACCESS_GENERAL),
-            (
-                IID_NULL,
-                SERVICE_GENERIC_EXECUTE,
-                "Start/Stop/Pause service",
-                SI_ACCESS_GENERAL,
-            ),
-            (IID_NULL, READ_CONTROL, "Read Permissions", SI_ACCESS_GENERAL),
-            (IID_NULL, WRITE_DAC, "Change permissions", SI_ACCESS_GENERAL),
-            (IID_NULL, WRITE_OWNER, "Change owner", SI_ACCESS_GENERAL),
-            (IID_NULL, win32con.DELETE, "Delete service", SI_ACCESS_GENERAL),
-            (IID_NULL, win32service.SERVICE_START, "Start service", SI_ACCESS_SPECIFIC),
-            (IID_NULL, win32service.SERVICE_STOP, "Stop service", SI_ACCESS_SPECIFIC),
-            (
-                IID_NULL,
-                win32service.SERVICE_PAUSE_CONTINUE,
-                "Pause/unpause service",
-                SI_ACCESS_SPECIFIC,
-            ),
-            (
-                IID_NULL,
-                win32service.SERVICE_USER_DEFINED_CONTROL,
-                "Execute user defined operations",
-                SI_ACCESS_SPECIFIC,
-            ),
-            (
-                IID_NULL,
-                win32service.SERVICE_QUERY_CONFIG,
-                "Read configuration",
-                SI_ACCESS_SPECIFIC,
-            ),
-            (
-                IID_NULL,
-                win32service.SERVICE_CHANGE_CONFIG,
-                "Change configuration",
-                SI_ACCESS_SPECIFIC,
-            ),
-            (
-                IID_NULL,
-                win32service.SERVICE_ENUMERATE_DEPENDENTS,
-                "List dependent services",
-                SI_ACCESS_SPECIFIC,
-            ),
-            (
-                IID_NULL,
-                win32service.SERVICE_QUERY_STATUS,
-                "Query status",
-                SI_ACCESS_SPECIFIC,
-            ),
-            (
-                IID_NULL,
-                win32service.SERVICE_INTERROGATE,
-                "Query status (immediate)",
-                SI_ACCESS_SPECIFIC,
-            ),
-        ]
-        return (accessrights, 0)
-
-    def MapGeneric(self, guid, aceflags, mask):
-        """Converts generic access rights to specific rights."""
-        return win32security.MapGenericMask(
-            mask,
-            (
-                SERVICE_GENERIC_READ,
-                SERVICE_GENERIC_WRITE,
-                SERVICE_GENERIC_EXECUTE,
-                win32service.SERVICE_ALL_ACCESS,
-            ),
-        )
-
-    def GetInheritTypes(self):
-        """Specifies which types of ACE inheritance are supported.
-        Services don't use any inheritance
-        """
-        return ((IID_NULL, 0, "Only current object"),)
-
-    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)
-
-
-if __name__ == "__main__":
-    # Find the first service on local machine and edit its permissions
-    scm = win32service.OpenSCManager(
-        None, None, win32service.SC_MANAGER_ENUMERATE_SERVICE
-    )
-    svcs = win32service.EnumServicesStatus(scm)
-    win32service.CloseServiceHandle(scm)
-    si = ServiceSecurity(svcs[0][0])
-    si.EditSecurity()

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

@@ -1,4 +0,0 @@
-# See if we have a special directory for the binaries (for developers)
-import win32com
-
-win32com.__PackageSupportBuildPath__(__path__)

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

@@ -1,4 +0,0 @@
-# See if we have a special directory for the binaries (for developers)
-import win32com
-
-win32com.__PackageSupportBuildPath__(__path__)

py2docfx/venv/venv1/Lib/site-packages/win32comext/axdebug/adb.py

@@ -1,467 +0,0 @@
-"""The glue between the Python debugger interface and the Active Debugger interface"""
-
-import _thread
-import bdb
-import os
-import sys
-import traceback
-
-import pythoncom
-import win32api
-import win32com.client.connect
-from win32com.axdebug.util import _wrap, trace
-
-from . import axdebug, gateways, stackframe
-
-
-def fnull(*args):
-    pass
-
-
-debugging = "DEBUG_AXDEBUG" in os.environ
-traceenter = fnull  # trace enter of functions
-tracev = fnull  # verbose trace
-
-if debugging:
-    traceenter = trace  # trace enter of functions
-    tracev = trace  # verbose trace
-
-
-class OutputReflector:
-    def __init__(self, file, writefunc):
-        self.writefunc = writefunc
-        self.file = file
-
-    def __getattr__(self, name):
-        return getattr(self.file, name)
-
-    def write(self, message):
-        self.writefunc(message)
-        self.file.write(message)
-
-
-def _dumpf(frame):
-    if frame is None:
-        return "<None>"
-    else:
-        addn = "(with trace!)"
-        if frame.f_trace is None:
-            addn = " **No Trace Set **"
-        return f"Frame at {id(frame)}, file {frame.f_code.co_filename}, line: {frame.f_lineno}{addn}"
-
-
-g_adb = None
-
-
-def OnSetBreakPoint(codeContext, breakPointState, lineNo):
-    try:
-        fileName = codeContext.codeContainer.GetFileName()
-        # inject the code into linecache.
-        import linecache
-
-        linecache.cache[fileName] = 0, 0, codeContext.codeContainer.GetText(), fileName
-        g_adb._OnSetBreakPoint(fileName, codeContext, breakPointState, lineNo + 1)
-    except:
-        traceback.print_exc()
-
-
-class Adb(bdb.Bdb, gateways.RemoteDebugApplicationEvents):
-    def __init__(self):
-        self.debugApplication = None
-        self.debuggingThread = None
-        self.debuggingThreadStateHandle = None
-        self.stackSnifferCookie = self.stackSniffer = None
-        self.codeContainerProvider = None
-        self.debuggingThread = None
-        self.breakFlags = None
-        self.breakReason = None
-        self.appDebugger = None
-        self.appEventConnection = None
-        self.logicalbotframe = None  # Anything at this level or below does not exist!
-        self.currentframe = None  # The frame we are currently in.
-        self.recursiveData = []  # Data saved for each reentery on this thread.
-        bdb.Bdb.__init__(self)
-        self._threadprotectlock = _thread.allocate_lock()
-        self.reset()
-
-    def canonic(self, fname):
-        if fname[0] == "<":
-            return fname
-        return bdb.Bdb.canonic(self, fname)
-
-    def reset(self):
-        traceenter("adb.reset")
-        bdb.Bdb.reset(self)
-
-    def __xxxxx__set_break(self, filename, lineno, cond=None):
-        # As per standard one, except no linecache checking!
-        if filename not in self.breaks:
-            self.breaks[filename] = []
-        list = self.breaks[filename]
-        if lineno in list:
-            return "There is already a breakpoint there!"
-        list.append(lineno)
-        if cond is not None:
-            self.cbreaks[filename, lineno] = cond
-
-    def stop_here(self, frame):
-        traceenter("stop_here", _dumpf(frame), _dumpf(self.stopframe))
-        # As per bdb.stop_here, except for logicalbotframe
-        # if self.stopframe is None:
-        #     return 1
-        if frame is self.stopframe:
-            return 1
-
-        tracev("stop_here said 'No'!")
-        return 0
-
-    def break_here(self, frame):
-        traceenter("break_here", self.breakFlags, _dumpf(frame))
-        self.breakReason = None
-        if self.breakFlags == axdebug.APPBREAKFLAG_DEBUGGER_HALT:
-            self.breakReason = axdebug.BREAKREASON_DEBUGGER_HALT
-        elif self.breakFlags == axdebug.APPBREAKFLAG_DEBUGGER_BLOCK:
-            self.breakReason = axdebug.BREAKREASON_DEBUGGER_BLOCK
-        elif self.breakFlags == axdebug.APPBREAKFLAG_STEP:
-            self.breakReason = axdebug.BREAKREASON_STEP
-        else:
-            print("Calling base 'break_here' with", self.breaks)
-            if bdb.Bdb.break_here(self, frame):
-                self.breakReason = axdebug.BREAKREASON_BREAKPOINT
-        return self.breakReason is not None
-
-    def break_anywhere(self, frame):
-        traceenter("break_anywhere", _dumpf(frame))
-        if self.breakFlags == axdebug.APPBREAKFLAG_DEBUGGER_HALT:
-            self.breakReason = axdebug.BREAKREASON_DEBUGGER_HALT
-            return 1
-        rc = bdb.Bdb.break_anywhere(self, frame)
-        tracev("break_anywhere", _dumpf(frame), "returning", rc)
-        return rc
-
-    def dispatch_return(self, frame, arg):
-        traceenter("dispatch_return", _dumpf(frame), arg)
-        if self.logicalbotframe is frame:
-            # We don't want to debug parent frames.
-            tracev("dispatch_return resetting sys.trace")
-            sys.settrace(None)
-            return
-        # self.bSetTrace = 0
-        self.currentframe = frame.f_back
-        return bdb.Bdb.dispatch_return(self, frame, arg)
-
-    def dispatch_line(self, frame):
-        traceenter("dispatch_line", _dumpf(frame), _dumpf(self.botframe))
-        # trace("logbotframe is", _dumpf(self.logicalbotframe), "botframe is", self.botframe)
-        if frame is self.logicalbotframe:
-            trace("dispatch_line", _dumpf(frame), "for bottom frame returing tracer")
-            # The next code executed in the frame above may be a builtin (eg, apply())
-            # in which sys.trace needs to be set.
-            sys.settrace(self.trace_dispatch)
-            # And return the tracer incase we are about to execute Python code,
-            # in which case sys tracer is ignored!
-            return self.trace_dispatch
-
-        if self.codeContainerProvider.FromFileName(frame.f_code.co_filename) is None:
-            trace(
-                "dispatch_line has no document for", _dumpf(frame), "- skipping trace!"
-            )
-            return None
-        self.currentframe = (
-            frame  # So the stack sniffer knows our most recent, debuggable code.
-        )
-        return bdb.Bdb.dispatch_line(self, frame)
-
-    def dispatch_call(self, frame, arg):
-        traceenter("dispatch_call", _dumpf(frame))
-        frame.f_locals["__axstack_address__"] = axdebug.GetStackAddress()
-        if frame is self.botframe:
-            trace("dispatch_call is self.botframe - returning tracer")
-            return self.trace_dispatch
-        # Not our bottom frame.  If we have a document for it,
-        # then trace it, otherwise run at full speed.
-        if self.codeContainerProvider.FromFileName(frame.f_code.co_filename) is None:
-            trace(
-                "dispatch_call has no document for", _dumpf(frame), "- skipping trace!"
-            )
-            # sys.settrace(None)
-            return None
-        return self.trace_dispatch
-
-        # rc =  bdb.Bdb.dispatch_call(self, frame, arg)
-        # trace("dispatch_call", _dumpf(frame),"returned",rc)
-        # return rc
-
-    def trace_dispatch(self, frame, event, arg):
-        traceenter("trace_dispatch", _dumpf(frame), event, arg)
-        if self.debugApplication is None:
-            trace("trace_dispatch has no application!")
-            return  # None
-        return bdb.Bdb.trace_dispatch(self, frame, event, arg)
-
-    #
-    # The user functions do bugger all!
-    #
-    # def user_call(self, frame, argument_list):
-    #     traceenter("user_call",_dumpf(frame))
-
-    def user_line(self, frame):
-        traceenter("user_line", _dumpf(frame))
-        # Traces at line zero
-        if frame.f_lineno != 0:
-            breakReason = self.breakReason
-            if breakReason is None:
-                breakReason = axdebug.BREAKREASON_STEP
-            self._HandleBreakPoint(frame, None, breakReason)
-
-    def user_return(self, frame, return_value):
-        # traceenter("user_return",_dumpf(frame),return_value)
-        bdb.Bdb.user_return(self, frame, return_value)
-
-    def user_exception(self, frame, exc_info):
-        # traceenter("user_exception")
-        bdb.Bdb.user_exception(self, frame, exc_info)
-
-    def _HandleBreakPoint(self, frame, tb, reason):
-        traceenter(
-            "Calling HandleBreakPoint with reason", reason, "at frame", _dumpf(frame)
-        )
-        traceenter(" Current frame is", _dumpf(self.currentframe))
-        try:
-            resumeAction = self.debugApplication.HandleBreakPoint(reason)
-            tracev("HandleBreakPoint returned with ", resumeAction)
-        except pythoncom.com_error as details:
-            # Eeek - the debugger is dead, or something serious is happening.
-            # Assume we should continue
-            resumeAction = axdebug.BREAKRESUMEACTION_CONTINUE
-            trace("HandleBreakPoint FAILED with", details)
-
-        self.stack = []
-        self.curindex = 0
-        if resumeAction == axdebug.BREAKRESUMEACTION_ABORT:
-            self.set_quit()
-        elif resumeAction == axdebug.BREAKRESUMEACTION_CONTINUE:
-            tracev("resume action is continue")
-            self.set_continue()
-        elif resumeAction == axdebug.BREAKRESUMEACTION_STEP_INTO:
-            tracev("resume action is step")
-            self.set_step()
-        elif resumeAction == axdebug.BREAKRESUMEACTION_STEP_OVER:
-            tracev("resume action is next")
-            self.set_next(frame)
-        elif resumeAction == axdebug.BREAKRESUMEACTION_STEP_OUT:
-            tracev("resume action is stop out")
-            self.set_return(frame)
-        else:
-            raise ValueError("unknown resume action flags")
-        self.breakReason = None
-
-    def set_trace(self):
-        self.breakReason = axdebug.BREAKREASON_LANGUAGE_INITIATED
-        bdb.Bdb.set_trace(self)
-
-    def CloseApp(self):
-        traceenter("ClosingApp")
-        self.reset()
-        self.logicalbotframe = None
-        if self.stackSnifferCookie is not None:
-            try:
-                self.debugApplication.RemoveStackFrameSniffer(self.stackSnifferCookie)
-
-            except pythoncom.com_error:
-                trace(
-                    f"*** Could not RemoveStackFrameSniffer {self.stackSnifferCookie}"
-                )
-        self.stackSnifferCookie = self.stackSniffer = None
-
-        if self.appEventConnection is not None:
-            self.appEventConnection.Disconnect()
-            self.appEventConnection = None
-        self.debugApplication = None
-        self.appDebugger = None
-        if self.codeContainerProvider is not None:
-            self.codeContainerProvider.Close()
-            self.codeContainerProvider = None
-
-    def AttachApp(self, debugApplication, codeContainerProvider):
-        # traceenter("AttachApp", debugApplication, codeContainerProvider)
-        self.codeContainerProvider = codeContainerProvider
-        self.debugApplication = debugApplication
-        self.stackSniffer = _wrap(
-            stackframe.DebugStackFrameSniffer(self), axdebug.IID_IDebugStackFrameSniffer
-        )
-        self.stackSnifferCookie = debugApplication.AddStackFrameSniffer(
-            self.stackSniffer
-        )
-        # trace(f"StackFrameSniffer added ({self.stackSnifferCookie})")
-
-        # Connect to the application events.
-        self.appEventConnection = win32com.client.connect.SimpleConnection(
-            self.debugApplication, self, axdebug.IID_IRemoteDebugApplicationEvents
-        )
-
-    def ResetAXDebugging(self):
-        traceenter("ResetAXDebugging", self, "with refcount", len(self.recursiveData))
-        if win32api.GetCurrentThreadId() != self.debuggingThread:
-            trace("ResetAXDebugging called on other thread")
-            return
-
-        if len(self.recursiveData) == 0:
-            # print("ResetAXDebugging called for final time.")
-            self.logicalbotframe = None
-            self.debuggingThread = None
-            self.currentframe = None
-            self.debuggingThreadStateHandle = None
-            return
-
-        (
-            self.logbotframe,
-            self.stopframe,
-            self.currentframe,
-            self.debuggingThreadStateHandle,
-        ) = self.recursiveData[0]
-        self.recursiveData = self.recursiveData[1:]
-
-    def SetupAXDebugging(self, baseFrame=None, userFrame=None):
-        """Get ready for potential debugging.  Must be called on the thread
-        that is being debugged.
-        """
-        # userFrame is for non AXScript debugging.  This is the first frame of the
-        # users code.
-        if userFrame is None:
-            userFrame = baseFrame
-        else:
-            # We have missed the "dispatch_call" function, so set this up now!
-            userFrame.f_locals["__axstack_address__"] = axdebug.GetStackAddress()
-
-        traceenter("SetupAXDebugging", self)
-        self._threadprotectlock.acquire()
-        try:
-            thisThread = win32api.GetCurrentThreadId()
-            if self.debuggingThread is None:
-                self.debuggingThread = thisThread
-            else:
-                if self.debuggingThread != thisThread:
-                    trace("SetupAXDebugging called on other thread - ignored!")
-                    return
-                # push our context.
-                self.recursiveData.insert(
-                    0,
-                    (
-                        self.logicalbotframe,
-                        self.stopframe,
-                        self.currentframe,
-                        self.debuggingThreadStateHandle,
-                    ),
-                )
-        finally:
-            self._threadprotectlock.release()
-
-        trace("SetupAXDebugging has base frame as", _dumpf(baseFrame))
-        self.botframe = baseFrame
-        self.stopframe = userFrame
-        self.logicalbotframe = baseFrame
-        self.currentframe = None
-        self.debuggingThreadStateHandle = axdebug.GetThreadStateHandle()
-
-        self._BreakFlagsChanged()
-
-    # RemoteDebugApplicationEvents
-    def OnConnectDebugger(self, appDebugger):
-        traceenter("OnConnectDebugger", appDebugger)
-        self.appDebugger = appDebugger
-        # Reflect output to appDebugger
-        writefunc = lambda s: appDebugger.onDebugOutput(s)
-        sys.stdout = OutputReflector(sys.stdout, writefunc)
-        sys.stderr = OutputReflector(sys.stderr, writefunc)
-
-    def OnDisconnectDebugger(self):
-        traceenter("OnDisconnectDebugger")
-        # Stop reflecting output
-        if isinstance(sys.stdout, OutputReflector):
-            sys.stdout = sys.stdout.file
-        if isinstance(sys.stderr, OutputReflector):
-            sys.stderr = sys.stderr.file
-        self.appDebugger = None
-        self.set_quit()
-
-    def OnSetName(self, name):
-        traceenter("OnSetName", name)
-
-    def OnDebugOutput(self, string):
-        traceenter("OnDebugOutput", string)
-
-    def OnClose(self):
-        traceenter("OnClose")
-
-    def OnEnterBreakPoint(self, rdat):
-        traceenter("OnEnterBreakPoint", rdat)
-
-    def OnLeaveBreakPoint(self, rdat):
-        traceenter("OnLeaveBreakPoint", rdat)
-
-    def OnCreateThread(self, rdat):
-        traceenter("OnCreateThread", rdat)
-
-    def OnDestroyThread(self, rdat):
-        traceenter("OnDestroyThread", rdat)
-
-    def OnBreakFlagChange(self, abf, rdat):
-        traceenter("Debugger OnBreakFlagChange", abf, rdat)
-        self.breakFlags = abf
-        self._BreakFlagsChanged()
-
-    def _BreakFlagsChanged(self):
-        traceenter(
-            f"_BreakFlagsChanged to {self.breakFlags} "
-            + f"with our thread = {self.debuggingThread}, "
-            + f"and debugging thread = {win32api.GetCurrentThreadId()}"
-        )
-        trace("_BreakFlagsChanged has breaks", self.breaks)
-        # If a request comes on our debugging thread, then do it now!
-        # if self.debuggingThread!=win32api.GetCurrentThreadId():
-        #     return
-
-        if len(self.breaks) or self.breakFlags:
-            if self.logicalbotframe:
-                trace("BreakFlagsChange with bot frame", _dumpf(self.logicalbotframe))
-                # We have frames not to be debugged (eg, Scripting engine frames
-                # (sys.settrace will be set when out logicalbotframe is hit -
-                #  this may not be the right thing to do, as it may not cause the
-                #  immediate break we desire.)
-                self.logicalbotframe.f_trace = self.trace_dispatch
-            else:
-                trace("BreakFlagsChanged, but no bottom frame")
-                if self.stopframe is not None:
-                    self.stopframe.f_trace = self.trace_dispatch
-            # If we have the thread-state for the thread being debugged, then
-            # we dynamically set its trace function - it is possible that the thread
-            # being debugged is in a blocked call (eg, a message box) and we
-            # want to hit the debugger the instant we return
-        if (
-            self.debuggingThreadStateHandle is not None
-            and self.breakFlags
-            and self.debuggingThread != win32api.GetCurrentThreadId()
-        ):
-            axdebug.SetThreadStateTrace(
-                self.debuggingThreadStateHandle, self.trace_dispatch
-            )
-
-    def _OnSetBreakPoint(self, key, codeContext, bps, lineNo):
-        traceenter("_OnSetBreakPoint", self, key, codeContext, bps, lineNo)
-        if bps == axdebug.BREAKPOINT_ENABLED:
-            problem = self.set_break(key, lineNo)
-            if problem:
-                print("*** set_break failed -", problem)
-            trace("_OnSetBreakPoint just set BP and has breaks", self.breaks)
-        else:
-            self.clear_break(key, lineNo)
-        self._BreakFlagsChanged()
-        trace("_OnSetBreakPoint leaving with breaks", self.breaks)
-
-
-def Debugger():
-    global g_adb
-    if g_adb is None:
-        g_adb = Adb()
-    return g_adb