rsloop 0.1.51__cp315-cp315-win_amd64.whl

rsloop/__init__.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from ._bootstrap import bootstrap as __bootstrap
+
+__bootstrap()
+
+from ._loop_compat import (
+    Loop,
+    __version__,
+    build_info,
+    reset_transport_stats,
+    transport_stats,
+)
+from ._run import EventLoopPolicy, install, new_event_loop, run, uninstall
+
+__all__: tuple[str, ...] = (
+    "EventLoopPolicy",
+    "Loop",
+    "__version__",
+    "build_info",
+    "install",
+    "new_event_loop",
+    "reset_transport_stats",
+    "run",
+    "transport_stats",
+    "uninstall",
+)

rsloop/__init__.pyi

@@ -0,0 +1,40 @@
+from asyncio import DefaultEventLoopPolicy
+from collections.abc import Callable, Coroutine
+from typing import Any, TypeVar
+
+from ._loop import PyLoop
+
+_T = TypeVar("_T")
+
+Loop = PyLoop
+
+__version__: str
+
+def build_info() -> dict[str, str | bool]: ...
+def transport_stats() -> dict[str, int | bool]: ...
+def reset_transport_stats() -> None: ...
+
+class EventLoopPolicy(DefaultEventLoopPolicy):
+    def new_event_loop(self) -> Loop: ...
+
+def install() -> None: ...
+def uninstall() -> None: ...
+def new_event_loop() -> Loop: ...
+def run(
+    main: Coroutine[Any, Any, _T],
+    *,
+    loop_factory: Callable[[], Loop] = ...,
+    debug: bool | None = ...,
+) -> _T: ...
+__all__: tuple[str, ...] = (
+    "EventLoopPolicy",
+    "Loop",
+    "__version__",
+    "build_info",
+    "install",
+    "new_event_loop",
+    "reset_transport_stats",
+    "run",
+    "transport_stats",
+    "uninstall",
+)

