py2docfx 0.1.15rc2025477__py3-none-any.whl → 0.1.16__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/isapi/threaded_extension.py

@@ -1,191 +0,0 @@
-"""An ISAPI extension base class implemented using a thread-pool."""
-
-# $Id$
-
-import sys
-import threading
-import time
-import traceback
-
-from pywintypes import OVERLAPPED
-from win32event import INFINITE
-from win32file import (
-    CloseHandle,
-    CreateIoCompletionPort,
-    GetQueuedCompletionStatus,
-    PostQueuedCompletionStatus,
-)
-from win32security import SetThreadToken
-
-import isapi.simple
-from isapi import ExtensionError, isapicon
-
-ISAPI_REQUEST = 1
-ISAPI_SHUTDOWN = 2
-
-
-class WorkerThread(threading.Thread):
-    def __init__(self, extension, io_req_port):
-        self.running = False
-        self.io_req_port = io_req_port
-        self.extension = extension
-        threading.Thread.__init__(self)
-        # We wait 15 seconds for a thread to terminate, but if it fails to,
-        # we don't want the process to hang at exit waiting for it...
-        self.setDaemon(True)
-
-    def run(self):
-        self.running = True
-        while self.running:
-            errCode, bytes, key, overlapped = GetQueuedCompletionStatus(
-                self.io_req_port, INFINITE
-            )
-            if key == ISAPI_SHUTDOWN and overlapped is None:
-                break
-
-            # Let the parent extension handle the command.
-            dispatcher = self.extension.dispatch_map.get(key)
-            if dispatcher is None:
-                raise RuntimeError(f"Bad request '{key}'")
-
-            dispatcher(errCode, bytes, key, overlapped)
-
-    def call_handler(self, cblock):
-        self.extension.Dispatch(cblock)
-
-
-# A generic thread-pool based extension, using IO Completion Ports.
-# Sub-classes can override one method to implement a simple extension, or
-# may leverage the CompletionPort to queue their own requests, and implement a
-# fully asynch extension.
-class ThreadPoolExtension(isapi.simple.SimpleExtension):
-    "Base class for an ISAPI extension based around a thread-pool"
-
-    max_workers = 20
-    worker_shutdown_wait = 15000  # 15 seconds for workers to quit...
-
-    def __init__(self):
-        self.workers = []
-        # extensible dispatch map, for sub-classes that need to post their
-        # own requests to the completion port.
-        # Each of these functions is called with the result of
-        # GetQueuedCompletionStatus for our port.
-        self.dispatch_map = {
-            ISAPI_REQUEST: self.DispatchConnection,
-        }
-
-    def GetExtensionVersion(self, vi):
-        isapi.simple.SimpleExtension.GetExtensionVersion(self, vi)
-        # As per Q192800, the CompletionPort should be created with the number
-        # of processors, even if the number of worker threads is much larger.
-        # Passing 0 means the system picks the number.
-        self.io_req_port = CreateIoCompletionPort(-1, None, 0, 0)
-        # start up the workers
-        self.workers = []
-        for i in range(self.max_workers):
-            worker = WorkerThread(self, self.io_req_port)
-            worker.start()
-            self.workers.append(worker)
-
-    def HttpExtensionProc(self, control_block):
-        overlapped = OVERLAPPED()
-        overlapped.object = control_block
-        PostQueuedCompletionStatus(self.io_req_port, 0, ISAPI_REQUEST, overlapped)
-        return isapicon.HSE_STATUS_PENDING
-
-    def TerminateExtension(self, status):
-        for worker in self.workers:
-            worker.running = False
-        for worker in self.workers:
-            PostQueuedCompletionStatus(self.io_req_port, 0, ISAPI_SHUTDOWN, None)
-        # wait for them to terminate - pity we aren't using 'native' threads
-        # as then we could do a smart wait - but now we need to poll....
-        end_time = time.time() + self.worker_shutdown_wait / 1000
-        alive = self.workers
-        while alive:
-            if time.time() > end_time:
-                # xxx - might be nice to log something here.
-                break
-            time.sleep(0.2)
-            alive = [w for w in alive if w.is_alive()]
-        self.dispatch_map = {}  # break circles
-        CloseHandle(self.io_req_port)
-
-    # This is the one operation the base class supports - a simple
-    # Connection request.  We setup the thread-token, and dispatch to the
-    # sub-class's 'Dispatch' method.
-    def DispatchConnection(self, errCode, bytes, key, overlapped):
-        control_block = overlapped.object
-        # setup the correct user for this request
-        hRequestToken = control_block.GetImpersonationToken()
-        SetThreadToken(None, hRequestToken)
-        try:
-            try:
-                self.Dispatch(control_block)
-            except:
-                self.HandleDispatchError(control_block)
-        finally:
-            # reset the security context
-            SetThreadToken(None, None)
-
-    def Dispatch(self, ecb):
-        """Overridden by the sub-class to handle connection requests.
-
-        This class creates a thread-pool using a Windows completion port,
-        and dispatches requests via this port.  Sub-classes can generally
-        implement each connection request using blocking reads and writes, and
-        the thread-pool will still provide decent response to the end user.
-
-        The sub-class can set a max_workers attribute (default is 20).  Note
-        that this generally does *not* mean 20 threads will all be concurrently
-        running, via the magic of Windows completion ports.
-
-        There is no default implementation - sub-classes must implement this.
-        """
-        raise NotImplementedError("sub-classes should override Dispatch")
-
-    def HandleDispatchError(self, ecb):
-        """Handles errors in the Dispatch method.
-
-        When a Dispatch method call fails, this method is called to handle
-        the exception.  The default implementation formats the traceback
-        in the browser.
-        """
-        ecb.HttpStatusCode = isapicon.HSE_STATUS_ERROR
-        # control_block.LogData = "we failed!"
-        exc_typ, exc_val, exc_tb = sys.exc_info()
-        limit = None
-        try:
-            try:
-                import html
-
-                ecb.SendResponseHeaders(
-                    "200 OK", "Content-type: text/html\r\n\r\n", False
-                )
-                print(file=ecb)
-                print("<H3>Traceback (most recent call last):</H3>", file=ecb)
-                list = traceback.format_tb(
-                    exc_tb, limit
-                ) + traceback.format_exception_only(exc_typ, exc_val)
-                bold = list.pop()
-                print(
-                    "<PRE>{}<B>{}</B></PRE>".format(
-                        html.escape("".join(list)),
-                        html.escape(bold),
-                    ),
-                    file=ecb,
-                )
-            except ExtensionError:
-                # The client disconnected without reading the error body -
-                # it's probably not a real browser at the other end, ignore it.
-                pass
-            except:
-                print("FAILED to render the error message!")
-                traceback.print_exc()
-                print("ORIGINAL extension error:")
-                traceback.print_exception(exc_typ, exc_val, exc_tb)
-        finally:
-            # holding tracebacks in a local of a frame that may itself be
-            # part of a traceback used to be evil and cause leaks!
-            exc_tb = None
-            ecb.DoneWithSession()

