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

py2docfx/venv/venv1/Lib/site-packages/win32/Demos/service/pipeTestService.py

@@ -1,185 +0,0 @@
-# A Demo of services and named pipes.
-
-# A multi-threaded service that simply echos back its input.
-
-# * Install as a service using "pipeTestService.py install"
-# * Use Control Panel to change the user name of the service
-#   to a real user name (ie, NOT the SystemAccount)
-# * Start the service.
-# * Run the "pipeTestServiceClient.py" program as the client pipe side.
-
-import _thread
-import traceback
-
-import pywintypes
-
-# Old versions of the service framework would not let you import this
-# module at the top-level.  Now you can, and can check 'servicemanager.Debugging()'
-# and 'servicemanager.RunningAsService()' to check your context.
-import servicemanager
-import win32con
-import win32service
-import win32serviceutil
-import winerror
-
-# # Use "import *" to keep this looking as much as a "normal" service
-# as possible.  Real code shouldn't do this.
-from ntsecuritycon import *  # nopycln: import
-from win32api import *  # nopycln: import
-from win32event import *  # nopycln: import
-from win32file import *  # nopycln: import
-from win32pipe import *  # nopycln: import
-
-
-def ApplyIgnoreError(fn, args):
-    try:
-        return fn(*args)
-    except error:  # Ignore win32api errors.
-        return None
-
-
-class TestPipeService(win32serviceutil.ServiceFramework):
-    _svc_name_ = "PyPipeTestService"
-    _svc_display_name_ = "Python Pipe Test Service"
-    _svc_description_ = "Tests Python service framework by receiving and echoing messages over a named pipe"
-
-    def __init__(self, args):
-        win32serviceutil.ServiceFramework.__init__(self, args)
-        self.hWaitStop = CreateEvent(None, 0, 0, None)
-        self.overlapped = pywintypes.OVERLAPPED()
-        self.overlapped.hEvent = CreateEvent(None, 0, 0, None)
-        self.thread_handles = []
-
-    def CreatePipeSecurityObject(self):
-        # Create a security object giving World read/write access,
-        # but only "Owner" modify access.
-        sa = pywintypes.SECURITY_ATTRIBUTES()
-        sidEveryone = pywintypes.SID()
-        sidEveryone.Initialize(SECURITY_WORLD_SID_AUTHORITY, 1)
-        sidEveryone.SetSubAuthority(0, SECURITY_WORLD_RID)
-        sidCreator = pywintypes.SID()
-        sidCreator.Initialize(SECURITY_CREATOR_SID_AUTHORITY, 1)
-        sidCreator.SetSubAuthority(0, SECURITY_CREATOR_OWNER_RID)
-
-        acl = pywintypes.ACL()
-        acl.AddAccessAllowedAce(FILE_GENERIC_READ | FILE_GENERIC_WRITE, sidEveryone)
-        acl.AddAccessAllowedAce(FILE_ALL_ACCESS, sidCreator)
-
-        sa.SetSecurityDescriptorDacl(1, acl, 0)
-        return sa
-
-    # The functions executed in their own thread to process a client request.
-    def DoProcessClient(self, pipeHandle, tid):
-        try:
-            try:
-                # Create a loop, reading large data.  If we knew the data stream was
-                # was small, a simple ReadFile would do.
-                d = b""
-                hr = winerror.ERROR_MORE_DATA
-                while hr == winerror.ERROR_MORE_DATA:
-                    hr, thisd = ReadFile(pipeHandle, 256)
-                    d += thisd
-                print("Read", d)
-                ok = 1
-            except error:
-                # Client disconnection - do nothing
-                ok = 0
-
-            # A secure service would handle (and ignore!) errors writing to the
-            # pipe, but for the sake of this demo we don't (if only to see what errors
-            # we can get when our clients break at strange times :-)
-            if ok:
-                msg = (
-                    "%s (on thread %d) sent me %s"
-                    % (GetNamedPipeHandleState(pipeHandle, False, True)[4], tid, d)
-                ).encode("ascii")
-                WriteFile(pipeHandle, msg)
-        finally:
-            ApplyIgnoreError(DisconnectNamedPipe, (pipeHandle,))
-            ApplyIgnoreError(CloseHandle, (pipeHandle,))
-
-    def ProcessClient(self, pipeHandle):
-        try:
-            procHandle = GetCurrentProcess()
-            th = DuplicateHandle(
-                procHandle,
-                GetCurrentThread(),
-                procHandle,
-                0,
-                0,
-                win32con.DUPLICATE_SAME_ACCESS,
-            )
-            try:
-                self.thread_handles.append(th)
-                try:
-                    return self.DoProcessClient(pipeHandle, th)
-                except:
-                    traceback.print_exc()
-            finally:
-                self.thread_handles.remove(th)
-        except:
-            traceback.print_exc()
-
-    def SvcStop(self):
-        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
-        SetEvent(self.hWaitStop)
-
-    def SvcDoRun(self):
-        # Write an event log record - in debug mode we will also
-        # see this message printed.
-        servicemanager.LogMsg(
-            servicemanager.EVENTLOG_INFORMATION_TYPE,
-            servicemanager.PYS_SERVICE_STARTED,
-            (self._svc_name_, ""),
-        )
-
-        num_connections = 0
-        while 1:
-            pipeHandle = CreateNamedPipe(
-                "\\\\.\\pipe\\PyPipeTest",
-                PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
-                PIPE_TYPE_MESSAGE | PIPE_READMODE_BYTE,
-                PIPE_UNLIMITED_INSTANCES,  # max instances
-                0,
-                0,
-                6000,
-                self.CreatePipeSecurityObject(),
-            )
-            try:
-                hr = ConnectNamedPipe(pipeHandle, self.overlapped)
-            except error as details:
-                print("Error connecting pipe!", details)
-                CloseHandle(pipeHandle)
-                break
-            if hr == winerror.ERROR_PIPE_CONNECTED:
-                # Client is already connected - signal event
-                SetEvent(self.overlapped.hEvent)
-            rc = WaitForMultipleObjects(
-                (self.hWaitStop, self.overlapped.hEvent), 0, INFINITE
-            )
-            if rc == WAIT_OBJECT_0:
-                # Stop event
-                break
-            else:
-                # Pipe event - spawn thread to deal with it.
-                _thread.start_new_thread(self.ProcessClient, (pipeHandle,))
-                num_connections += 1
-
-        # Sleep to ensure that any new threads are in the list, and then
-        # wait for all current threads to finish.
-        # What is a better way?
-        Sleep(500)
-        while self.thread_handles:
-            self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING, 5000)
-            print("Waiting for %d threads to finish..." % (len(self.thread_handles)))
-            WaitForMultipleObjects(self.thread_handles, 1, 3000)
-        # Write another event log record.
-        servicemanager.LogMsg(
-            servicemanager.EVENTLOG_INFORMATION_TYPE,
-            servicemanager.PYS_SERVICE_STOPPED,
-            (self._svc_name_, " after processing %d connections" % (num_connections,)),
-        )
-
-
-if __name__ == "__main__":
-    win32serviceutil.HandleCommandLine(TestPipeService)

