hmdev-cli 1.0.0 → 1.0.2

package/python/.venv/Lib/site-packages/anyio/to_interpreter.py

@@ -1,246 +0,0 @@
-from __future__ import annotations
-
-__all__ = (
-    "run_sync",
-    "current_default_interpreter_limiter",
-)
-
-import atexit
-import os
-import sys
-from collections import deque
-from collections.abc import Callable
-from typing import Any, Final, TypeVar
-
-from . import current_time, to_thread
-from ._core._exceptions import BrokenWorkerInterpreter
-from ._core._synchronization import CapacityLimiter
-from .lowlevel import RunVar
-
-if sys.version_info >= (3, 11):
-    from typing import TypeVarTuple, Unpack
-else:
-    from typing_extensions import TypeVarTuple, Unpack
-
-if sys.version_info >= (3, 14):
-    from concurrent.interpreters import ExecutionFailed, create
-
-    def _interp_call(
-        func: Callable[..., Any], args: tuple[Any, ...]
-    ) -> tuple[Any, bool]:
-        try:
-            retval = func(*args)
-        except BaseException as exc:
-            return exc, True
-        else:
-            return retval, False
-
-    class _Worker:
-        last_used: float = 0
-
-        def __init__(self) -> None:
-            self._interpreter = create()
-
-        def destroy(self) -> None:
-            self._interpreter.close()
-
-        def call(
-            self,
-            func: Callable[..., T_Retval],
-            args: tuple[Any, ...],
-        ) -> T_Retval:
-            try:
-                res, is_exception = self._interpreter.call(_interp_call, func, args)
-            except ExecutionFailed as exc:
-                raise BrokenWorkerInterpreter(exc.excinfo) from exc
-
-            if is_exception:
-                raise res
-
-            return res
-elif sys.version_info >= (3, 13):
-    import _interpqueues
-    import _interpreters
-
-    UNBOUND: Final = 2  # I have no clue how this works, but it was used in the stdlib
-    FMT_UNPICKLED: Final = 0
-    FMT_PICKLED: Final = 1
-    QUEUE_PICKLE_ARGS: Final = (FMT_PICKLED, UNBOUND)
-    QUEUE_UNPICKLE_ARGS: Final = (FMT_UNPICKLED, UNBOUND)
-
-    _run_func = compile(
-        """
-import _interpqueues
-from _interpreters import NotShareableError
-from pickle import loads, dumps, HIGHEST_PROTOCOL
-
-QUEUE_PICKLE_ARGS = (1, 2)
-QUEUE_UNPICKLE_ARGS = (0, 2)
-
-item = _interpqueues.get(queue_id)[0]
-try:
-    func, args = loads(item)
-    retval = func(*args)
-except BaseException as exc:
-    is_exception = True
-    retval = exc
-else:
-    is_exception = False
-
-try:
-    _interpqueues.put(queue_id, (retval, is_exception), *QUEUE_UNPICKLE_ARGS)
-except NotShareableError:
-    retval = dumps(retval, HIGHEST_PROTOCOL)
-    _interpqueues.put(queue_id, (retval, is_exception), *QUEUE_PICKLE_ARGS)
-    """,
-        "<string>",
-        "exec",
-    )
-
-    class _Worker:
-        last_used: float = 0
-
-        def __init__(self) -> None:
-            self._interpreter_id = _interpreters.create()
-            self._queue_id = _interpqueues.create(1, *QUEUE_UNPICKLE_ARGS)
-            _interpreters.set___main___attrs(
-                self._interpreter_id, {"queue_id": self._queue_id}
-            )
-
-        def destroy(self) -> None:
-            _interpqueues.destroy(self._queue_id)
-            _interpreters.destroy(self._interpreter_id)
-
-        def call(
-            self,
-            func: Callable[..., T_Retval],
-            args: tuple[Any, ...],
-        ) -> T_Retval:
-            import pickle
-
-            item = pickle.dumps((func, args), pickle.HIGHEST_PROTOCOL)
-            _interpqueues.put(self._queue_id, item, *QUEUE_PICKLE_ARGS)
-            exc_info = _interpreters.exec(self._interpreter_id, _run_func)
-            if exc_info:
-                raise BrokenWorkerInterpreter(exc_info)
-
-            res = _interpqueues.get(self._queue_id)
-            (res, is_exception), fmt = res[:2]
-            if fmt == FMT_PICKLED:
-                res = pickle.loads(res)
-
-            if is_exception:
-                raise res
-
-            return res
-else:
-
-    class _Worker:
-        last_used: float = 0
-
-        def __init__(self) -> None:
-            raise RuntimeError("subinterpreters require at least Python 3.13")
-
-        def call(
-            self,
-            func: Callable[..., T_Retval],
-            args: tuple[Any, ...],
-        ) -> T_Retval:
-            raise NotImplementedError
-
-        def destroy(self) -> None:
-            pass
-
-
-DEFAULT_CPU_COUNT: Final = 8  # this is just an arbitrarily selected value
-MAX_WORKER_IDLE_TIME = (
-    30  # seconds a subinterpreter can be idle before becoming eligible for pruning
-)
-
-T_Retval = TypeVar("T_Retval")
-PosArgsT = TypeVarTuple("PosArgsT")
-
-_idle_workers = RunVar[deque[_Worker]]("_available_workers")
-_default_interpreter_limiter = RunVar[CapacityLimiter]("_default_interpreter_limiter")
-
-
-def _stop_workers(workers: deque[_Worker]) -> None:
-    for worker in workers:
-        worker.destroy()
-
-    workers.clear()
-
-
-async def run_sync(
-    func: Callable[[Unpack[PosArgsT]], T_Retval],
-    *args: Unpack[PosArgsT],
-    limiter: CapacityLimiter | None = None,
-) -> T_Retval:
-    """
-    Call the given function with the given arguments in a subinterpreter.
-
-    .. warning:: On Python 3.13, the :mod:`concurrent.interpreters` module was not yet
-        available, so the code path for that Python version relies on an undocumented,
-        private API. As such, it is recommended to not rely on this function for anything
-        mission-critical on Python 3.13.
-
-    :param func: a callable
-    :param args: the positional arguments for the callable
-    :param limiter: capacity limiter to use to limit the total number of subinterpreters
-        running (if omitted, the default limiter is used)
-    :return: the result of the call
-    :raises BrokenWorkerInterpreter: if there's an internal error in a subinterpreter
-
-    """
-    if limiter is None:
-        limiter = current_default_interpreter_limiter()
-
-    try:
-        idle_workers = _idle_workers.get()
-    except LookupError:
-        idle_workers = deque()
-        _idle_workers.set(idle_workers)
-        atexit.register(_stop_workers, idle_workers)
-
-    async with limiter:
-        try:
-            worker = idle_workers.pop()
-        except IndexError:
-            worker = _Worker()
-
-    try:
-        return await to_thread.run_sync(
-            worker.call,
-            func,
-            args,
-            limiter=limiter,
-        )
-    finally:
-        # Prune workers that have been idle for too long
-        now = current_time()
-        while idle_workers:
-            if now - idle_workers[0].last_used <= MAX_WORKER_IDLE_TIME:
-                break
-
-            await to_thread.run_sync(idle_workers.popleft().destroy, limiter=limiter)
-
-        worker.last_used = current_time()
-        idle_workers.append(worker)
-
-
-def current_default_interpreter_limiter() -> CapacityLimiter:
-    """
-    Return the capacity limiter used by default to limit the number of concurrently
-    running subinterpreters.
-
-    Defaults to the number of CPU cores.
-
-    :return: a capacity limiter object
-
-    """
-    try:
-        return _default_interpreter_limiter.get()
-    except LookupError:
-        limiter = CapacityLimiter(os.cpu_count() or DEFAULT_CPU_COUNT)
-        _default_interpreter_limiter.set(limiter)
-        return limiter