py2docfx/venv/venv1/Lib/site-packages/portalocker/__about__.py

@@ -1,6 +0,0 @@
-__package_name__ = 'portalocker'
-__author__ = 'Rick van Hattem'
-__email__ = 'wolph@wol.ph'
-__version__ = '2.10.1'
-__description__ = '''Wraps the portalocker recipe for easy usage'''
-__url__ = 'https://github.com/WoLpH/portalocker'

py2docfx/venv/venv1/Lib/site-packages/portalocker/__init__.py

@@ -1,79 +0,0 @@
-from . import __about__, constants, exceptions, portalocker
-from .utils import (
-    BoundedSemaphore,
-    Lock,
-    RLock,
-    TemporaryFileLock,
-    open_atomic,
-)
-
-try:  # pragma: no cover
-    from .redis import RedisLock
-except ImportError:  # pragma: no cover
-    RedisLock = None  # type: ignore
-
-
-#: The package name on Pypi
-__package_name__ = __about__.__package_name__
-#: Current author and maintainer, view the git history for the previous ones
-__author__ = __about__.__author__
-#: Current author's email address
-__email__ = __about__.__email__
-#: Version number
-__version__ = '2.10.1'
-#: Package description for Pypi
-__description__ = __about__.__description__
-#: Package homepage
-__url__ = __about__.__url__
-
-
-#: Exception thrown when the file is already locked by someone else
-AlreadyLocked = exceptions.AlreadyLocked
-#: Exception thrown if an error occurred during locking
-LockException = exceptions.LockException
-
-
-#: Lock a file. Note that this is an advisory lock on Linux/Unix systems
-lock = portalocker.lock
-#: Unlock a file
-unlock = portalocker.unlock
-
-#: Place an exclusive lock.
-#: Only one process may hold an exclusive lock for a given file at a given
-#: time.
-LOCK_EX: constants.LockFlags = constants.LockFlags.EXCLUSIVE
-
-#: Place a shared lock.
-#: More than one process may hold a shared lock for a given file at a given
-#: time.
-LOCK_SH: constants.LockFlags = constants.LockFlags.SHARED
-
-#: Acquire the lock in a non-blocking fashion.
-LOCK_NB: constants.LockFlags = constants.LockFlags.NON_BLOCKING
-
-#: Remove an existing lock held by this process.
-LOCK_UN: constants.LockFlags = constants.LockFlags.UNBLOCK
-
-#: Locking flags enum
-LockFlags = constants.LockFlags
-
-#: Locking utility class to automatically handle opening with timeouts and
-#: context wrappers
-
-__all__ = [
-    'lock',
-    'unlock',
-    'LOCK_EX',
-    'LOCK_SH',
-    'LOCK_NB',
-    'LOCK_UN',
-    'LockFlags',
-    'LockException',
-    'Lock',
-    'RLock',
-    'AlreadyLocked',
-    'BoundedSemaphore',
-    'TemporaryFileLock',
-    'open_atomic',
-    'RedisLock',
-]