py2docfx/venv/venv1/Lib/site-packages/win32/Demos/service/pipeTestServiceClient.py

@@ -1,158 +0,0 @@
-# A Test Program for pipeTestService.py
-#
-# Install and start the Pipe Test service, then run this test
-# either from the same machine, or from another using the "-s" param.
-#
-# Eg: pipeTestServiceClient.py -s server_name Hi There
-# Should work.
-
-import os
-import sys
-import traceback
-
-import pywintypes
-import win32api
-import winerror
-
-# # Use "import *" to keep this looking as much as a "normal" service
-# as possible.  Real code shouldn't do this.
-from win32event import *  # nopycln: import
-from win32file import *  # nopycln: import
-from win32pipe import *  # nopycln: import
-
-verbose = 0
-
-# def ReadFromPipe(pipeName):
-# Could (Should?) use CallNamedPipe, but this technique allows variable size
-# messages (whereas you must supply a buffer size for CallNamedPipe!
-#       hPipe = CreateFile(pipeName, GENERIC_WRITE, 0, None, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)
-#       more = 1
-#       while more:
-#               hr = ReadFile(hPipe, 256)
-#               if hr==0:
-#                       more = 0
-#               except win32api.error (hr, fn, desc):
-#                       if hr==winerror.ERROR_MORE_DATA:
-#                               data = dat
-#
-
-
-def CallPipe(fn, args):
-    ret = None
-    retryCount = 0
-    while retryCount < 8:  # Keep looping until user cancels.
-        retryCount += 1
-        try:
-            return fn(*args)
-        except win32api.error as exc:
-            if exc.winerror == winerror.ERROR_PIPE_BUSY:
-                win32api.Sleep(5000)
-                continue
-            else:
-                raise
-
-    raise RuntimeError("Could not make a connection to the server")
-
-
-def testClient(server, msg):
-    if verbose:
-        print("Sending", msg)
-    data = CallPipe(
-        CallNamedPipe,
-        ("\\\\%s\\pipe\\PyPipeTest" % server, msg, 256, NMPWAIT_WAIT_FOREVER),
-    )
-    if verbose:
-        print("Server sent back '%s'" % data)
-    print("Sent and received a message!")
-
-
-def testLargeMessage(server, size=4096):
-    if verbose:
-        print("Sending message of size %d" % (size))
-    msg = "*" * size
-    data = CallPipe(
-        CallNamedPipe,
-        ("\\\\%s\\pipe\\PyPipeTest" % server, msg, 512, NMPWAIT_WAIT_FOREVER),
-    )
-    if len(data) - size:
-        print("Sizes are all wrong - send %d, got back %d" % (size, len(data)))
-
-
-def stressThread(server, numMessages, wait):
-    try:
-        try:
-            for i in range(numMessages):
-                r = CallPipe(
-                    CallNamedPipe,
-                    (
-                        "\\\\%s\\pipe\\PyPipeTest" % server,
-                        "#" * 512,
-                        1024,
-                        NMPWAIT_WAIT_FOREVER,
-                    ),
-                )
-        except:
-            traceback.print_exc()
-            print("Failed after %d messages" % i)
-    finally:
-        SetEvent(wait)
-
-
-def stressTestClient(server, numThreads, numMessages):
-    import _thread
-
-    thread_waits = []
-    for t_num in range(numThreads):
-        # Note I could just wait on thread handles (after calling DuplicateHandle)
-        # See the service itself for an example of waiting for the clients...
-        wait = CreateEvent(None, 0, 0, None)
-        thread_waits.append(wait)
-        _thread.start_new_thread(stressThread, (server, numMessages, wait))
-    # Wait for all threads to finish.
-    WaitForMultipleObjects(thread_waits, 1, INFINITE)
-
-
-def main():
-    import getopt
-
-    server = "."
-    thread_count = 0
-    msg_count = 500
-    try:
-        opts, args = getopt.getopt(sys.argv[1:], "s:t:m:vl")
-        for o, a in opts:
-            if o == "-s":
-                server = a
-            if o == "-m":
-                msg_count = int(a)
-            if o == "-t":
-                thread_count = int(a)
-            if o == "-v":
-                global verbose
-                verbose = 1
-            if o == "-l":
-                testLargeMessage(server)
-        msg = " ".join(args).encode("mbcs")
-    except getopt.error as msg:
-        print(msg)
-        my_name = os.path.split(sys.argv[0])[1]
-        print(
-            "Usage: %s [-v] [-s server] [-t thread_count=0] [-m msg_count=500] msg ..."
-            % my_name
-        )
-        print("       -v = verbose")
-        print(
-            "       Specifying a value for -t will stress test using that many threads."
-        )
-        return
-    testClient(server, msg)
-    if thread_count > 0:
-        print(
-            "Spawning %d threads each sending %d messages..."
-            % (thread_count, msg_count)
-        )
-        stressTestClient(server, thread_count, msg_count)
-
-
-if __name__ == "__main__":
-    main()

