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

@@ -1,246 +0,0 @@
-# Demonstrates using a taskbar icon to create and navigate between desktops
-
-import _thread
-import io
-import time
-import traceback
-
-import pywintypes
-import win32api
-import win32con
-import win32gui
-import win32process
-import win32service
-
-## "Shell_TrayWnd" is class of system tray window, broadcasts "TaskbarCreated" when initialized
-
-
-def desktop_name_dlgproc(hwnd, msg, wparam, lparam):
-    """Handles messages from the desktop name dialog box"""
-    if msg in (win32con.WM_CLOSE, win32con.WM_DESTROY):
-        win32gui.DestroyWindow(hwnd)
-    elif msg == win32con.WM_COMMAND:
-        if wparam == win32con.IDOK:
-            desktop_name = win32gui.GetDlgItemText(hwnd, 72)
-            print("new desktop name: ", desktop_name)
-            win32gui.DestroyWindow(hwnd)
-            create_desktop(desktop_name)
-
-        elif wparam == win32con.IDCANCEL:
-            win32gui.DestroyWindow(hwnd)
-
-
-def get_new_desktop_name(parent_hwnd):
-    """Create a dialog box to ask the user for name of desktop to be created"""
-    msgs = {
-        win32con.WM_COMMAND: desktop_name_dlgproc,
-        win32con.WM_CLOSE: desktop_name_dlgproc,
-        win32con.WM_DESTROY: desktop_name_dlgproc,
-    }
-    # dlg item [type, caption, id, (x,y,cx,cy), style, ex style
-    style = (
-        win32con.WS_BORDER
-        | win32con.WS_VISIBLE
-        | win32con.WS_CAPTION
-        | win32con.WS_SYSMENU
-    )  ## |win32con.DS_SYSMODAL
-    h = win32gui.CreateDialogIndirect(
-        win32api.GetModuleHandle(None),
-        [
-            ["One ugly dialog box !", (100, 100, 200, 100), style, 0],
-            [
-                "Button",
-                "Create",
-                win32con.IDOK,
-                (10, 10, 30, 20),
-                win32con.WS_VISIBLE
-                | win32con.WS_TABSTOP
-                | win32con.BS_HOLLOW
-                | win32con.BS_DEFPUSHBUTTON,
-            ],
-            [
-                "Button",
-                "Never mind",
-                win32con.IDCANCEL,
-                (45, 10, 50, 20),
-                win32con.WS_VISIBLE | win32con.WS_TABSTOP | win32con.BS_HOLLOW,
-            ],
-            ["Static", "Desktop name:", 71, (10, 40, 70, 10), win32con.WS_VISIBLE],
-            ["Edit", "", 72, (75, 40, 90, 10), win32con.WS_VISIBLE],
-        ],
-        parent_hwnd,
-        msgs,
-    )  ## parent_hwnd, msgs)
-
-    win32gui.EnableWindow(h, True)
-    hcontrol = win32gui.GetDlgItem(h, 72)
-    win32gui.EnableWindow(hcontrol, True)
-    win32gui.SetFocus(hcontrol)
-
-
-def new_icon(hdesk, desktop_name):
-    """Runs as a thread on each desktop to create a new tray icon and handle its messages"""
-    global id
-    id += 1
-    hdesk.SetThreadDesktop()
-    ## apparently the threads can't use same hinst, so each needs its own window class
-    windowclassname = "PythonDesktopManager" + desktop_name
-    wc = win32gui.WNDCLASS()
-    wc.hInstance = win32api.GetModuleHandle(None)
-    wc.lpszClassName = windowclassname
-    wc.style = win32con.CS_VREDRAW | win32con.CS_HREDRAW | win32con.CS_GLOBALCLASS
-    wc.hCursor = win32gui.LoadCursor(0, win32con.IDC_ARROW)
-    wc.hbrBackground = win32con.COLOR_WINDOW
-    wc.lpfnWndProc = icon_wndproc
-    windowclass = win32gui.RegisterClass(wc)
-    style = win32con.WS_OVERLAPPED | win32con.WS_SYSMENU
-    hwnd = win32gui.CreateWindow(
-        windowclass,
-        "dm_" + desktop_name,
-        win32con.WS_SYSMENU,
-        0,
-        0,
-        win32con.CW_USEDEFAULT,
-        win32con.CW_USEDEFAULT,
-        0,
-        0,
-        wc.hInstance,
-        None,
-    )
-    win32gui.UpdateWindow(hwnd)
-    flags = win32gui.NIF_ICON | win32gui.NIF_MESSAGE | win32gui.NIF_TIP
-    notify_info = (
-        hwnd,
-        id,
-        flags,
-        win32con.WM_USER + 20,
-        hicon,
-        "Desktop Manager (%s)" % desktop_name,
-    )
-    window_info[hwnd] = notify_info
-    ## wait for explorer to initialize system tray for new desktop
-    tray_found = 0
-    while not tray_found:
-        try:
-            tray_found = win32gui.FindWindow("Shell_TrayWnd", None)
-        except win32gui.error:
-            traceback.print_exc
-            time.sleep(0.5)
-    win32gui.Shell_NotifyIcon(win32gui.NIM_ADD, notify_info)
-    win32gui.PumpMessages()
-
-
-def create_desktop(desktop_name, start_explorer=1):
-    """Creates a new desktop and spawns a thread running on it
-    Will also start a new icon thread on an existing desktop
-    """
-    sa = pywintypes.SECURITY_ATTRIBUTES()
-    sa.bInheritHandle = 1
-
-    try:
-        hdesk = win32service.CreateDesktop(
-            desktop_name, 0, win32con.MAXIMUM_ALLOWED, sa
-        )
-    except win32service.error:
-        traceback.print_exc()
-        errbuf = io.StringIO()
-        traceback.print_exc(None, errbuf)
-        win32api.MessageBox(0, errbuf.getvalue(), "Desktop creation failed")
-        return
-    if start_explorer:
-        s = win32process.STARTUPINFO()
-        s.lpDesktop = desktop_name
-        prc_info = win32process.CreateProcess(
-            None,
-            "Explorer.exe",
-            None,
-            None,
-            True,
-            win32con.CREATE_NEW_CONSOLE,
-            None,
-            "c:\\",
-            s,
-        )
-
-    th = _thread.start_new_thread(new_icon, (hdesk, desktop_name))
-    hdesk.SwitchDesktop()
-
-
-def icon_wndproc(hwnd, msg, wp, lp):
-    """Window proc for the tray icons"""
-    if lp == win32con.WM_LBUTTONDOWN:
-        ## popup menu won't disappear if you don't do this
-        win32gui.SetForegroundWindow(hwnd)
-
-        curr_desktop = win32service.OpenInputDesktop(0, True, win32con.MAXIMUM_ALLOWED)
-        curr_desktop_name = win32service.GetUserObjectInformation(
-            curr_desktop, win32con.UOI_NAME
-        )
-        winsta = win32service.GetProcessWindowStation()
-        desktops = winsta.EnumDesktops()
-        m = win32gui.CreatePopupMenu()
-        desktop_cnt = len(desktops)
-        ## *don't* create an item 0
-        for d in range(1, desktop_cnt + 1):
-            mf_flags = win32con.MF_STRING
-            ## if you switch to winlogon yourself, there's nothing there and you're stuck
-            if desktops[d - 1].lower() in ("winlogon", "disconnect"):
-                mf_flags |= win32con.MF_GRAYED | win32con.MF_DISABLED
-            if desktops[d - 1] == curr_desktop_name:
-                mf_flags |= win32con.MF_CHECKED
-            win32gui.AppendMenu(m, mf_flags, d, desktops[d - 1])
-        win32gui.AppendMenu(m, win32con.MF_STRING, desktop_cnt + 1, "Create new ...")
-        win32gui.AppendMenu(m, win32con.MF_STRING, desktop_cnt + 2, "Exit")
-
-        x, y = win32gui.GetCursorPos()
-        d = win32gui.TrackPopupMenu(
-            m,
-            win32con.TPM_LEFTBUTTON | win32con.TPM_RETURNCMD | win32con.TPM_NONOTIFY,
-            x,
-            y,
-            0,
-            hwnd,
-            None,
-        )
-        win32gui.PumpWaitingMessages()
-        win32gui.DestroyMenu(m)
-        if d == desktop_cnt + 1:  ## Create new
-            get_new_desktop_name(hwnd)
-        elif d == desktop_cnt + 2:  ## Exit
-            win32gui.PostQuitMessage(0)
-            win32gui.Shell_NotifyIcon(win32gui.NIM_DELETE, window_info[hwnd])
-            del window_info[hwnd]
-            origin_desktop.SwitchDesktop()
-        elif d > 0:
-            hdesk = win32service.OpenDesktop(
-                desktops[d - 1], 0, 0, win32con.MAXIMUM_ALLOWED
-            )
-            hdesk.SwitchDesktop()
-        return 0
-    else:
-        return win32gui.DefWindowProc(hwnd, msg, wp, lp)
-
-
-window_info = {}
-origin_desktop = win32service.OpenInputDesktop(0, True, win32con.MAXIMUM_ALLOWED)
-origin_desktop_name = win32service.GetUserObjectInformation(
-    origin_desktop, win32service.UOI_NAME
-)
-
-hinst = win32api.GetModuleHandle(None)
-try:
-    hicon = win32gui.LoadIcon(hinst, 1)  ## python.exe and pythonw.exe
-except win32gui.error:
-    hicon = win32gui.LoadIcon(hinst, 135)  ## pythonwin's icon
-id = 0
-
-create_desktop(str(origin_desktop_name), 0)
-
-## wait for first thread to initialize its icon
-while not window_info:
-    time.sleep(1)
-
-## exit when last tray icon goes away
-while window_info:
-    win32gui.PumpWaitingMessages()
-    time.sleep(3)

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

