omlish 0.0.0.dev123__py3-none-any.whl → 0.0.0.dev125__py3-none-any.whl

omlish/lite/inject.py

@@ -9,10 +9,12 @@ import weakref
 
 from .check import check_isinstance
 from .check import check_not_isinstance
+from .check import check_not_none
 from .maybes import Maybe
 from .reflect import get_optional_alias_arg
 from .reflect import is_new_type
 from .reflect import is_optional_alias
+from .typing import Func
 
 
 T = ta.TypeVar('T')
@@ -30,12 +32,28 @@ InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
 
 
 @dc.dataclass(frozen=True)
-class InjectorKey:
-    cls: InjectorKeyCls
+class InjectorKey(ta.Generic[T]):
+    # Before PEP-560 typing.Generic was a metaclass with a __new__ that takes a 'cls' arg, so instantiating a dataclass
+    # with kwargs (such as through dc.replace) causes `TypeError: __new__() got multiple values for argument 'cls'`.
+    # See:
+    #  - https://github.com/python/cpython/commit/d911e40e788fb679723d78b6ea11cabf46caed5a
+    #  - https://gist.github.com/wrmsr/4468b86efe9f373b6b114bfe85b98fd3
+    cls_: InjectorKeyCls
+
     tag: ta.Any = None
     array: bool = False
 
 
+def is_valid_injector_key_cls(cls: ta.Any) -> bool:
+    return isinstance(cls, type) or is_new_type(cls)
+
+
+def check_valid_injector_key_cls(cls: T) -> T:
+    if not is_valid_injector_key_cls(cls):
+        raise TypeError(cls)
+    return cls
+
+
 ##
 
 
@@ -79,6 +97,12 @@ class Injector(abc.ABC):
     def inject(self, obj: ta.Any) -> ta.Any:
         raise NotImplementedError
 
+    def __getitem__(
+            self,
+            target: ta.Union[InjectorKey[T], ta.Type[T]],
+    ) -> T:
+        return self.provide(target)
+
 
 ###
 # exceptions
@@ -111,7 +135,7 @@ def as_injector_key(o: ta.Any) -> InjectorKey:
         raise TypeError(o)
     if isinstance(o, InjectorKey):
         return o
-    if isinstance(o, type) or is_new_type(o):
+    if is_valid_injector_key_cls(o):
         return InjectorKey(o)
     raise TypeError(o)
 
@@ -136,14 +160,14 @@ class FnInjectorProvider(InjectorProvider):
 
 @dc.dataclass(frozen=True)
 class CtorInjectorProvider(InjectorProvider):
-    cls: type
+    cls_: type
 
     def __post_init__(self) -> None:
-        check_isinstance(self.cls, type)
+        check_isinstance(self.cls_, type)
 
     def provider_fn(self) -> InjectorProviderFn:
         def pfn(i: Injector) -> ta.Any:
-            return i.inject(self.cls)
+            return i.inject(self.cls_)
 
         return pfn
 
@@ -292,19 +316,42 @@ def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey,
 # inspection
 
 
-_INJECTION_SIGNATURE_CACHE: ta.MutableMapping[ta.Any, inspect.Signature] = weakref.WeakKeyDictionary()
+# inspect.signature(eval_str=True) was added in 3.10 and we have to support 3.8, so we have to get_type_hints to eval
+# str annotations *in addition to* getting the signature for parameter information.
+class _InjectionInspection(ta.NamedTuple):
+    signature: inspect.Signature
+    type_hints: ta.Mapping[str, ta.Any]
+
+
+_INJECTION_INSPECTION_CACHE: ta.MutableMapping[ta.Any, _InjectionInspection] = weakref.WeakKeyDictionary()
+
 
+def _do_injection_inspect(obj: ta.Any) -> _InjectionInspection:
+    uw = obj
+    while True:
+        if isinstance(uw, functools.partial):
+            uw = uw.func
+        else:
+            if (uw2 := inspect.unwrap(uw)) is uw:
+                break
+            uw = uw2
+
+    return _InjectionInspection(
+        inspect.signature(obj),
+        ta.get_type_hints(uw),
+    )
 
-def _injection_signature(obj: ta.Any) -> inspect.Signature:
+
+def _injection_inspect(obj: ta.Any) -> _InjectionInspection:
     try:
-        return _INJECTION_SIGNATURE_CACHE[obj]
+        return _INJECTION_INSPECTION_CACHE[obj]
     except TypeError:
-        return inspect.signature(obj)
+        return _do_injection_inspect(obj)
     except KeyError:
         pass