py2docfx/venv/venv1/Lib/site-packages/win32/Demos/service/serviceEvents.py

@@ -1,98 +0,0 @@
-# A Demo of a service that takes advantage of the additional notifications
-# available in later Windows versions.
-
-# Note that all output is written as event log entries - so you must install
-# and start the service, then look at the event log for messages as events
-# are generated.
-
-# Events are generated for USB device insertion and removal, power state
-# changes and hardware profile events - so try putting your computer to
-# sleep and waking it, inserting a memory stick, etc then check the event log
-
-# Most event notification support lives around win32gui
-import servicemanager
-import win32con
-import win32event
-import win32gui
-import win32gui_struct
-import win32service
-import win32serviceutil
-
-GUID_DEVINTERFACE_USB_DEVICE = "{A5DCBF10-6530-11D2-901F-00C04FB951ED}"
-
-
-class EventDemoService(win32serviceutil.ServiceFramework):
-    _svc_name_ = "PyServiceEventDemo"
-    _svc_display_name_ = "Python Service Event Demo"
-    _svc_description_ = (
-        "Demonstrates a Python service which takes advantage of the extra notifications"
-    )
-
-    def __init__(self, args):
-        win32serviceutil.ServiceFramework.__init__(self, args)
-        self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)
-        # register for a device notification - we pass our service handle
-        # instead of a window handle.
-        filter = win32gui_struct.PackDEV_BROADCAST_DEVICEINTERFACE(
-            GUID_DEVINTERFACE_USB_DEVICE
-        )
-        self.hdn = win32gui.RegisterDeviceNotification(
-            self.ssh, filter, win32con.DEVICE_NOTIFY_SERVICE_HANDLE
-        )
-
-    # Override the base class so we can accept additional events.
-    def GetAcceptedControls(self):
-        # say we accept them all.
-        rc = win32serviceutil.ServiceFramework.GetAcceptedControls(self)
-        rc |= (
-            win32service.SERVICE_ACCEPT_PARAMCHANGE
-            | win32service.SERVICE_ACCEPT_NETBINDCHANGE
-            | win32service.SERVICE_CONTROL_DEVICEEVENT
-            | win32service.SERVICE_ACCEPT_HARDWAREPROFILECHANGE
-            | win32service.SERVICE_ACCEPT_POWEREVENT
-            | win32service.SERVICE_ACCEPT_SESSIONCHANGE
-        )
-        return rc
-
-    # All extra events are sent via SvcOtherEx (SvcOther remains as a
-    # function taking only the first args for backwards compat)
-    def SvcOtherEx(self, control, event_type, data):
-        # This is only showing a few of the extra events - see the MSDN
-        # docs for "HandlerEx callback" for more info.
-        if control == win32service.SERVICE_CONTROL_DEVICEEVENT:
-            info = win32gui_struct.UnpackDEV_BROADCAST(data)
-            msg = f"A device event occurred: {event_type:x} - {info}"
-        elif control == win32service.SERVICE_CONTROL_HARDWAREPROFILECHANGE:
-            msg = f"A hardware profile changed: type={event_type}, data={data}"
-        elif control == win32service.SERVICE_CONTROL_POWEREVENT:
-            msg = "A power event: setting %s" % data
-        elif control == win32service.SERVICE_CONTROL_SESSIONCHANGE:
-            # data is a single elt tuple, but this could potentially grow
-            # in the future if the win32 struct does
-            msg = f"Session event: type={event_type}, data={data}"
-        else:
-            msg = "Other event: code=%d, type=%s, data=%s" % (control, event_type, data)
-
-        servicemanager.LogMsg(
-            servicemanager.EVENTLOG_INFORMATION_TYPE,
-            0xF000,  #  generic message
-            (msg, ""),
-        )
-
-    def SvcStop(self):
-        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
-        win32event.SetEvent(self.hWaitStop)
-
-    def SvcDoRun(self):
-        # do nothing at all - just wait to be stopped
-        win32event.WaitForSingleObject(self.hWaitStop, win32event.INFINITE)
-        # Write a stop message.
-        servicemanager.LogMsg(
-            servicemanager.EVENTLOG_INFORMATION_TYPE,
-            servicemanager.PYS_SERVICE_STOPPED,
-            (self._svc_name_, ""),
-        )
-
-
-if __name__ == "__main__":
-    win32serviceutil.HandleCommandLine(EventDemoService)