@@ -1,143 +0,0 @@
-import win32api  # To translate NT Sids to account names.
-import win32con
-import win32evtlog
-import win32evtlogutil
-import win32security
-
-
-def ReadLog(computer, logType="Application", dumpEachRecord=0):
-    # read the entire log back.
-    h = win32evtlog.OpenEventLog(computer, logType)
-    numRecords = win32evtlog.GetNumberOfEventLogRecords(h)
-    # print(f"There are {numRecords} records")
-
-    num = 0
-    while 1:
-        objects = win32evtlog.ReadEventLog(
-            h,
-            win32evtlog.EVENTLOG_BACKWARDS_READ | win32evtlog.EVENTLOG_SEQUENTIAL_READ,
-            0,
-        )
-        if not objects:
-            break
-        for object in objects:
-            # get it for testing purposes, but don't print it.
-            msg = win32evtlogutil.SafeFormatMessage(object, logType)
-            if object.Sid is not None:
-                try:
-                    domain, user, typ = win32security.LookupAccountSid(
-                        computer, object.Sid
-                    )
-                    sidDesc = f"{domain}/{user}"
-                except win32security.error:
-                    sidDesc = str(object.Sid)
-                user_desc = f"Event associated with user {sidDesc}"
-            else:
-                user_desc = None
-            if dumpEachRecord:
-                print(
-                    "Event record from {!r} generated at {}".format(
-                        object.SourceName, object.TimeGenerated.Format()
-                    )
-                )
-                if user_desc:
-                    print(user_desc)
-                try:
-                    print(msg)
-                except UnicodeError:
-                    print("(unicode error printing message: repr() follows...)")
-                    print(repr(msg))
-
-        num += len(objects)
-
-    if numRecords == num:
-        print("Successfully read all", numRecords, "records")
-    else:
-        print(
-            "Couldn't get all records - reported %d, but found %d" % (numRecords, num)
-        )
-        print(
-            "(Note that some other app may have written records while we were running!)"
-        )
-    win32evtlog.CloseEventLog(h)
-
-
-def usage():
-    print("Writes an event to the event log.")
-    print("-w : Don't write any test records.")
-    print("-r : Don't read the event log")
-    print("-c : computerName : Process the log on the specified computer")
-    print("-v : Verbose")
-    print("-t : LogType - Use the specified log - default = 'Application'")
-
-
-def test():
-    # check if running on Windows NT, if not, display notice and terminate
-    if win32api.GetVersion() & 0x80000000:
-        print("This sample only runs on NT")
-        return
-
-    import getopt
-    import sys
-
-    opts, args = getopt.getopt(sys.argv[1:], "rwh?c:t:v")
-    computer = None
-    do_read = do_write = 1
-
-    logType = "Application"
-    verbose = 0
-
-    if len(args) > 0:
-        print("Invalid args")
-        usage()
-        return 1
-    for opt, val in opts:
-        if opt == "-t":
-            logType = val
-        if opt == "-c":
-            computer = val
-        if opt in ["-h", "-?"]:
-            usage()
-            return
-        if opt == "-r":
-            do_read = 0
-        if opt == "-w":
-            do_write = 0
-        if opt == "-v":
-            verbose += 1
-    if do_write:
-        ph = win32api.GetCurrentProcess()
-        th = win32security.OpenProcessToken(ph, win32con.TOKEN_READ)
-        my_sid = win32security.GetTokenInformation(th, win32security.TokenUser)[0]
-
-        win32evtlogutil.ReportEvent(
-            logType,
-            2,
-            strings=["The message text for event 2", "Another insert"],
-            data=b"Raw\0Data",
-            sid=my_sid,
-        )
-        win32evtlogutil.ReportEvent(
-            logType,
-            1,
-            eventType=win32evtlog.EVENTLOG_WARNING_TYPE,
-            strings=["A warning", "An even more dire warning"],
-            data=b"Raw\0Data",
-            sid=my_sid,
-        )
-        win32evtlogutil.ReportEvent(
-            logType,
-            1,
-            eventType=win32evtlog.EVENTLOG_INFORMATION_TYPE,
-            strings=["An info", "Too much info"],
-            data=b"Raw\0Data",
-            sid=my_sid,
-        )
-        print("Successfully wrote 3 records to the log")
-
-    if do_read:
-        ReadLog(computer, logType, verbose > 0)
-
-
-if __name__ == "__main__":
-    test()

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

