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/win32clipboard_bitmapdemo.py

@@ -1,117 +0,0 @@
-import win32api
-import win32clipboard
-import win32con
-import win32gui
-
-
-class ViewerWindow:
-    def __init__(self):
-        self.hwndNextViewer = None
-
-    def OnPaint(self, hwnd, msg, wp, lp):
-        dc, ps = win32gui.BeginPaint(hwnd)
-        wndrect = win32gui.GetClientRect(hwnd)
-        wndwidth = wndrect[2] - wndrect[0]
-        wndheight = wndrect[3] - wndrect[1]
-        win32clipboard.OpenClipboard()
-        try:
-            try:
-                hbitmap = win32clipboard.GetClipboardData(win32clipboard.CF_BITMAP)
-            except TypeError:
-                font = win32gui.LOGFONT()
-                font.lfHeight = 15  # int(wndheight/20)
-                font.lfWidth = 15  # font.lfHeight
-                #            font.lfWeight=150
-                hf = win32gui.CreateFontIndirect(font)
-                win32gui.SelectObject(dc, hf)
-                win32gui.SetBkMode(dc, win32con.TRANSPARENT)
-                win32gui.SetTextColor(dc, win32api.RGB(0, 0, 0))
-                win32gui.DrawText(
-                    dc,
-                    "No bitmaps are in the clipboard\n(try pressing the PrtScn button)",
-                    -1,
-                    (0, 0, wndwidth, wndheight),
-                    win32con.DT_CENTER,
-                )
-            else:
-                bminfo = win32gui.GetObject(hbitmap)
-                dcDC = win32gui.CreateCompatibleDC(None)
-                win32gui.SelectObject(dcDC, hbitmap)
-                win32gui.StretchBlt(
-                    dc,
-                    0,
-                    0,
-                    wndwidth,
-                    wndheight,
-                    dcDC,
-                    0,
-                    0,
-                    bminfo.bmWidth,
-                    bminfo.bmHeight,
-                    win32con.SRCCOPY,
-                )
-                win32gui.DeleteDC(dcDC)
-                win32gui.EndPaint(hwnd, ps)
-        finally:
-            win32clipboard.CloseClipboard()
-        return 0
-
-    def OnDrawClipboard(self, hwnd, msg, wp, lp):
-        win32gui.InvalidateRect(hwnd, None, True)
-
-    def OnChangeCBChain(self, hwnd, msg, wp, lp):
-        # If the next window is closing, repair the chain.
-        if wp == self.hwndNextViewer:
-            self.hwndNextViewer = lp
-        # Otherwise, pass the message to the next link.
-        elif self.hwndNextViewer:
-            win32gui.SendMessage(self.hwndNextViewer, msg, wp, lp)
-
-    def OnCreate(self, hwnd, msg, wp, lp):
-        self.hwndNextViewer = win32gui.SetClipboardViewer(hwnd)
-
-    def OnClose(self, hwnd, msg, wp, lp):
-        win32clipboard.ChangeClipboardChain(hwnd, self.hwndNextViewer)
-        win32gui.DestroyWindow(hwnd)
-        win32gui.PostQuitMessage(0)
-
-    def go(self):
-        wndproc = {
-            win32con.WM_PAINT: self.OnPaint,
-            win32con.WM_CLOSE: self.OnClose,
-            win32con.WM_CREATE: self.OnCreate,
-            win32con.WM_DRAWCLIPBOARD: self.OnDrawClipboard,
-            win32con.WM_CHANGECBCHAIN: self.OnChangeCBChain,
-        }
-
-        wc = win32gui.WNDCLASS()
-        wc.lpszClassName = "test_win32clipboard_bmp"
-        wc.style = win32con.CS_GLOBALCLASS | win32con.CS_VREDRAW | win32con.CS_HREDRAW
-        wc.hbrBackground = win32con.COLOR_WINDOW + 1
-        wc.lpfnWndProc = wndproc
-        class_atom = win32gui.RegisterClass(wc)
-        hwnd = win32gui.CreateWindowEx(
-            0,
-            class_atom,
-            "ClipboardViewer",
-            win32con.WS_CAPTION
-            | win32con.WS_VISIBLE
-            | win32con.WS_THICKFRAME
-            | win32con.WS_SYSMENU,
-            100,
-            100,
-            900,
-            900,
-            0,
-            0,
-            0,
-            None,
-        )
-        win32clipboard.SetClipboardViewer(hwnd)
-        win32gui.PumpMessages()
-        win32gui.UnregisterClass(class_atom, None)
-
-
-if __name__ == "__main__":
-    w = ViewerWindow()
-    w.go()

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