-    sig = inspect.signature(obj)
-    _INJECTION_SIGNATURE_CACHE[obj] = sig
-    return sig
+    insp = _do_injection_inspect(obj)
+    _INJECTION_INSPECTION_CACHE[obj] = insp
+    return insp
 
 
 class InjectionKwarg(ta.NamedTuple):
@@ -325,20 +372,20 @@ def build_injection_kwargs_target(
         skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
         raw_optional: bool = False,
 ) -> InjectionKwargsTarget:
-    sig = _injection_signature(obj)
+    insp = _injection_inspect(obj)
 
     seen: ta.Set[InjectorKey] = set(map(as_injector_key, skip_kwargs)) if skip_kwargs is not None else set()
     kws: ta.List[InjectionKwarg] = []
-    for p in list(sig.parameters.values())[skip_args:]:
+    for p in list(insp.signature.parameters.values())[skip_args:]:
         if p.annotation is inspect.Signature.empty:
             if p.default is not inspect.Parameter.empty:
                 raise KeyError(f'{obj}, {p.name}')
             continue
 
         if p.kind not in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY):
-            raise TypeError(sig)
+            raise TypeError(insp)
 
-        ann = p.annotation
+        ann = insp.type_hints.get(p.name, p.annotation)
         if (
                 not raw_optional and
                 is_optional_alias(ann)
@@ -363,6 +410,66 @@ def build_injection_kwargs_target(
     )
 
 
+###
+# injector
+
+
+_INJECTOR_INJECTOR_KEY: InjectorKey[Injector] = InjectorKey(Injector)
+
+
+class _Injector(Injector):
+    def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
+        super().__init__()
+
+        self._bs = check_isinstance(bs, InjectorBindings)
+        self._p: ta.Optional[Injector] = check_isinstance(p, (Injector, type(None)))
+
+        self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
+
+        if _INJECTOR_INJECTOR_KEY in self._pfm:
+            raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
+
+    def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
+        key = as_injector_key(key)
+
+        if key == _INJECTOR_INJECTOR_KEY:
+            return Maybe.just(self)
+
+        fn = self._pfm.get(key)
+        if fn is not None:
+            return Maybe.just(fn(self))
+
+        if self._p is not None:
+            pv = self._p.try_provide(key)
+            if pv is not None:
+                return Maybe.empty()
+
+        return Maybe.empty()
+
+    def provide(self, key: ta.Any) -> ta.Any:
+        v = self.try_provide(key)
+        if v.present:
+            return v.must()
+        raise UnboundInjectorKeyError(key)
+
+    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
+        kt = build_injection_kwargs_target(obj)
+        ret: ta.Dict[str, ta.Any] = {}
+        for kw in kt.kwargs:
+            if kw.has_default:
+                if not (mv := self.try_provide(kw.key)).present:
+                    continue
+                v = mv.must()
+            else:
+                v = self.provide(kw.key)
+            ret[kw.name] = v
+        return ret
+
+    def inject(self, obj: ta.Any) -> ta.Any:
+        kws = self.provide_kwargs(obj)
+        return obj(**kws)
+
+
 ###
 # binder
 
@@ -412,7 +519,7 @@ class InjectorBinder:
             to_key: ta.Any = None,
 
             singleton: bool = False,
-    ) -> InjectorBinding:
+    ) -> InjectorBindingOrBindings:
         if obj is None or obj is inspect.Parameter.empty:
             raise TypeError(obj)
         if isinstance(obj, cls._BANNED_BIND_TYPES):
@@ -442,9 +549,9 @@ class InjectorBinder:
         elif cls._is_fn(obj) and not has_to:
             to_fn = obj
             if key is None:
-                sig = _injection_signature(obj)
-                ty = check_isinstance(sig.return_annotation, type)
-                key = InjectorKey(ty)
+                insp = _injection_inspect(obj)
+                key_cls: ta.Any = check_valid_injector_key_cls(check_not_none(insp.type_hints.get('return')))
+                key = InjectorKey(key_cls)
         else:
             if to_const is not None:
                 raise TypeError('Cannot bind instance with to_const')
@@ -495,67 +602,21 @@ class InjectorBinder:
 
 
 ###
-# injector
-
-
-_INJECTOR_INJECTOR_KEY = InjectorKey(Injector)
-
-
-class _Injector(Injector):
-    def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
-        super().__init__()
-
-        self._bs = check_isinstance(bs, InjectorBindings)
-        self._p: ta.Optional[Injector] = check_isinstance(p, (Injector, type(None)))
-
-        self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
-
-        if _INJECTOR_INJECTOR_KEY in self._pfm:
-            raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
-
-    def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
-        key = as_injector_key(key)
-
-        if key == _INJECTOR_INJECTOR_KEY:
-            return Maybe.just(self)
-
-        fn = self._pfm.get(key)
-        if fn is not None:
-            return Maybe.just(fn(self))
-
-        if self._p is not None:
-            pv = self._p.try_provide(key)
-            if pv is not None:
-                return Maybe.empty()
-
-        return Maybe.empty()
+# injection helpers
 