package/python/.venv/Lib/site-packages/anyio/to_process.py

@@ -1,266 +0,0 @@
-from __future__ import annotations
-
-__all__ = (
-    "current_default_process_limiter",
-    "process_worker",
-    "run_sync",
-)
-
-import os
-import pickle
-import subprocess
-import sys
-from collections import deque
-from collections.abc import Callable
-from importlib.util import module_from_spec, spec_from_file_location
-from typing import TypeVar, cast
-
-from ._core._eventloop import current_time, get_async_backend, get_cancelled_exc_class
-from ._core._exceptions import BrokenWorkerProcess
-from ._core._subprocesses import open_process
-from ._core._synchronization import CapacityLimiter
-from ._core._tasks import CancelScope, fail_after
-from .abc import ByteReceiveStream, ByteSendStream, Process
-from .lowlevel import RunVar, checkpoint_if_cancelled
-from .streams.buffered import BufferedByteReceiveStream
-
-if sys.version_info >= (3, 11):
-    from typing import TypeVarTuple, Unpack
-else:
-    from typing_extensions import TypeVarTuple, Unpack
-
-WORKER_MAX_IDLE_TIME = 300  # 5 minutes
-
-T_Retval = TypeVar("T_Retval")
-PosArgsT = TypeVarTuple("PosArgsT")
-
-_process_pool_workers: RunVar[set[Process]] = RunVar("_process_pool_workers")
-_process_pool_idle_workers: RunVar[deque[tuple[Process, float]]] = RunVar(
-    "_process_pool_idle_workers"
-)
-_default_process_limiter: RunVar[CapacityLimiter] = RunVar("_default_process_limiter")
-
-
-async def run_sync(  # type: ignore[return]
-    func: Callable[[Unpack[PosArgsT]], T_Retval],
-    *args: Unpack[PosArgsT],
-    cancellable: bool = False,
-    limiter: CapacityLimiter | None = None,
-) -> T_Retval:
-    """
-    Call the given function with the given arguments in a worker process.
-
-    If the ``cancellable`` option is enabled and the task waiting for its completion is
-    cancelled, the worker process running it will be abruptly terminated using SIGKILL
-    (or ``terminateProcess()`` on Windows).
-
-    :param func: a callable
-    :param args: positional arguments for the callable
-    :param cancellable: ``True`` to allow cancellation of the operation while it's
-        running
-    :param limiter: capacity limiter to use to limit the total amount of processes
-        running (if omitted, the default limiter is used)
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-    :return: an awaitable that yields the return value of the function.
-
-    """
-
-    async def send_raw_command(pickled_cmd: bytes) -> object:
-        try:
-            await stdin.send(pickled_cmd)
-            response = await buffered.receive_until(b"\n", 50)
-            status, length = response.split(b" ")
-            if status not in (b"RETURN", b"EXCEPTION"):
-                raise RuntimeError(
-                    f"Worker process returned unexpected response: {response!r}"
-                )
-
-            pickled_response = await buffered.receive_exactly(int(length))
-        except BaseException as exc:
-            workers.discard(process)
-            try:
-                process.kill()
-                with CancelScope(shield=True):
-                    await process.aclose()
-            except ProcessLookupError:
-                pass
-
-            if isinstance(exc, get_cancelled_exc_class()):
-                raise
-            else:
-                raise BrokenWorkerProcess from exc
-
-        retval = pickle.loads(pickled_response)
-        if status == b"EXCEPTION":
-            assert isinstance(retval, BaseException)
-            raise retval
-        else:
-            return retval
-
-    # First pickle the request before trying to reserve a worker process
-    await checkpoint_if_cancelled()
-    request = pickle.dumps(("run", func, args), protocol=pickle.HIGHEST_PROTOCOL)
-
-    # If this is the first run in this event loop thread, set up the necessary variables
-    try:
-        workers = _process_pool_workers.get()
-        idle_workers = _process_pool_idle_workers.get()
-    except LookupError:
-        workers = set()
-        idle_workers = deque()
-        _process_pool_workers.set(workers)
-        _process_pool_idle_workers.set(idle_workers)
-        get_async_backend().setup_process_pool_exit_at_shutdown(workers)
-
-    async with limiter or current_default_process_limiter():
-        # Pop processes from the pool (starting from the most recently used) until we
-        # find one that hasn't exited yet
-        process: Process
-        while idle_workers:
-            process, idle_since = idle_workers.pop()
-            if process.returncode is None:
-                stdin = cast(ByteSendStream, process.stdin)
-                buffered = BufferedByteReceiveStream(
-                    cast(ByteReceiveStream, process.stdout)
-                )
-
-                # Prune any other workers that have been idle for WORKER_MAX_IDLE_TIME
-                # seconds or longer
-                now = current_time()
-                killed_processes: list[Process] = []
-                while idle_workers:
-                    if now - idle_workers[0][1] < WORKER_MAX_IDLE_TIME:
-                        break
-
-                    process_to_kill, idle_since = idle_workers.popleft()
-                    process_to_kill.kill()
-                    workers.remove(process_to_kill)
-                    killed_processes.append(process_to_kill)
-
-                with CancelScope(shield=True):
-                    for killed_process in killed_processes:
-                        await killed_process.aclose()
-
-                break
-
-            workers.remove(process)
-        else:
-            command = [sys.executable, "-u", "-m", __name__]
-            process = await open_process(
-                command, stdin=subprocess.PIPE, stdout=subprocess.PIPE
-            )
-            try:
-                stdin = cast(ByteSendStream, process.stdin)
-                buffered = BufferedByteReceiveStream(
-                    cast(ByteReceiveStream, process.stdout)
-                )
-                with fail_after(20):
-                    message = await buffered.receive(6)
-
-                if message != b"READY\n":
-                    raise BrokenWorkerProcess(
-                        f"Worker process returned unexpected response: {message!r}"
-                    )
-
-                main_module_path = getattr(sys.modules["__main__"], "__file__", None)
-                pickled = pickle.dumps(
-                    ("init", sys.path, main_module_path),
-                    protocol=pickle.HIGHEST_PROTOCOL,
-                )
-                await send_raw_command(pickled)
-            except (BrokenWorkerProcess, get_cancelled_exc_class()):
-                raise
-            except BaseException as exc:
-                process.kill()
-                raise BrokenWorkerProcess(
-                    "Error during worker process initialization"
-                ) from exc
-
-            workers.add(process)
-
-        with CancelScope(shield=not cancellable):
-            try:
-                return cast(T_Retval, await send_raw_command(request))
-            finally:
-                if process in workers:
-                    idle_workers.append((process, current_time()))
-
-
-def current_default_process_limiter() -> CapacityLimiter:
-    """
-    Return the capacity limiter that is used by default to limit the number of worker
-    processes.
-
-    :return: a capacity limiter object
-
-    """
-    try:
-        return _default_process_limiter.get()
-    except LookupError:
-        limiter = CapacityLimiter(os.cpu_count() or 2)
-        _default_process_limiter.set(limiter)
-        return limiter
-
-
-def process_worker() -> None:
-    # Redirect standard streams to os.devnull so that user code won't interfere with the
-    # parent-worker communication
-    stdin = sys.stdin
-    stdout = sys.stdout
-    sys.stdin = open(os.devnull)
-    sys.stdout = open(os.devnull, "w")
-
-    stdout.buffer.write(b"READY\n")
-    while True:
-        retval = exception = None
-        try:
-            command, *args = pickle.load(stdin.buffer)
-        except EOFError:
-            return
-        except BaseException as exc:
-            exception = exc
-        else:
-            if command == "run":
-                func, args = args
-                try:
-                    retval = func(*args)
-                except BaseException as exc:
-                    exception = exc
-            elif command == "init":
-                main_module_path: str | None
-                sys.path, main_module_path = args
-                del sys.modules["__main__"]
-                if main_module_path and os.path.isfile(main_module_path):
-                    # Load the parent's main module but as __mp_main__ instead of
-                    # __main__ (like multiprocessing does) to avoid infinite recursion
-                    try:
-                        spec = spec_from_file_location("__mp_main__", main_module_path)
-                        if spec and spec.loader:
-                            main = module_from_spec(spec)
-                            spec.loader.exec_module(main)
-                            sys.modules["__main__"] = main
-                    except BaseException as exc:
-                        exception = exc
-        try:
-            if exception is not None:
-                status = b"EXCEPTION"
-                pickled = pickle.dumps(exception, pickle.HIGHEST_PROTOCOL)
-            else:
-                status = b"RETURN"
-                pickled = pickle.dumps(retval, pickle.HIGHEST_PROTOCOL)
-        except BaseException as exc:
-            exception = exc
-            status = b"EXCEPTION"
-            pickled = pickle.dumps(exc, pickle.HIGHEST_PROTOCOL)
-
-        stdout.buffer.write(b"%s %d\n" % (status, len(pickled)))
-        stdout.buffer.write(pickled)
-
-        # Respect SIGTERM
-        if isinstance(exception, SystemExit):
-            raise exception
-
-
-if __name__ == "__main__":
-    process_worker()