@@ -1,174 +0,0 @@
-# This is a simple serial port terminal demo.
-#
-# Its primary purpose is to demonstrate the native serial port access offered via
-# win32file.
-
-# It uses 3 threads:
-# - The main thread, which cranks up the other 2 threads, then simply waits for them to exit.
-# - The user-input thread - blocks waiting for a keyboard character, and when found sends it
-#   out the COM port.  If the character is Ctrl+C, it stops, signalling the COM port thread to stop.
-# - The COM port thread is simply listening for input on the COM port, and prints it to the screen.
-
-# This demo uses userlapped IO, so that none of the read or write operations actually block (however,
-# in this sample, the very next thing we do _is_ block - so it shows off the concepts even though it
-# doesn't exploit them.
-
-import msvcrt  # For the getch() function.
-import sys
-import threading
-
-import win32con  # constants.
-from win32event import (  # We use events and the WaitFor[Multiple]Objects functions.
-    INFINITE,
-    WAIT_OBJECT_0,
-    CreateEvent,
-    SetEvent,
-    WaitForMultipleObjects,
-    WaitForSingleObject,
-)
-from win32file import (  # The base COM port and file IO functions.
-    CBR_115200,
-    EV_RXCHAR,
-    NOPARITY,
-    ONESTOPBIT,
-    OVERLAPPED,
-    PURGE_RXABORT,
-    PURGE_RXCLEAR,
-    PURGE_TXABORT,
-    PURGE_TXCLEAR,
-    ClearCommError,
-    CreateFile,
-    GetCommModemStatus,
-    GetCommState,
-    PurgeComm,
-    ReadFile,
-    SetCommMask,
-    SetCommState,
-    SetCommTimeouts,
-    SetupComm,
-    WaitCommEvent,
-    WriteFile,
-    error,
-)
-
-
-def FindModem():
-    # Snoop over the comports, seeing if it is likely we have a modem.
-    for i in range(1, 5):
-        port = "COM%d" % (i,)
-        try:
-            handle = CreateFile(
-                port,
-                win32con.GENERIC_READ | win32con.GENERIC_WRITE,
-                0,  # exclusive access
-                None,  # no security
-                win32con.OPEN_EXISTING,
-                win32con.FILE_ATTRIBUTE_NORMAL,
-                None,
-            )
-            # It appears that an available COM port will always success here,
-            # just return 0 for the status flags.  We only care that it has _any_ status
-            # flags (and therefore probably a real modem)
-            if GetCommModemStatus(handle) != 0:
-                return port
-        except error:
-            pass  # No port, or modem status failed.
-    return None
-
-
-# A basic synchronous COM port file-like object
-class SerialTTY:
-    def __init__(self, port):
-        if isinstance(port, int):
-            port = "COM%d" % (port,)
-        self.handle = CreateFile(
-            port,
-            win32con.GENERIC_READ | win32con.GENERIC_WRITE,
-            0,  # exclusive access
-            None,  # no security
-            win32con.OPEN_EXISTING,
-            win32con.FILE_ATTRIBUTE_NORMAL | win32con.FILE_FLAG_OVERLAPPED,
-            None,
-        )
-        # Tell the port we want a notification on each char.
-        SetCommMask(self.handle, EV_RXCHAR)
-        # Setup a 4k buffer
-        SetupComm(self.handle, 4096, 4096)
-        # Remove anything that was there
-        PurgeComm(
-            self.handle, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR
-        )
-        # Setup for overlapped IO.
-        timeouts = 0xFFFFFFFF, 0, 1000, 0, 1000
-        SetCommTimeouts(self.handle, timeouts)
-        # Setup the connection info.
-        dcb = GetCommState(self.handle)
-        dcb.BaudRate = CBR_115200
-        dcb.ByteSize = 8
-        dcb.Parity = NOPARITY
-        dcb.StopBits = ONESTOPBIT
-        SetCommState(self.handle, dcb)
-        print(f"Connected to {port} at {dcb.BaudRate} baud")
-
-    def _UserInputReaderThread(self):
-        overlapped = OVERLAPPED()
-        overlapped.hEvent = CreateEvent(None, 1, 0, None)
-        try:
-            while 1:
-                ch = msvcrt.getch()
-                if ord(ch) == 3:
-                    break
-                WriteFile(self.handle, ch, overlapped)
-                # Wait for the write to complete.
-                WaitForSingleObject(overlapped.hEvent, INFINITE)
-        finally:
-            SetEvent(self.eventStop)
-
-    def _ComPortThread(self):
-        overlapped = OVERLAPPED()
-        overlapped.hEvent = CreateEvent(None, 1, 0, None)
-        while 1:
-            # XXX - note we could _probably_ just use overlapped IO on the win32file.ReadFile() statement
-            # XXX but this tests the COM stuff!
-            rc, mask = WaitCommEvent(self.handle, overlapped)
-            if rc == 0:  # Character already ready!
-                SetEvent(overlapped.hEvent)
-            rc = WaitForMultipleObjects(
-                [overlapped.hEvent, self.eventStop], 0, INFINITE
-            )
-            if rc == WAIT_OBJECT_0:
-                # Some input - read and print it
-                flags, comstat = ClearCommError(self.handle)
-                rc, data = ReadFile(self.handle, comstat.cbInQue, overlapped)
-                WaitForSingleObject(overlapped.hEvent, INFINITE)
-                sys.stdout.write(data)
-            else:
-                # Stop the thread!
-                # Just incase the user input thread uis still going, close it
-                sys.stdout.close()
-                break
-
-    def Run(self):
-        self.eventStop = CreateEvent(None, 0, 0, None)
-        # Start the reader and writer threads.
-        user_thread = threading.Thread(target=self._UserInputReaderThread)
-        user_thread.start()
-        com_thread = threading.Thread(target=self._ComPortThread)
-        com_thread.start()
-        user_thread.join()
-        com_thread.join()
-
-
-if __name__ == "__main__":
-    print("Serial port terminal demo - press Ctrl+C to exit")
-    if len(sys.argv) <= 1:
-        port = FindModem()
-        if port is None:
-            print("No COM port specified, and no modem could be found")
-            print("Please re-run this script with the name of a COM port (eg COM3)")
-            sys.exit(1)
-    else:
-        port = sys.argv[1]
-
-    tty = SerialTTY(port)
-    tty.Run()

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