@@ -1,33 +0,0 @@
-import os
-
-import win32api
-
-ver_strings = (
-    "Comments",
-    "InternalName",
-    "ProductName",
-    "CompanyName",
-    "LegalCopyright",
-    "ProductVersion",
-    "FileDescription",
-    "LegalTrademarks",
-    "PrivateBuild",
-    "FileVersion",
-    "OriginalFilename",
-    "SpecialBuild",
-)
-fname = os.environ["comspec"]
-d = win32api.GetFileVersionInfo(fname, "\\")
-## backslash as parm returns dictionary of numeric info corresponding to VS_FIXEDFILEINFO struc
-for n, v in d.items():
-    print(n, v)
-
-pairs = win32api.GetFileVersionInfo(fname, "\\VarFileInfo\\Translation")
-## \VarFileInfo\Translation returns list of available (language, codepage) pairs that can be used to retreive string info
-## any other must be of the form \StringfileInfo\%04X%04X\parm_name, middle two are language/codepage pair returned from above
-for lang, codepage in pairs:
-    print("lang:", lang, "codepage:", codepage)
-    for ver_string in ver_strings:
-        str_info = f"\\StringFileInfo\\{lang:04X}{codepage:04X}\\{ver_string}"
-        # print(str_inf)
-        print(ver_string, repr(win32api.GetFileVersionInfo(fname, str_info)))

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