package/python/.venv/Lib/site-packages/anyio/to_thread.py

@@ -1,78 +0,0 @@
-from __future__ import annotations
-
-__all__ = (
-    "run_sync",
-    "current_default_thread_limiter",
-)
-
-import sys
-from collections.abc import Callable
-from typing import TypeVar
-from warnings import warn
-
-from ._core._eventloop import get_async_backend
-from .abc import CapacityLimiter
-
-if sys.version_info >= (3, 11):
-    from typing import TypeVarTuple, Unpack
-else:
-    from typing_extensions import TypeVarTuple, Unpack
-
-T_Retval = TypeVar("T_Retval")
-PosArgsT = TypeVarTuple("PosArgsT")
-
-
-async def run_sync(
-    func: Callable[[Unpack[PosArgsT]], T_Retval],
-    *args: Unpack[PosArgsT],
-    abandon_on_cancel: bool = False,
-    cancellable: bool | None = None,
-    limiter: CapacityLimiter | None = None,
-) -> T_Retval:
-    """
-    Call the given function with the given arguments in a worker thread.
-
-    If the ``abandon_on_cancel`` option is enabled and the task waiting for its
-    completion is cancelled, the thread will still run its course but its
-    return value (or any raised exception) will be ignored.
-
-    :param func: a callable
-    :param args: positional arguments for the callable
-    :param abandon_on_cancel: ``True`` to abandon the thread (leaving it to run
-        unchecked on own) if the host task is cancelled, ``False`` to ignore
-        cancellations in the host task until the operation has completed in the worker
-        thread
-    :param cancellable: deprecated alias of ``abandon_on_cancel``; will override
-        ``abandon_on_cancel`` if both parameters are passed
-    :param limiter: capacity limiter to use to limit the total amount of threads running
-        (if omitted, the default limiter is used)
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-    :return: an awaitable that yields the return value of the function.
-
-    """
-    if cancellable is not None:
-        abandon_on_cancel = cancellable
-        warn(
-            "The `cancellable=` keyword argument to `anyio.to_thread.run_sync` is "
-            "deprecated since AnyIO 4.1.0; use `abandon_on_cancel=` instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-    return await get_async_backend().run_sync_in_worker_thread(
-        func, args, abandon_on_cancel=abandon_on_cancel, limiter=limiter
-    )
-
-
-def current_default_thread_limiter() -> CapacityLimiter:
-    """
-    Return the capacity limiter that is used by default to limit the number of
-    concurrent threads.
-
-    :return: a capacity limiter object
-    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
-        current thread
-
-    """
-    return get_async_backend().current_default_thread_limiter()