py2docfx/venv/venv1/Lib/site-packages/portalocker/__main__.py

@@ -1,122 +0,0 @@
-import argparse
-import logging
-import os
-import pathlib
-import re
-import typing
-
-base_path = pathlib.Path(__file__).parent.parent
-src_path = base_path / 'portalocker'
-dist_path = base_path / 'dist'
-_default_output_path = base_path / 'dist' / 'portalocker.py'
-
-_NAMES_RE = re.compile(r'(?P<names>[^()]+)$')
-_RELATIVE_IMPORT_RE = re.compile(
-    r'^from \.(?P<from>.*?) import (?P<paren>\(?)(?P<names>[^()]+)$',
-)
-_USELESS_ASSIGNMENT_RE = re.compile(r'^(?P<name>\w+) = \1\n$')
-
-_TEXT_TEMPLATE = """'''
-{}
-'''
-
-"""
-
-logger = logging.getLogger(__name__)
-
-
-def main(argv=None):
-    parser = argparse.ArgumentParser()
-
-    subparsers = parser.add_subparsers(required=True)
-    combine_parser = subparsers.add_parser(
-        'combine',
-        help='Combine all Python files into a single unified `portalocker.py` '
-        'file for easy distribution',
-    )
-    combine_parser.add_argument(
-        '--output-file',
-        '-o',
-        type=argparse.FileType('w'),
-        default=str(_default_output_path),
-    )
-
-    combine_parser.set_defaults(func=combine)
-    args = parser.parse_args(argv)
-    args.func(args)
-
-
-def _read_file(path: pathlib.Path, seen_files: typing.Set[pathlib.Path]):
-    if path in seen_files:
-        return
-
-    names = set()
-    seen_files.add(path)
-    paren = False
-    from_ = None
-    for line in path.open():
-        if paren:
-            if ')' in line:
-                line = line.split(')', 1)[1]
-                paren = False
-                continue
-
-            match = _NAMES_RE.match(line)
-        else:
-            match = _RELATIVE_IMPORT_RE.match(line)
-
-        if match:
-            if not paren:
-                paren = bool(match.group('paren'))
-                from_ = match.group('from')
-
-            if from_:
-                names.add(from_)
-                yield from _read_file(src_path / f'{from_}.py', seen_files)
-            else:
-                for name in match.group('names').split(','):
-                    name = name.strip()
-                    names.add(name)
-                    yield from _read_file(src_path / f'{name}.py', seen_files)
-        else:
-            yield _clean_line(line, names)
-
-
-def _clean_line(line, names):
-    # Replace `some_import.spam` with `spam`
-    if names:
-        joined_names = '|'.join(names)
-        line = re.sub(fr'\b({joined_names})\.', '', line)
-
-    # Replace useless assignments (e.g. `spam = spam`)
-    return _USELESS_ASSIGNMENT_RE.sub('', line)
-
-
-def combine(args):
-    output_file = args.output_file
-    pathlib.Path(output_file.name).parent.mkdir(parents=True, exist_ok=True)
-
-    output_file.write(
-        _TEXT_TEMPLATE.format((base_path / 'README.rst').read_text()),
-    )
-    output_file.write(
-        _TEXT_TEMPLATE.format((base_path / 'LICENSE').read_text()),
-    )
-
-    seen_files: typing.Set[pathlib.Path] = set()
-    for line in _read_file(src_path / '__init__.py', seen_files):
-        output_file.write(line)
-
-    output_file.flush()
-    output_file.close()
-
-    logger.info(f'Wrote combined file to {output_file.name}')
-    # Run black and ruff if available. If not then just run the file.
-    os.system(f'black {output_file.name}')
-    os.system(f'ruff --fix {output_file.name}')
-    os.system(f'python3 {output_file.name}')
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-    main()

