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

@@ -1,230 +0,0 @@
-"""
-Windows Process Control
-
-winprocess.run launches a child process and returns the exit code.
-Optionally, it can:
-  redirect stdin, stdout & stderr to files
-  run the command as another user
-  limit the process's running time
-  control the process window (location, size, window state, desktop)
-Works on Windows NT, 2000 & XP. Requires Mark Hammond's win32
-extensions.
-
-This code is free for any purpose, with no warranty of any kind.
--- John B. Dell'Aquila <jbd@alum.mit.edu>
-"""
-
-import msvcrt
-import os
-
-import win32api
-import win32con
-import win32event
-import win32gui
-import win32process
-import win32security
-
-
-def logonUser(loginString):
-    """
-    Login as specified user and return handle.
-    loginString:  'Domain\nUser\nPassword'; for local
-        login use . or empty string as domain
-        e.g. '.\nadministrator\nsecret_password'
-    """
-    domain, user, passwd = loginString.split("\n")
-    return win32security.LogonUser(
-        user,
-        domain,
-        passwd,
-        win32con.LOGON32_LOGON_INTERACTIVE,
-        win32con.LOGON32_PROVIDER_DEFAULT,
-    )
-
-
-class Process:
-    """
-    A Windows process.
-    """
-
-    def __init__(
-        self,
-        cmd,
-        login=None,
-        hStdin=None,
-        hStdout=None,
-        hStderr=None,
-        show=1,
-        xy=None,
-        xySize=None,
-        desktop=None,
-    ):
-        """
-        Create a Windows process.
-        cmd:     command to run
-        login:   run as user 'Domain\nUser\nPassword'
-        hStdin, hStdout, hStderr:
-                 handles for process I/O; default is caller's stdin,
-                 stdout & stderr
-        show:    wShowWindow (0=SW_HIDE, 1=SW_NORMAL, ...)
-        xy:      window offset (x, y) of upper left corner in pixels
-        xySize:  window size (width, height) in pixels
-        desktop: lpDesktop - name of desktop e.g. 'winsta0\\default'
-                 None = inherit current desktop
-                 '' = create new desktop if necessary
-
-        User calling login requires additional privileges:
-          Act as part of the operating system [not needed on Windows XP]
-          Increase quotas
-          Replace a process level token
-        Login string must EITHER be an administrator's account
-        (ordinary user can't access current desktop - see Microsoft
-        Q165194) OR use desktop='' to run another desktop invisibly
-        (may be very slow to startup & finalize).
-        """
-        si = win32process.STARTUPINFO()
-        si.dwFlags = win32con.STARTF_USESTDHANDLES ^ win32con.STARTF_USESHOWWINDOW
-        if hStdin is None:
-            si.hStdInput = win32api.GetStdHandle(win32api.STD_INPUT_HANDLE)
-        else:
-            si.hStdInput = hStdin
-        if hStdout is None:
-            si.hStdOutput = win32api.GetStdHandle(win32api.STD_OUTPUT_HANDLE)
-        else:
-            si.hStdOutput = hStdout
-        if hStderr is None:
-            si.hStdError = win32api.GetStdHandle(win32api.STD_ERROR_HANDLE)
-        else:
-            si.hStdError = hStderr
-        si.wShowWindow = show
-        if xy is not None:
-            si.dwX, si.dwY = xy
-            si.dwFlags ^= win32con.STARTF_USEPOSITION
-        if xySize is not None:
-            si.dwXSize, si.dwYSize = xySize
-            si.dwFlags ^= win32con.STARTF_USESIZE
-        if desktop is not None:
-            si.lpDesktop = desktop
-        procArgs = (
-            None,  # appName
-            cmd,  # commandLine
-            None,  # processAttributes
-            None,  # threadAttributes
-            1,  # bInheritHandles
-            win32process.CREATE_NEW_CONSOLE,  # dwCreationFlags
-            None,  # newEnvironment
-            None,  # currentDirectory
-            si,
-        )  # startupinfo
-        if login is not None:
-            hUser = logonUser(login)
-            win32security.ImpersonateLoggedOnUser(hUser)
-            procHandles = win32process.CreateProcessAsUser(hUser, *procArgs)
-            win32security.RevertToSelf()
-        else:
-            procHandles = win32process.CreateProcess(*procArgs)
-        self.hProcess, self.hThread, self.PId, self.TId = procHandles
-
-    def wait(self, mSec=None):
-        """
-        Wait for process to finish or for specified number of
-        milliseconds to elapse.
-        """
-        if mSec is None:
-            mSec = win32event.INFINITE
-        return win32event.WaitForSingleObject(self.hProcess, mSec)
-
-    def kill(self, gracePeriod=5000):
-        """
-        Kill process. Try for an orderly shutdown via WM_CLOSE.  If
-        still running after gracePeriod (5 sec. default), terminate.
-        """
-        win32gui.EnumWindows(self.__close__, 0)
-        if self.wait(gracePeriod) != win32event.WAIT_OBJECT_0:
-            win32process.TerminateProcess(self.hProcess, 0)
-            win32api.Sleep(100)  # wait for resources to be released
-
-    def __close__(self, hwnd, dummy):
-        """
-        EnumWindows callback - sends WM_CLOSE to any window
-        owned by this process.
-        """
-        TId, PId = win32process.GetWindowThreadProcessId(hwnd)
-        if PId == self.PId:
-            win32gui.PostMessage(hwnd, win32con.WM_CLOSE, 0, 0)
-
-    def exitCode(self):
-        """
-        Return process exit code.
-        """
-        return win32process.GetExitCodeProcess(self.hProcess)
-
-
-def run(cmd, mSec=None, stdin=None, stdout=None, stderr=None, **kw):
-    """
-    Run cmd as a child process and return exit code.
-    mSec:  terminate cmd after specified number of milliseconds
-    stdin, stdout, stderr:
-           file objects for child I/O (use hStdin etc. to attach
-           handles instead of files); default is caller's stdin,
-           stdout & stderr;
-    kw:    see Process.__init__ for more keyword options
-    """
-    if stdin is not None:
-        kw["hStdin"] = msvcrt.get_osfhandle(stdin.fileno())
-    if stdout is not None:
-        kw["hStdout"] = msvcrt.get_osfhandle(stdout.fileno())
-    if stderr is not None:
-        kw["hStderr"] = msvcrt.get_osfhandle(stderr.fileno())
-    child = Process(cmd, **kw)
-    if child.wait(mSec) != win32event.WAIT_OBJECT_0:
-        child.kill()
-        raise OSError("process timeout exceeded")
-    return child.exitCode()
-
-
-if __name__ == "__main__":
-    # Pipe commands to a shell and display the output in notepad
-    print("Testing winprocess.py...")
-
-    import tempfile
-
-    timeoutSeconds = 15
-    cmdString = (
-        """\
-REM      Test of winprocess.py piping commands to a shell.\r
-REM      This 'notepad' process will terminate in %d seconds.\r
-vol\r
-net user\r
-_this_is_a_test_of_stderr_\r
-"""
-        % timeoutSeconds
-    )
-
-    cmd_name = tempfile.mktemp()
-    out_name = cmd_name + ".txt"
-    try:
-        cmd = open(cmd_name, "w+b")
-        out = open(out_name, "w+b")
-        cmd.write(cmdString.encode("mbcs"))
-        cmd.seek(0)
-        print(
-            "CMD.EXE exit code:",
-            run("cmd.exe", show=0, stdin=cmd, stdout=out, stderr=out),
-        )
-        cmd.close()
-        print(
-            "NOTEPAD exit code:",
-            run(
-                "notepad.exe %s" % out.name,
-                show=win32con.SW_MAXIMIZE,
-                mSec=timeoutSeconds * 1000,
-            ),
-        )
-        out.close()
-    finally:
-        for n in (cmd_name, out_name):
-            try:
-                os.unlink(cmd_name)
-            except OSError:
-                pass