py2docfx/venv/venv1/Lib/site-packages/win32/Demos/timer_demo.py

@@ -1,72 +0,0 @@
-# -*- Mode: Python; tab-width: 4 -*-
-#
-
-# This module, and the timer.pyd core timer support, were written by
-# Sam Rushing (rushing@nightmare.com)
-
-import time
-
-# Timers are based on Windows messages.  So we need
-# to do the event-loop thing!
-import timer
-import win32event
-import win32gui
-
-# glork holds a simple counter for us.
-
-
-class glork:
-    def __init__(self, delay=1000, max=10):
-        self.x = 0
-        self.max = max
-        self.id = timer.set_timer(delay, self.increment)
-        # Could use the threading module, but this is
-        # a win32 extension test after all! :-)
-        self.event = win32event.CreateEvent(None, 0, 0, None)
-
-    def increment(self, id, time):
-        print("x = %d" % self.x)
-        self.x += 1
-        # if we've reached the max count,
-        # kill off the timer.
-        if self.x > self.max:
-            # we could have used 'self.id' here, too
-            timer.kill_timer(id)
-            win32event.SetEvent(self.event)
-
-
-# create a counter that will count from '1' thru '10', incrementing
-# once a second, and then stop.
-
-
-def demo(delay=1000, stop=10):
-    g = glork(delay, stop)
-    # Timers are message based - so we need
-    # To run a message loop while waiting for our timers
-    # to expire.
-    start_time = time.time()
-    while 1:
-        # We can't simply give a timeout of 30 seconds, as
-        # we may continouusly be recieving other input messages,
-        # and therefore never expire.
-        rc = win32event.MsgWaitForMultipleObjects(
-            (g.event,),  # list of objects
-            0,  # wait all
-            500,  # timeout
-            win32event.QS_ALLEVENTS,  # type of input
-        )
-        if rc == win32event.WAIT_OBJECT_0:
-            # Event signalled.
-            break
-        elif rc == win32event.WAIT_OBJECT_0 + 1:
-            # Message waiting.
-            if win32gui.PumpWaitingMessages():
-                raise RuntimeError("We got an unexpected WM_QUIT message!")
-        else:
-            # This wait timed-out.
-            if time.time() - start_time > 30:
-                raise RuntimeError("We timed out waiting for the timers to expire!")
-
-
-if __name__ == "__main__":
-    demo()