@@ -1,132 +0,0 @@
-import time
-
-import win32con
-import win32console
-
-virtual_keys = {k: v for k, v in win32con.__dict__.items() if k.startswith("VK_")}
-
-free_console = True
-try:
-    win32console.AllocConsole()
-except win32console.error as exc:
-    if exc.winerror != 5:
-        raise
-    ## only free console if one was created successfully
-    free_console = False
-
-stdout = win32console.GetStdHandle(win32console.STD_OUTPUT_HANDLE)
-stdin = win32console.GetStdHandle(win32console.STD_INPUT_HANDLE)
-newbuffer = win32console.CreateConsoleScreenBuffer()
-newbuffer.SetConsoleActiveScreenBuffer()
-newbuffer.SetConsoleTextAttribute(
-    win32console.FOREGROUND_RED
-    | win32console.FOREGROUND_INTENSITY
-    | win32console.BACKGROUND_GREEN
-    | win32console.BACKGROUND_INTENSITY
-)
-newbuffer.WriteConsole("This is a new screen buffer\n")
-
-## test setting screen buffer and window size
-## screen buffer size cannot be smaller than window size
-window_size = newbuffer.GetConsoleScreenBufferInfo()["Window"]
-coord = win32console.PyCOORDType(X=window_size.Right + 20, Y=window_size.Bottom + 20)
-newbuffer.SetConsoleScreenBufferSize(coord)
-
-window_size.Right += 10
-window_size.Bottom += 10
-newbuffer.SetConsoleWindowInfo(Absolute=True, ConsoleWindow=window_size)
-
-## write some records to the input queue
-x = win32console.PyINPUT_RECORDType(win32console.KEY_EVENT)
-x.Char = "X"
-x.KeyDown = True
-x.RepeatCount = 1
-x.VirtualKeyCode = 0x58
-x.ControlKeyState = win32con.SHIFT_PRESSED
-
-z = win32console.PyINPUT_RECORDType(win32console.KEY_EVENT)
-z.Char = "Z"
-z.KeyDown = True
-z.RepeatCount = 1
-z.VirtualKeyCode = 0x5A
-z.ControlKeyState = win32con.SHIFT_PRESSED
-
-stdin.WriteConsoleInput([x, z, x])
-
-newbuffer.SetConsoleTextAttribute(
-    win32console.FOREGROUND_RED
-    | win32console.FOREGROUND_INTENSITY
-    | win32console.BACKGROUND_GREEN
-    | win32console.BACKGROUND_INTENSITY
-)
-newbuffer.WriteConsole("Press some keys, click some characters with the mouse\n")
-
-newbuffer.SetConsoleTextAttribute(
-    win32console.FOREGROUND_BLUE
-    | win32console.FOREGROUND_INTENSITY
-    | win32console.BACKGROUND_RED
-    | win32console.BACKGROUND_INTENSITY
-)
-newbuffer.WriteConsole('Hit "End" key to quit\n')
-
-breakout = False
-while not breakout:
-    input_records = stdin.ReadConsoleInput(10)
-    for input_record in input_records:
-        if input_record.EventType == win32console.KEY_EVENT:
-            if input_record.KeyDown:
-                if input_record.Char == "\0":
-                    newbuffer.WriteConsole(
-                        virtual_keys.get(
-                            input_record.VirtualKeyCode,
-                            "VirtualKeyCode: %s" % input_record.VirtualKeyCode,
-                        )
-                    )
-                else:
-                    newbuffer.WriteConsole(input_record.Char)
-                if input_record.VirtualKeyCode == win32con.VK_END:
-                    breakout = True
-                    break
-        elif input_record.EventType == win32console.MOUSE_EVENT:
-            if input_record.EventFlags == 0:  ## 0 indicates a button event
-                if input_record.ButtonState != 0:  ## exclude button releases
-                    pos = input_record.MousePosition
-                    # switch the foreground and background colors of the character that was clicked
-                    attr = newbuffer.ReadConsoleOutputAttribute(
-                        Length=1, ReadCoord=pos
-                    )[0]
-                    new_attr = attr
-                    if attr & win32console.FOREGROUND_BLUE:
-                        new_attr = (
-                            new_attr & ~win32console.FOREGROUND_BLUE
-                        ) | win32console.BACKGROUND_BLUE
-                    if attr & win32console.FOREGROUND_RED:
-                        new_attr = (
-                            new_attr & ~win32console.FOREGROUND_RED
-                        ) | win32console.BACKGROUND_RED
-                    if attr & win32console.FOREGROUND_GREEN:
-                        new_attr = (
-                            new_attr & ~win32console.FOREGROUND_GREEN
-                        ) | win32console.BACKGROUND_GREEN
-
-                    if attr & win32console.BACKGROUND_BLUE:
-                        new_attr = (
-                            new_attr & ~win32console.BACKGROUND_BLUE
-                        ) | win32console.FOREGROUND_BLUE
-                    if attr & win32console.BACKGROUND_RED:
-                        new_attr = (
-                            new_attr & ~win32console.BACKGROUND_RED
-                        ) | win32console.FOREGROUND_RED
-                    if attr & win32console.BACKGROUND_GREEN:
-                        new_attr = (
-                            new_attr & ~win32console.BACKGROUND_GREEN
-                        ) | win32console.FOREGROUND_GREEN
-                    newbuffer.WriteConsoleOutputAttribute((new_attr,), pos)
-        else:
-            newbuffer.WriteConsole(str(input_record))
-    time.sleep(0.1)
-
-stdout.SetConsoleActiveScreenBuffer()
-newbuffer.Close()
-if free_console:
-    win32console.FreeConsole()

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