rsloop/_bootstrap.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import os as __os
+import ssl as __ssl
+import sys as __sys
+import typing as __typing
+
+__DLL_DIR_HANDLES: list[object] = []
+
+
+def configure_windows_dll_search_path() -> None:
+    if __sys.platform != "win32" or not hasattr(__os, "add_dll_directory"):
+        return
+
+    import shutil as __shutil
+
+    candidate_dirs: list[str] = []
+    gcc = __shutil.which("gcc")
+    if gcc is not None:
+        candidate_dirs.append(__os.path.dirname(gcc))
+
+    msys_prefix = __os.environ.get("MSYSTEM_PREFIX")
+    if msys_prefix:
+        candidate_dirs.append(__os.path.join(msys_prefix, "bin"))
+
+    candidate_dirs.extend(
+        [
+            r"C:\msys64\ucrt64\bin",
+            r"C:\msys64\mingw64\bin",
+            r"C:\msys64\clang64\bin",
+        ]
+    )
+
+    seen: set[str] = set()
+    for directory in candidate_dirs:
+        normalized = __os.path.normcase(__os.path.abspath(directory))
+        if normalized in seen or not __os.path.isdir(directory):
+            continue
+        if not __os.path.exists(__os.path.join(directory, "libstdc++-6.dll")):
+            continue
+        __DLL_DIR_HANDLES.append(__os.add_dll_directory(directory))
+        seen.add(normalized)
+
+
+def install_ssl_tracking() -> None:
+    context_cls = __ssl.SSLContext
+    if getattr(context_cls, "_rsloop_tracking_installed", False):
+        return
+
+    def mark_default_verify_paths(context):
+        context.__dict__["_rsloop_use_default_verify_paths"] = True
+        return context
+
+    def mark_tls_config_changed(context):
+        state = context.__dict__
+        state["_rsloop_tls_generation"] = state.get("_rsloop_tls_generation", 0) + 1
+
+    orig_load_cert_chain = context_cls.load_cert_chain
+    orig_load_default_certs = context_cls.load_default_certs
+    orig_load_verify_locations = context_cls.load_verify_locations
+    orig_set_default_verify_paths = context_cls.set_default_verify_paths
+
+    def load_cert_chain(self, certfile, keyfile=None, password=None):
+        result = orig_load_cert_chain(
+            self,
+            certfile,
+            keyfile=keyfile,
+            password=password,
+        )
+        if callable(password):
+            password_value = password()
+        else:
+            password_value = password
+        if isinstance(password_value, str):
+            password_value = password_value.encode()
+        if password_value is not None and not isinstance(password_value, bytes):
+            password_value = bytes(__typing.cast(__typing.Any, password_value))
+        self.__dict__["_rsloop_certfile"] = __os.fspath(certfile)
+        self.__dict__["_rsloop_keyfile"] = (
+            __os.fspath(keyfile) if keyfile is not None else __os.fspath(certfile)
+        )
+        self.__dict__["_rsloop_key_password"] = password_value
+        mark_tls_config_changed(self)
+        return result
+
+    def load_default_certs(self, *args, **kwargs):
+        result = orig_load_default_certs(self, *args, **kwargs)
+        mark_default_verify_paths(self)
+        mark_tls_config_changed(self)
+        return result
+
+    def load_verify_locations(self, *args, **kwargs):
+        result = orig_load_verify_locations(self, *args, **kwargs)
+        mark_tls_config_changed(self)
+        return result
+
+    def set_default_verify_paths(self):
+        result = orig_set_default_verify_paths(self)
+        mark_default_verify_paths(self)
+        mark_tls_config_changed(self)
+        return result
+
+    context_cls.load_cert_chain = load_cert_chain
+    context_cls.load_default_certs = load_default_certs
+    context_cls.load_verify_locations = load_verify_locations
+    context_cls.set_default_verify_paths = set_default_verify_paths
+    __typing.cast(__typing.Any, context_cls)._rsloop_tracking_installed = True
+
+
+def bootstrap() -> None:
+    configure_windows_dll_search_path()
+    install_ssl_tracking()

rsloop/_loop.pyi

@@ -0,0 +1,53 @@
+from asyncio import (
+    AbstractEventLoop,
+    Future,
+    Server,
+    StreamReader,
+    StreamWriter,
+    Task,
+)
+from collections.abc import Awaitable, Callable, Coroutine, Sequence
+from contextvars import Context
+from typing import Any, TypeVar
+
+_T = TypeVar("_T")
+
+__version__: str
+
+def build_info() -> dict[str, str | bool]: ...
+def transport_stats() -> dict[str, int | bool]: ...
+def reset_transport_stats() -> None: ...
+
+class PyLoop(AbstractEventLoop):
+    slow_callback_duration: float
+    def __init__(self) -> None: ...
+    def create_future(self) -> Future[Any]: ...
+    def create_task(
+        self,
+        coro: Coroutine[Any, Any, _T],
+        *,
+        name: object | None = None,
+        context: Context | None = None,
+        eager_start: bool | None = None,
+        **kwargs: Any,
+    ) -> Task[_T]: ...
+    def set_slow_callback_duration(self, value: float) -> None: ...
+
+async def start_server(
+    client_connected_cb: Callable[[StreamReader, StreamWriter], Awaitable[None]]
+    | Callable[[StreamReader, StreamWriter], None],
+    host: str | Sequence[str] | None = None,
+    port: int | str | None = None,
+    *,
+    limit: int = 65536,
+    ssl_handshake_timeout: float | None = None,
+    **kwds: Any,
+) -> Server: ...
+async def open_connection(
+    host: str | None = None,
+    port: int | str | None = None,
+    *,
+    limit: int = 65536,
+    ssl_handshake_timeout: float | None = None,
+    **kwds: Any,
+) -> tuple[StreamReader, StreamWriter]: ...