py2docfx/venv/venv1/Lib/site-packages/win32/Demos/win32clipboardDemo.py

@@ -1,155 +0,0 @@
-# win32clipboardDemo.py
-#
-# Demo/test of the win32clipboard module.
-import win32con
-from win32clipboard import (
-    CloseClipboard,
-    EmptyClipboard,
-    EnumClipboardFormats,
-    GetClipboardData,
-    GetClipboardFormatName,
-    IsClipboardFormatAvailable,
-    OpenClipboard,
-    RegisterClipboardFormat,
-    SetClipboardData,
-    SetClipboardText,
-)
-
-if not __debug__:
-    print("WARNING: The test code in this module uses assert")
-    print("This instance of Python has asserts disabled, so many tests will be skipped")
-
-# Build map of CF_* constants to names.
-cf_names = {
-    val: name
-    for name, val in win32con.__dict__.items()
-    if name[:3] == "CF_" and name != "CF_SCREENFONTS"  # CF_SCREEN_FONTS==CF_TEXT!?!?
-}
-
-
-def TestEmptyClipboard():
-    OpenClipboard()
-    try:
-        EmptyClipboard()
-        assert (
-            EnumClipboardFormats(0) == 0
-        ), "Clipboard formats were available after emptying it!"
-    finally:
-        CloseClipboard()
-
-
-def TestText():
-    OpenClipboard()
-    try:
-        text = "Hello from Python"
-        text_bytes = text.encode("latin1")
-        SetClipboardText(text)
-        got = GetClipboardData(win32con.CF_TEXT)
-        # CF_TEXT always gives us 'bytes' back .
-        assert got == text_bytes, f"Didn't get the correct result back - '{got!r}'."
-    finally:
-        CloseClipboard()
-
-    OpenClipboard()
-    try:
-        # CF_UNICODE text always gives unicode objects back.
-        got = GetClipboardData(win32con.CF_UNICODETEXT)
-        assert got == text, f"Didn't get the correct result back - '{got!r}'."
-        assert isinstance(got, str), f"Didn't get the correct result back - '{got!r}'."
-
-        # CF_OEMTEXT is a bytes-based format.
-        got = GetClipboardData(win32con.CF_OEMTEXT)
-        assert got == text_bytes, f"Didn't get the correct result back - '{got!r}'."
-
-        # Unicode tests
-        EmptyClipboard()
-        text = "Hello from Python unicode"
-        text_bytes = text.encode("latin1")
-        # Now set the Unicode value
-        SetClipboardData(win32con.CF_UNICODETEXT, text)
-        # Get it in Unicode.
-        got = GetClipboardData(win32con.CF_UNICODETEXT)
-        assert got == text, f"Didn't get the correct result back - '{got!r}'."
-        assert isinstance(got, str), f"Didn't get the correct result back - '{got!r}'."
-
-        # Close and open the clipboard to ensure auto-conversions take place.
-    finally:
-        CloseClipboard()
-
-    OpenClipboard()
-    try:
-        # Make sure I can still get the text as bytes
-        got = GetClipboardData(win32con.CF_TEXT)
-        assert got == text_bytes, f"Didn't get the correct result back - '{got!r}'."
-        # Make sure we get back the correct types.
-        got = GetClipboardData(win32con.CF_UNICODETEXT)
-        assert isinstance(got, str), f"Didn't get the correct result back - '{got!r}'."
-        got = GetClipboardData(win32con.CF_OEMTEXT)
-        assert got == text_bytes, f"Didn't get the correct result back - '{got!r}'."
-        print("Clipboard text tests worked correctly")
-    finally:
-        CloseClipboard()
-
-
-def TestClipboardEnum():
-    OpenClipboard()
-    try:
-        # Enumerate over the clipboard types
-        enum = 0
-        while 1:
-            enum = EnumClipboardFormats(enum)
-            if enum == 0:
-                break
-            assert IsClipboardFormatAvailable(
-                enum
-            ), "Have format, but clipboard says it is not available!"
-            n = cf_names.get(enum, "")
-            if not n:
-                try:
-                    n = GetClipboardFormatName(enum)
-                except error:
-                    n = f"unknown ({enum})"
-
-            print("Have format", n)
-        print("Clipboard enumerator tests worked correctly")
-    finally:
-        CloseClipboard()
-
-
-class Foo:
-    def __init__(self, **kw):
-        self.__dict__.update(kw)
-
-    def __lt__(self, other):
-        return self.__dict__ < other.__dict__
-
-    def __eq__(self, other):
-        return self.__dict__ == other.__dict__
-
-
-def TestCustomFormat():
-    OpenClipboard()
-    try:
-        # Just for the fun of it pickle Python objects through the clipboard
-        fmt = RegisterClipboardFormat("Python Pickle Format")
-        import pickle
-
-        pickled_object = Foo(a=1, b=2, Hi=3)
-        SetClipboardData(fmt, pickle.dumps(pickled_object))
-        # Now read it back.
-        data = GetClipboardData(fmt)
-        loaded_object = pickle.loads(data)
-        assert pickle.loads(data) == pickled_object, "Didn't get the correct data!"
-
-        print("Clipboard custom format tests worked correctly")
-    finally:
-        CloseClipboard()
-
-
-if __name__ == "__main__":
-    TestEmptyClipboard()
-    TestText()
-    TestCustomFormat()
-    TestClipboardEnum()
-    # And leave it empty at the end!
-    TestEmptyClipboard()