@@ -1,101 +0,0 @@
-import os
-import tempfile
-
-import mmapfile
-import win32api
-import winerror
-
-system_info = win32api.GetSystemInfo()
-page_size = system_info[1]
-alloc_size = system_info[7]
-
-fname = tempfile.mktemp()
-mapping_name = os.path.split(fname)[1]
-fsize = 8 * page_size
-print(fname, fsize, mapping_name)
-
-m1 = mmapfile.mmapfile(File=fname, Name=mapping_name, MaximumSize=fsize)
-m1.seek(100)
-m1.write_byte(b"?")
-m1.seek(-1, 1)
-assert m1.read_byte() == b"?"
-
-## A reopened named mapping should have exact same size as original mapping
-m2 = mmapfile.mmapfile(Name=mapping_name, File=None, MaximumSize=fsize * 2)
-assert m2.size() == m1.size()
-m1.seek(0, 0)
-m1.write(fsize * b"s")
-assert m2.read(fsize) == fsize * b"s"
-
-move_src = 100
-move_dest = 500
-move_size = 150
-
-m2.seek(move_src, 0)
-assert m2.tell() == move_src
-m2.write(b"m" * move_size)
-m2.move(move_dest, move_src, move_size)
-m2.seek(move_dest, 0)
-assert m2.read(move_size) == b"m" * move_size
-##    m2.write('x'* (fsize+1))
-
-m2.close()
-m1.resize(fsize * 2)
-assert m1.size() == fsize * 2
-m1.seek(fsize)
-m1.write(b"w" * fsize)
-m1.flush()
-m1.close()
-os.remove(fname)
-
-
-## Test a file with size larger than 32 bits
-## need 10 GB free on drive where your temp folder lives
-fname_large = tempfile.mktemp()
-mapping_name = "Pywin32_large_mmap"
-offsetdata = b"This is start of offset"
-
-## Deliberately use odd numbers to test rounding logic
-fsize = (1024 * 1024 * 1024 * 10) + 333
-offset = (1024 * 1024 * 32) + 42
-view_size = (1024 * 1024 * 16) + 111
-
-## round mapping size and view size up to multiple of system page size
-if fsize % page_size:
-    fsize += page_size - (fsize % page_size)
-if view_size % page_size:
-    view_size += page_size - (view_size % page_size)
-## round offset down to multiple of allocation granularity
-offset -= offset % alloc_size
-
-m1 = None
-m2 = None
-try:
-    try:
-        m1 = mmapfile.mmapfile(fname_large, mapping_name, fsize, 0, offset * 2)
-    except mmapfile.error as exc:
-        # if we don't have enough disk-space, that's OK.
-        if exc.winerror != winerror.ERROR_DISK_FULL:
-            raise
-        print("skipping large file test - need", fsize, "available bytes.")
-    else:
-        m1.seek(offset)
-        m1.write(offsetdata)
-
-        ## When reopening an existing mapping without passing a file handle, you have
-        ##  to specify a positive size even though it's ignored
-        m2 = mmapfile.mmapfile(
-            File=None,
-            Name=mapping_name,
-            MaximumSize=1,
-            FileOffset=offset,
-            NumberOfBytesToMap=view_size,
-        )
-        assert m2.read(len(offsetdata)) == offsetdata
-finally:
-    if m1 is not None:
-        m1.close()
-    if m2 is not None:
-        m2.close()
-    if os.path.exists(fname_large):
-        os.remove(fname_large)

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