py2docfx/venv/venv1/Lib/site-packages/portalocker/constants.py

@@ -1,59 +0,0 @@
-'''
-Locking constants
-
-Lock types:
-
-- `EXCLUSIVE` exclusive lock
-- `SHARED` shared lock
-
-Lock flags:
-
-- `NON_BLOCKING` non-blocking
-
-Manually unlock, only needed internally
-
-- `UNBLOCK` unlock
-'''
-
-import enum
-import os
-
-# The actual tests will execute the code anyhow so the following code can
-# safely be ignored from the coverage tests
-if os.name == 'nt':  # pragma: no cover
-    import msvcrt
-
-    #: exclusive lock
-    LOCK_EX = 0x1
-    #: shared lock
-    LOCK_SH = 0x2
-    #: non-blocking
-    LOCK_NB = 0x4
-    #: unlock
-    LOCK_UN = msvcrt.LK_UNLCK  # type: ignore
-
-elif os.name == 'posix':  # pragma: no cover
-    import fcntl
-
-    #: exclusive lock
-    LOCK_EX = fcntl.LOCK_EX
-    #: shared lock
-    LOCK_SH = fcntl.LOCK_SH
-    #: non-blocking
-    LOCK_NB = fcntl.LOCK_NB
-    #: unlock
-    LOCK_UN = fcntl.LOCK_UN
-
-else:  # pragma: no cover
-    raise RuntimeError('PortaLocker only defined for nt and posix platforms')
-
-
-class LockFlags(enum.IntFlag):
-    #: exclusive lock
-    EXCLUSIVE = LOCK_EX
-    #: shared lock
-    SHARED = LOCK_SH
-    #: non-blocking
-    NON_BLOCKING = LOCK_NB
-    #: unlock
-    UNBLOCK = LOCK_UN

py2docfx/venv/venv1/Lib/site-packages/portalocker/exceptions.py

@@ -1,27 +0,0 @@
-import typing
-
-
-class BaseLockException(Exception):  # noqa: N818
-    # Error codes:
-    LOCK_FAILED = 1
-
-    def __init__(
-        self,
-        *args: typing.Any,
-        fh: typing.Union[typing.IO, None, int] = None,
-        **kwargs: typing.Any,
-    ) -> None:
-        self.fh = fh
-        Exception.__init__(self, *args)
-
-
-class LockException(BaseLockException):
-    pass
-
-
-class AlreadyLocked(LockException):
-    pass
-
-
-class FileToLarge(LockException):
-    pass

py2docfx/venv/venv1/Lib/site-packages/portalocker/portalocker.py