@@ -1,82 +0,0 @@
-"""
-Demonstrates prompting for credentials, saving, and loggging on with marshalled credential.
-Also shows how to load user's profile
-"""
-
-import win32api
-import win32con
-import win32cred
-import win32net
-import win32profile
-import win32security
-
-## Prompt for a username/pwd for local computer
-uiinfo = {
-    "MessageText": "Enter credentials for local machine",
-    "CaptionText": "win32cred_demo.py",
-}
-target, pwd, save = win32cred.CredUIPromptForCredentials(
-    TargetName=win32api.GetComputerName(),
-    AuthError=0,
-    Flags=win32cred.CREDUI_FLAGS_DO_NOT_PERSIST
-    | win32cred.CREDUI_FLAGS_SHOW_SAVE_CHECK_BOX,
-    Save=False,
-    UiInfo=uiinfo,
-)
-
-attrs = [
-    {"Keyword": "attr1", "Flags": 0, "Value": "unicode data"},
-    {"Keyword": "attr2", "Flags": 0, "Value": b"character data"},
-]
-cred = {
-    "Comment": "Created by win32cred_demo.py",
-    "UserName": target,
-    "TargetAlias": None,
-    "TargetName": target,
-    "CredentialBlob": pwd,
-    "Flags": win32cred.CRED_FLAGS_USERNAME_TARGET,
-    "Persist": win32cred.CRED_PERSIST_ENTERPRISE,
-    "Type": win32cred.CRED_TYPE_DOMAIN_PASSWORD,
-    "Attributes": attrs,
-}
-win32cred.CredWrite(cred)
-pwd = None
-print(win32cred.CredRead(target, win32cred.CRED_TYPE_DOMAIN_PASSWORD))
-
-## Marshal saved credential and use it to log on
-mc = win32cred.CredMarshalCredential(win32cred.UsernameTargetCredential, target)
-
-# As of pywin32 301 this no longer works for markh and unclear when it stopped, or
-# even if it ever did! # Fails in Python 2.7 too, so not a Python 3 regression.
-try:
-    th = win32security.LogonUser(
-        mc,
-        None,
-        "",
-        win32con.LOGON32_LOGON_INTERACTIVE,
-        win32con.LOGON32_PROVIDER_DEFAULT,
-    )
-    win32security.ImpersonateLoggedOnUser(th)
-    print("GetUserName:", win32api.GetUserName())
-    win32security.RevertToSelf()
-
-    ## Load user's profile.  (first check if user has a roaming profile)
-    username, domain = win32cred.CredUIParseUserName(target)
-    user_info_4 = win32net.NetUserGetInfo(None, username, 4)
-    profilepath = user_info_4["profile"]
-    ## LoadUserProfile apparently doesn't like an empty string
-    if not profilepath:
-        profilepath = None
-
-    ## leave Flags in since 2.3 still chokes on some types of optional keyword args
-    hk = win32profile.LoadUserProfile(
-        th, {"UserName": username, "Flags": 0, "ProfilePath": profilepath}
-    )
-    ## Get user's environment variables in a form that can be passed to win32process.CreateProcessAsUser
-    env = win32profile.CreateEnvironmentBlock(th, False)
-
-    ## Cleanup should probably be in a finally block
-    win32profile.UnloadUserProfile(th, hk)
-    th.Close()
-except win32security.error as exc:
-    print("Failed to login for some reason", exc)

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