py2docfx/venv/venv1/Lib/site-packages/win32/lib/_win32verstamp_pywin32ctypes.py

@@ -1,164 +0,0 @@
-"""
-A pure-python re-implementation of methods used by win32verstamp.
-This is to avoid a bootstraping problem where win32verstamp is used during build,
-but requires an installation of pywin32 to be present.
-We used to work around this by ignoring failure to verstamp, but that's easy to miss.
-
-Implementations adapted, simplified and typed from:
-- https://github.com/enthought/pywin32-ctypes/blob/main/win32ctypes/core/ctypes/_util.py
-- https://github.com/enthought/pywin32-ctypes/blob/main/win32ctypes/core/cffi/_resource.py
-- https://github.com/enthought/pywin32-ctypes/blob/main/win32ctypes/pywin32/win32api.py
-
----
-
-(C) Copyright 2014 Enthought, Inc., Austin, TX
-All right reserved.
-
-This file is open source software distributed according to the terms in
-https://github.com/enthought/pywin32-ctypes/blob/main/LICENSE.txt
-"""
-
-from __future__ import annotations
-
-from collections.abc import Iterable
-from ctypes import FormatError, WinDLL, get_last_error
-from ctypes.wintypes import (
-    BOOL,
-    DWORD,
-    HANDLE,
-    LPCWSTR,
-    LPVOID,
-    WORD,
-)
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ctypes import _NamedFuncPointer
-
-    from _typeshed import ReadableBuffer
-    from typing_extensions import Literal, SupportsBytes, SupportsIndex
-
-kernel32 = WinDLL("kernel32", use_last_error=True)
-
-###
-# https://github.com/enthought/pywin32-ctypes/blob/main/win32ctypes/core/ctypes/_util.py
-###
-
-
-def make_error(function: _NamedFuncPointer) -> OSError:
-    code = get_last_error()
-    exception = OSError()
-    exception.winerror = code
-    exception.function = function.__name__
-    exception.strerror = FormatError(code).strip()
-    return exception
-
-
-def check_null(result: int | None, function: _NamedFuncPointer, *_) -> int:
-    if result is None:
-        raise make_error(function)
-    return result
-
-
-def check_false(result: int | None, function: _NamedFuncPointer, *_) -> Literal[True]:
-    if not bool(result):
-        raise make_error(function)
-    else:
-        return True
-
-
-###
-# https://github.com/enthought/pywin32-ctypes/blob/main/win32ctypes/core/cffi/_resource.py
-###
-
-_BeginUpdateResource = kernel32.BeginUpdateResourceW
-_BeginUpdateResource.argtypes = [LPCWSTR, BOOL]
-_BeginUpdateResource.restype = HANDLE
-_BeginUpdateResource.errcheck = check_null  # type: ignore[assignment] # ctypes is badly typed
-
-
-_EndUpdateResource = kernel32.EndUpdateResourceW
-_EndUpdateResource.argtypes = [HANDLE, BOOL]
-_EndUpdateResource.restype = BOOL
-_EndUpdateResource.errcheck = check_false  # type: ignore[assignment] # ctypes is badly typed
-
-_UpdateResource = kernel32.UpdateResourceW
-_UpdateResource.argtypes = [HANDLE, LPCWSTR, LPCWSTR, WORD, LPVOID, DWORD]
-_UpdateResource.restype = BOOL
-_UpdateResource.errcheck = check_false  # type: ignore[assignment] # ctypes is badly typed
-
-
-###
-# https://github.com/enthought/pywin32-ctypes/blob/main/win32ctypes/pywin32/win32api.py
-###
-
-LANG_NEUTRAL = 0x00
-
-
-def BeginUpdateResource(filename: str, delete: bool):
-    """Get a handle that can be used by the :func:`UpdateResource`.
-
-    Parameters
-    ----------
-    fileName : str
-        The filename of the module to load.
-    delete : bool
-        When true all existing resources are deleted
-
-    Returns
-    -------
-    result : hModule
-        Handle of the resource.
-
-    """
-    return _BeginUpdateResource(filename, delete)
-
-
-def EndUpdateResource(handle: int, discard: bool) -> None:
-    """End the update resource of the handle.
-
-    Parameters
-    ----------
-    handle : hModule
-        The handle of the resource as it is returned
-        by :func:`BeginUpdateResource`
-
-    discard : bool
-        When True all writes are discarded.
-
-    """
-    _EndUpdateResource(handle, discard)
-
-
-def UpdateResource(
-    handle: int,
-    type: str | int,
-    name: str | int,
-    data: Iterable[SupportsIndex] | SupportsIndex | SupportsBytes | ReadableBuffer,
-    language: int = LANG_NEUTRAL,
-) -> None:
-    """Update a resource.
-
-    Parameters
-    ----------
-    handle : hModule
-        The handle of the resource file as returned by
-        :func:`BeginUpdateResource`.
-
-    type : str | int
-        The type of resource to update.
-
-    name : str | int
-        The name or Id of the resource to update.
-
-    data : bytes-like
-        A bytes like object is expected.
-
-    language : int
-        Language to use, default is LANG_NEUTRAL.
-
-    """
-    lp_data = bytes(data)
-    _UpdateResource(
-        handle, LPCWSTR(type), LPCWSTR(name), language, lp_data, len(lp_data)
-    )

py2docfx/venv/venv1/Lib/site-packages/win32/lib/afxres.py

@@ -1,8 +0,0 @@
-import warnings
-
-from pywin.mfc.afxres import *
-
-warnings.warn(
-    "Importing the global `afxres` module is deprecated. Import from `pywin.mfc.afxres` instead.",
-    category=DeprecationWarning,
-)