-    def provide(self, key: ta.Any) -> ta.Any:
-        v = self.try_provide(key)
-        if v.present:
-            return v.must()
-        raise UnboundInjectorKeyError(key)
 
-    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
-        kt = build_injection_kwargs_target(obj)
-        ret: ta.Dict[str, ta.Any] = {}
-        for kw in kt.kwargs:
-            if kw.has_default:
-                if not (mv := self.try_provide(kw.key)).present:
-                    continue
-                v = mv.must()
-            else:
-                v = self.provide(kw.key)
-            ret[kw.name] = v
-        return ret
+def make_injector_factory(
+        factory_cls: ta.Any,
+        factory_fn: ta.Callable[..., T],
+) -> ta.Callable[..., Func[T]]:
+    def outer(injector: Injector) -> factory_cls:
+        def inner(*args, **kwargs):
+            return injector.inject(functools.partial(factory_fn, *args, **kwargs))
+        return Func(inner)
+    return outer
 
-    def inject(self, obj: ta.Any) -> ta.Any:
-        kws = self.provide_kwargs(obj)
-        return obj(**kws)
 
-
-###
-# injection helpers
+##
 
 
 class Injection:
@@ -586,6 +647,12 @@ class Injection:
     def override(cls, p: InjectorBindings, *args: InjectorBindingOrBindings) -> InjectorBindings:
         return injector_override(p, *args)
 
+    # injector
+
+    @classmethod
+    def create_injector(cls, *args: InjectorBindingOrBindings, p: ta.Optional[Injector] = None) -> Injector:
+        return _Injector(as_injector_bindings(*args), p)
+
     # binder
 
     @classmethod
@@ -603,7 +670,7 @@ class Injection:
             to_key: ta.Any = None,
 
             singleton: bool = False,
-    ) -> InjectorBinding:
+    ) -> InjectorBindingOrBindings:
         return InjectorBinder.bind(
             obj,
 
@@ -619,11 +686,15 @@ class Injection:
             singleton=singleton,
         )
 
-    # injector
+    # helpers
 
     @classmethod
-    def create_injector(cls, *args: InjectorBindingOrBindings, p: ta.Optional[Injector] = None) -> Injector:
-        return _Injector(as_injector_bindings(*args), p)
+    def bind_factory(
+            cls,
+            factory_cls: ta.Any,
+            factory_fn: ta.Callable[..., T],
+    ) -> InjectorBindingOrBindings:
+        return cls.bind(make_injector_factory(factory_cls, factory_fn))
 
 
 inj = Injection

omlish/lite/journald.py