@@ -1,154 +0,0 @@
-import os
-import typing
-
-from . import constants, exceptions
-
-# Alias for readability. Due to import recursion issues we cannot do:
-# from .constants import LockFlags
-LockFlags = constants.LockFlags
-
-
-class HasFileno(typing.Protocol):
-    def fileno(self) -> int: ...
-
-
-LOCKER: typing.Optional[typing.Callable[
-    [typing.Union[int, HasFileno], int], typing.Any]] = None
-
-
-if os.name == 'nt':  # pragma: no cover
-    import msvcrt
-
-    import pywintypes
-    import win32con
-    import win32file
-    import winerror
-
-    __overlapped = pywintypes.OVERLAPPED()
-
-    def lock(file_: typing.Union[typing.IO, int], flags: LockFlags):
-        # Windows locking does not support locking through `fh.fileno()` so
-        # we cast it to make mypy and pyright happy
-        file_ = typing.cast(typing.IO, file_)
-
-        mode = 0
-        if flags & LockFlags.NON_BLOCKING:
-            mode |= win32con.LOCKFILE_FAIL_IMMEDIATELY
-
-        if flags & LockFlags.EXCLUSIVE:
-            mode |= win32con.LOCKFILE_EXCLUSIVE_LOCK
-
-        # Save the old position so we can go back to that position but
-        # still lock from the beginning of the file
-        savepos = file_.tell()
-        if savepos:
-            file_.seek(0)
-
-        os_fh = msvcrt.get_osfhandle(file_.fileno())  # type: ignore
-        try:
-            win32file.LockFileEx(os_fh, mode, 0, -0x10000, __overlapped)
-        except pywintypes.error as exc_value:
-            # error: (33, 'LockFileEx', 'The process cannot access the file
-            # because another process has locked a portion of the file.')
-            if exc_value.winerror == winerror.ERROR_LOCK_VIOLATION:
-                raise exceptions.AlreadyLocked(
-                    exceptions.LockException.LOCK_FAILED,
-                    exc_value.strerror,
-                    fh=file_,
-                ) from exc_value
-            else:
-                # Q:  Are there exceptions/codes we should be dealing with
-                # here?
-                raise
-        finally:
-            if savepos:
-                file_.seek(savepos)
-
-    def unlock(file_: typing.IO):
-        try:
-            savepos = file_.tell()
-            if savepos:
-                file_.seek(0)
-
-            os_fh = msvcrt.get_osfhandle(file_.fileno())  # type: ignore
-            try:
-                win32file.UnlockFileEx(
-                    os_fh,
-                    0,
-                    -0x10000,
-                    __overlapped,
-                )
-            except pywintypes.error as exc:
-                if exc.winerror != winerror.ERROR_NOT_LOCKED:
-                    # Q:  Are there exceptions/codes we should be
-                    # dealing with here?
-                    raise
-            finally:
-                if savepos:
-                    file_.seek(savepos)
-        except OSError as exc:
-            raise exceptions.LockException(
-                exceptions.LockException.LOCK_FAILED,
-                exc.strerror,
-                fh=file_,
-            ) from exc
-
-elif os.name == 'posix':  # pragma: no cover
-    import errno
-    import fcntl
-
-    # The locking implementation.
-    # Expected values are either fcntl.flock() or fcntl.lockf(),
-    # but any callable that matches the syntax will be accepted.
-    LOCKER = fcntl.flock
-
-    def lock(file_: typing.Union[typing.IO, int], flags: LockFlags):
-        assert LOCKER is not None, 'We need a locking function in `LOCKER` '
-        # Locking with NON_BLOCKING without EXCLUSIVE or SHARED enabled
-        # results in an error
-        if (flags & LockFlags.NON_BLOCKING) and not flags & (
-            LockFlags.SHARED | LockFlags.EXCLUSIVE
-        ):
-            raise RuntimeError(
-                'When locking in non-blocking mode the SHARED '
-                'or EXCLUSIVE flag must be specified as well',
-            )
-
-        try:
-            LOCKER(file_, flags)
-        except OSError as exc_value:
-            # Python can use one of several different exception classes to
-            # represent timeout (most likely is BlockingIOError and IOError),
-            # but these errors may also represent other failures. On some
-            # systems, `IOError is OSError` which means checking for either
-            # IOError or OSError can mask other errors.
-            # The safest check is to catch OSError (from which the others
-            # inherit) and check the errno (which should be EACCESS or EAGAIN
-            # according to the spec).
-            if exc_value.errno in (errno.EACCES, errno.EAGAIN):
-                # A timeout exception, wrap this so the outer code knows to try
-                # again (if it wants to).
-                raise exceptions.AlreadyLocked(
-                    exc_value,
-                    fh=file_,
-                ) from exc_value
-            else:
-                # Something else went wrong; don't wrap this so we stop
-                # immediately.
-                raise exceptions.LockException(
-                    exc_value,
-                    fh=file_,
-                ) from exc_value
-        except EOFError as exc_value:
-            # On NFS filesystems, flock can raise an EOFError
-            raise exceptions.LockException(
-                exc_value,
-                fh=file_,
-            ) from exc_value
-
-    def unlock(file_: typing.IO):
-        assert LOCKER is not None, 'We need a locking function in `LOCKER` '
-        LOCKER(file_.fileno(), LockFlags.UNBLOCK)
-
-else:  # pragma: no cover
-    raise RuntimeError('PortaLocker only defined for nt and posix platforms')