@@ -1,17 +0,0 @@
-"""cat.py
-a version of unix cat, tweaked to show off runproc.py
-"""
-
-import sys
-
-data = sys.stdin.read(1)
-sys.stdout.write(data)
-sys.stdout.flush()
-while data:
-    data = sys.stdin.read(1)
-    sys.stdout.write(data)
-    sys.stdout.flush()
-# Just here to have something to read from stderr.
-sys.stderr.write("Blah...")
-
-# end of cat.py

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

@@ -1,114 +0,0 @@
-"""runproc.py
-
-start a process with three inherited pipes.
-Try to write to and read from those.
-"""
-
-import msvcrt
-import os
-
-import win32api
-import win32con
-import win32file
-import win32pipe
-import win32process
-import win32security
-
-
-class Process:
-    def run(self, cmdline):
-        # security attributes for pipes
-        sAttrs = win32security.SECURITY_ATTRIBUTES()
-        sAttrs.bInheritHandle = 1
-
-        # create pipes
-        hStdin_r, self.hStdin_w = win32pipe.CreatePipe(sAttrs, 0)
-        self.hStdout_r, hStdout_w = win32pipe.CreatePipe(sAttrs, 0)
-        self.hStderr_r, hStderr_w = win32pipe.CreatePipe(sAttrs, 0)
-
-        # set the info structure for the new process.
-        StartupInfo = win32process.STARTUPINFO()
-        StartupInfo.hStdInput = hStdin_r
-        StartupInfo.hStdOutput = hStdout_w
-        StartupInfo.hStdError = hStderr_w
-        StartupInfo.dwFlags = win32process.STARTF_USESTDHANDLES
-        # Mark doesn't support wShowWindow yet.
-        # StartupInfo.dwFlags = StartupInfo.dwFlags | win32process.STARTF_USESHOWWINDOW
-        # StartupInfo.wShowWindow = win32con.SW_HIDE
-
-        # Create new output read handles and the input write handle. Set
-        # the inheritance properties to FALSE. Otherwise, the child inherits
-        # the these handles; resulting in non-closeable handles to the pipes
-        # being created.
-        pid = win32api.GetCurrentProcess()
-
-        tmp = win32api.DuplicateHandle(
-            pid,
-            self.hStdin_w,
-            pid,
-            0,
-            0,  # non-inheritable!!
-            win32con.DUPLICATE_SAME_ACCESS,
-        )
-        # Close the inhertible version of the handle
-        win32file.CloseHandle(self.hStdin_w)
-        self.hStdin_w = tmp
-        tmp = win32api.DuplicateHandle(
-            pid,
-            self.hStdout_r,
-            pid,
-            0,
-            0,  # non-inheritable!
-            win32con.DUPLICATE_SAME_ACCESS,
-        )
-        # Close the inhertible version of the handle
-        win32file.CloseHandle(self.hStdout_r)
-        self.hStdout_r = tmp
-
-        # start the process.
-        hProcess, hThread, dwPid, dwTid = win32process.CreateProcess(
-            None,  # program
-            cmdline,  # command line
-            None,  # process security attributes
-            None,  # thread attributes
-            1,  # inherit handles, or USESTDHANDLES won't work.
-            # creation flags. Don't access the console.
-            0,  # Don't need anything here.
-            # If you're in a GUI app, you should use
-            # CREATE_NEW_CONSOLE here, or any subprocesses
-            # might fall victim to the problem described in:
-            # KB article: Q156755, cmd.exe requires
-            # an NT console in order to perform redirection..
-            None,  # no new environment
-            None,  # current directory (stay where we are)
-            StartupInfo,
-        )
-        # normally, we would save the pid etc. here...
-
-        # Child is launched. Close the parents copy of those pipe handles
-        # that only the child should have open.
-        # You need to make sure that no handles to the write end of the
-        # output pipe are maintained in this process or else the pipe will
-        # not close when the child process exits and the ReadFile will hang.
-        win32file.CloseHandle(hStderr_w)
-        win32file.CloseHandle(hStdout_w)
-        win32file.CloseHandle(hStdin_r)
-
-        self.stdin = os.fdopen(msvcrt.open_osfhandle(self.hStdin_w, 0), "wb")
-        self.stdin.write("hmmmmm\r\n")
-        self.stdin.flush()
-        self.stdin.close()
-
-        self.stdout = os.fdopen(msvcrt.open_osfhandle(self.hStdout_r, 0), "rb")
-        print(f"Read on stdout: {self.stdout.read()!r}")
-
-        self.stderr = os.fdopen(msvcrt.open_osfhandle(self.hStderr_r, 0), "rb")
-        print(f"Read on stderr: {self.stderr.read()!r}")
-
-
-if __name__ == "__main__":
-    p = Process()
-    exe = win32api.GetModuleFileName(0)
-    p.run(exe + " cat.py")
-
-# end of runproc.py