@@ -29,7 +29,6 @@ sd_iovec._fields_ = [
 def sd_libsystemd() -> ta.Any:
     lib = ct.CDLL('libsystemd.so.0')
 
-    lib.sd_journal_sendv = lib['sd_journal_sendv']  # type: ignore
     lib.sd_journal_sendv.restype = ct.c_int
     lib.sd_journal_sendv.argtypes = [ct.POINTER(sd_iovec), ct.c_int]
 

omlish/lite/runtime.py

@@ -14,5 +14,4 @@ REQUIRED_PYTHON_VERSION = (3, 8)
 
 def check_runtime_version() -> None:
     if sys.version_info < REQUIRED_PYTHON_VERSION:
-        raise OSError(
-            f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
+        raise OSError(f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa

omlish/lite/socket.py

@@ -0,0 +1,77 @@
+# ruff: noqa: UP006 UP007
+"""
+TODO:
+ - SocketClientAddress family / tuple pairs
+  + codification of https://docs.python.org/3/library/socket.html#socket-families
+"""
+import abc
+import dataclasses as dc
+import socket
+import typing as ta
+
+
+SocketAddress = ta.Any
+
+
+SocketHandlerFactory = ta.Callable[[SocketAddress, ta.BinaryIO, ta.BinaryIO], 'SocketHandler']
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SocketAddressInfoArgs:
+    host: ta.Optional[str]
+    port: ta.Union[str, int, None]
+    family: socket.AddressFamily = socket.AddressFamily.AF_UNSPEC
+    type: int = 0
+    proto: int = 0
+    flags: socket.AddressInfo = socket.AddressInfo(0)
+
+
+@dc.dataclass(frozen=True)
+class SocketAddressInfo:
+    family: socket.AddressFamily
+    type: int
+    proto: int
+    canonname: ta.Optional[str]
+    sockaddr: SocketAddress
+
+
+def get_best_socket_family(
+        host: ta.Optional[str],
+        port: ta.Union[str, int, None],
+        family: ta.Union[int, socket.AddressFamily] = socket.AddressFamily.AF_UNSPEC,
+) -> ta.Tuple[socket.AddressFamily, SocketAddress]:
+    """https://github.com/python/cpython/commit/f289084c83190cc72db4a70c58f007ec62e75247"""
+
+    infos = socket.getaddrinfo(
+        host,
+        port,
+        family,
+        type=socket.SOCK_STREAM,
+        flags=socket.AI_PASSIVE,
+    )
+    ai = SocketAddressInfo(*next(iter(infos)))
+    return ai.family, ai.sockaddr
+
+
+##
+
+
+class SocketHandler(abc.ABC):
+    def __init__(
+            self,
+            client_address: SocketAddress,
+            rfile: ta.BinaryIO,
+            wfile: ta.BinaryIO,
+    ) -> None:
+        super().__init__()
+
+        self._client_address = client_address
+        self._rfile = rfile
+        self._wfile = wfile
+
+    @abc.abstractmethod
+    def handle(self) -> None:
+        raise NotImplementedError

omlish/lite/socketserver.py

@@ -0,0 +1,66 @@
+# ruff: noqa: UP006 UP007
+import socket
+import socketserver
+import typing as ta
+
+from omlish.lite.check import check_not_none
+
+from .socket import SocketAddress
+from .socket import SocketHandlerFactory
+
+
+##
+
+
+class SocketServerBaseRequestHandler_:  # noqa
+    request: socket.socket
+    client_address: SocketAddress
+    server: socketserver.TCPServer
+
+
+class SocketServerStreamRequestHandler_(SocketServerBaseRequestHandler_):  # noqa
+    rbufsize: int
+    wbufsize: int
+
+    timeout: ta.Optional[float]
+
+    disable_nagle_algorithm: bool
+
+    connection: socket.socket
+    rfile: ta.BinaryIO
+    wfile: ta.BinaryIO
+
+
+##
+
+
+class SocketHandlerSocketServerStreamRequestHandler(  # type: ignore[misc]
+    socketserver.StreamRequestHandler,
+    SocketServerStreamRequestHandler_,
+):
+    socket_handler_factory: ta.Optional[SocketHandlerFactory] = None
+
+    def __init__(
+            self,
+            request: socket.socket,
+            client_address: SocketAddress,
+            server: socketserver.TCPServer,
+            *,
+            socket_handler_factory: ta.Optional[SocketHandlerFactory] = None,
+    ) -> None:
+        if socket_handler_factory is not None:
+            self.socket_handler_factory = socket_handler_factory
+
+        super().__init__(
+            request,
+            client_address,
+            server,
+        )
+
+    def handle(self) -> None:
+        target = check_not_none(self.socket_handler_factory)(
+            self.client_address,
+            self.rfile,  # type: ignore[arg-type]
+            self.wfile,  # type: ignore[arg-type]
+        )
+        target.handle()

omlish/lite/typing.py

@@ -0,0 +1,13 @@
+import dataclasses as dc
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+@dc.dataclass(frozen=True)
+class Func(ta.Generic[T]):
+    fn: ta.Callable[..., T]
+
+    def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self.fn(*args, **kwargs)

omlish-0.0.0.dev125.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.1
+Name: omlish
+Version: 0.0.0.dev125
+Summary: omlish
+Author: wrmsr
+License: BSD-3-Clause
+Project-URL: source, https://github.com/wrmsr/omlish
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Requires-Python: >=3.12
+License-File: LICENSE
+Provides-Extra: all
+Requires-Dist: anyio~=4.6; extra == "all"
+Requires-Dist: sniffio~=1.3; extra == "all"
+Requires-Dist: greenlet~=3.1; extra == "all"
+Requires-Dist: trio~=0.27; extra == "all"
+Requires-Dist: trio-asyncio~=0.15; extra == "all"
+Requires-Dist: lz4~=4.3; extra == "all"
+Requires-Dist: python-snappy~=0.7; extra == "all"
+Requires-Dist: zstandard~=0.23; extra == "all"
+Requires-Dist: asttokens~=2.4; extra == "all"
+Requires-Dist: executing~=2.1; extra == "all"
+Requires-Dist: psutil~=6.0; extra == "all"
+Requires-Dist: orjson~=3.10; extra == "all"
+Requires-Dist: ujson~=5.10; extra == "all"
+Requires-Dist: json5~=0.9; extra == "all"
+Requires-Dist: pyyaml~=6.0; extra == "all"
+Requires-Dist: cbor2~=5.6; extra == "all"
+Requires-Dist: cloudpickle~=3.1; extra == "all"
+Requires-Dist: httpx[http2]~=0.27; extra == "all"
+Requires-Dist: wrapt~=1.14; extra == "all"
+Requires-Dist: cryptography~=43.0; extra == "all"
+Requires-Dist: sqlalchemy[asyncio]~=2.0; extra == "all"
+Requires-Dist: pg8000~=1.31; extra == "all"
+Requires-Dist: pymysql~=1.1; extra == "all"
+Requires-Dist: aiomysql~=0.2; extra == "all"
+Requires-Dist: aiosqlite~=0.20; extra == "all"
+Requires-Dist: asyncpg~=0.30; extra == "all"
+Requires-Dist: apsw~=3.46; extra == "all"
+Requires-Dist: sqlean.py~=3.45; extra == "all"
+Requires-Dist: duckdb~=1.1; extra == "all"
+Requires-Dist: pytest~=8.0; extra == "all"
+Requires-Dist: anyio~=4.6; extra == "all"
+Requires-Dist: sniffio~=1.3; extra == "all"
+Requires-Dist: asttokens~=2.4; extra == "all"
+Requires-Dist: executing~=2.1; extra == "all"
+Requires-Dist: orjson~=3.10; extra == "all"
+Requires-Dist: pyyaml~=6.0; extra == "all"
+Requires-Dist: wrapt~=1.14; extra == "all"
+Provides-Extra: async
+Requires-Dist: anyio~=4.6; extra == "async"
+Requires-Dist: sniffio~=1.3; extra == "async"
+Requires-Dist: greenlet~=3.1; extra == "async"
+Requires-Dist: trio~=0.27; extra == "async"
+Requires-Dist: trio-asyncio~=0.15; extra == "async"
+Provides-Extra: compress
+Requires-Dist: lz4~=4.3; extra == "compress"
+Requires-Dist: python-snappy~=0.7; extra == "compress"
+Requires-Dist: zstandard~=0.23; extra == "compress"
+Provides-Extra: diag
+Requires-Dist: asttokens~=2.4; extra == "diag"
+Requires-Dist: executing~=2.1; extra == "diag"
+Requires-Dist: psutil~=6.0; extra == "diag"
+Provides-Extra: formats
+Requires-Dist: orjson~=3.10; extra == "formats"
+Requires-Dist: ujson~=5.10; extra == "formats"
+Requires-Dist: json5~=0.9; extra == "formats"
+Requires-Dist: pyyaml~=6.0; extra == "formats"
+Requires-Dist: cbor2~=5.6; extra == "formats"
+Requires-Dist: cloudpickle~=3.1; extra == "formats"
+Provides-Extra: http
+Requires-Dist: httpx[http2]~=0.27; extra == "http"
+Provides-Extra: misc
+Requires-Dist: wrapt~=1.14; extra == "misc"
+Provides-Extra: secrets
+Requires-Dist: cryptography~=43.0; extra == "secrets"
+Provides-Extra: sqlalchemy
+Requires-Dist: sqlalchemy[asyncio]~=2.0; extra == "sqlalchemy"
+Provides-Extra: sqldrivers
+Requires-Dist: pg8000~=1.31; extra == "sqldrivers"
+Requires-Dist: pymysql~=1.1; extra == "sqldrivers"
+Requires-Dist: aiomysql~=0.2; extra == "sqldrivers"
+Requires-Dist: aiosqlite~=0.20; extra == "sqldrivers"
+Requires-Dist: asyncpg~=0.30; extra == "sqldrivers"
+Requires-Dist: apsw~=3.46; extra == "sqldrivers"
+Requires-Dist: sqlean.py~=3.45; extra == "sqldrivers"
+Requires-Dist: duckdb~=1.1; extra == "sqldrivers"
+Provides-Extra: testing
+Requires-Dist: pytest~=8.0; extra == "testing"
+Provides-Extra: plus
+Requires-Dist: anyio~=4.6; extra == "plus"
+Requires-Dist: sniffio~=1.3; extra == "plus"
+Requires-Dist: asttokens~=2.4; extra == "plus"
+Requires-Dist: executing~=2.1; extra == "plus"
+Requires-Dist: orjson~=3.10; extra == "plus"
+Requires-Dist: pyyaml~=6.0; extra == "plus"
+Requires-Dist: wrapt~=1.14; extra == "plus"