@@ -1,41 +0,0 @@
-# This is a "demo" of win32file - it used to be more a test case than a
-# demo, so has been moved to the test directory.
-
-import os
-
-# Please contribute your favourite simple little demo.
-import win32api
-import win32con
-import win32file
-
-
-# A very simple demo - note that this does no more than you can do with
-# builtin Python file objects, so for something as simple as this, you
-# generally *should* use builtin Python objects.  Only use win32file etc
-# when you need win32 specific features not available in Python.
-def SimpleFileDemo():
-    testName = os.path.join(win32api.GetTempPath(), "win32file_demo_test_file")
-    if os.path.exists(testName):
-        os.unlink(testName)
-    # Open the file for writing.
-    handle = win32file.CreateFile(
-        testName, win32file.GENERIC_WRITE, 0, None, win32con.CREATE_NEW, 0, None
-    )
-    test_data = b"Hello\0there"
-    win32file.WriteFile(handle, test_data)
-    handle.Close()
-    # Open it for reading.
-    handle = win32file.CreateFile(
-        testName, win32file.GENERIC_READ, 0, None, win32con.OPEN_EXISTING, 0, None
-    )
-    rc, data = win32file.ReadFile(handle, 1024)
-    handle.Close()
-    if data == test_data:
-        print("Successfully wrote and read a file")
-    else:
-        raise Exception("Got different data back???")
-    os.unlink(testName)
-
-
-if __name__ == "__main__":
-    SimpleFileDemo()