package/python/.venv/Lib/site-packages/anyio-4.13.0.dist-info/INSTALLER

@@ -1 +0,0 @@
-pip

package/python/.venv/Lib/site-packages/anyio-4.13.0.dist-info/METADATA

@@ -1,105 +0,0 @@
-Metadata-Version: 2.4
-Name: anyio
-Version: 4.13.0
-Summary: High-level concurrency and networking framework on top of asyncio or Trio
-Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
-License-Expression: MIT
-Project-URL: Documentation, https://anyio.readthedocs.io/en/latest/
-Project-URL: Changelog, https://anyio.readthedocs.io/en/stable/versionhistory.html
-Project-URL: Source code, https://github.com/agronholm/anyio
-Project-URL: Issue tracker, https://github.com/agronholm/anyio/issues
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Framework :: AnyIO
-Classifier: Typing :: Typed
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Requires-Python: >=3.10
-Description-Content-Type: text/x-rst
-License-File: LICENSE
-Requires-Dist: exceptiongroup>=1.0.2; python_version < "3.11"
-Requires-Dist: idna>=2.8
-Requires-Dist: typing_extensions>=4.5; python_version < "3.13"
-Provides-Extra: trio
-Requires-Dist: trio>=0.32.0; extra == "trio"
-Dynamic: license-file
-
-.. image:: https://github.com/agronholm/anyio/actions/workflows/test.yml/badge.svg
-  :target: https://github.com/agronholm/anyio/actions/workflows/test.yml
-  :alt: Build Status
-.. image:: https://coveralls.io/repos/github/agronholm/anyio/badge.svg?branch=master
-  :target: https://coveralls.io/github/agronholm/anyio?branch=master
-  :alt: Code Coverage
-.. image:: https://readthedocs.org/projects/anyio/badge/?version=latest
-  :target: https://anyio.readthedocs.io/en/latest/?badge=latest
-  :alt: Documentation
-.. image:: https://badges.gitter.im/gitterHQ/gitter.svg
-  :target: https://gitter.im/python-trio/AnyIO
-  :alt: Gitter chat
-.. image:: https://tidelift.com/badges/package/pypi/anyio
-  :target: https://tidelift.com/subscription/pkg/pypi-anyio
-  :alt: Tidelift
-
-AnyIO is an asynchronous networking and concurrency library that works on top of either asyncio_ or
-Trio_. It implements Trio-like `structured concurrency`_ (SC) on top of asyncio and works in harmony
-with the native SC of Trio itself.
-
-Applications and libraries written against AnyIO's API will run unmodified on either asyncio_ or
-Trio_. AnyIO can also be adopted into a library or application incrementally – bit by bit, no full
-refactoring necessary. It will blend in with the native libraries of your chosen backend.
-
-To find out why you might want to use AnyIO's APIs instead of asyncio's, you can read about it
-`here <https://anyio.readthedocs.io/en/stable/why.html>`_.
-
-Documentation
--------------
-
-View full documentation at: https://anyio.readthedocs.io/
-
-Features
---------
-
-AnyIO offers the following functionality:
-
-* Task groups (nurseries_ in trio terminology)
-* High-level networking (TCP, UDP and UNIX sockets)
-
-  * `Happy eyeballs`_ algorithm for TCP connections (more robust than that of asyncio on Python
-    3.8)
-  * async/await style UDP sockets (unlike asyncio where you still have to use Transports and
-    Protocols)
-
-* A versatile API for byte streams and object streams
-* Inter-task synchronization and communication (locks, conditions, events, semaphores, object
-  streams)
-* Worker threads
-* Subprocesses
-* Subinterpreter support for code parallelization (on Python 3.13 and later)
-* Asynchronous file I/O (using worker threads)
-* Signal handling
-* Asynchronous version of the functools_ module
-
-AnyIO also comes with its own pytest_ plugin which also supports asynchronous fixtures.
-It even works with the popular Hypothesis_ library.
-
-.. _asyncio: https://docs.python.org/3/library/asyncio.html
-.. _Trio: https://github.com/python-trio/trio
-.. _structured concurrency: https://en.wikipedia.org/wiki/Structured_concurrency
-.. _nurseries: https://trio.readthedocs.io/en/stable/reference-core.html#nurseries-and-spawning
-.. _Happy eyeballs: https://en.wikipedia.org/wiki/Happy_Eyeballs
-.. _pytest: https://docs.pytest.org/en/latest/
-.. _functools: https://docs.python.org/3/library/functools.html
-.. _Hypothesis: https://hypothesis.works/
-
-Security contact information
-----------------------------
-
-To report a security vulnerability, please use the `Tidelift security contact`_.
-Tidelift will coordinate the fix and disclosure.
-
-.. _Tidelift security contact: https://tidelift.com/security