omlish 0.0.0.dev126__tar.gz → 0.0.0.dev128__tar.gz

{omlish-0.0.0.dev126/omlish.egg-info → omlish-0.0.0.dev128}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev126
+Version: 0.0.0.dev128
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev126'
-__revision__ = '631da43a3ae4f71529271e291fc643834c85c462'
+__version__ = '0.0.0.dev128'
+__revision__ = '032185683e360475ef780c77bea913c965cebcc6'
 
 
 #

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/omlish/collections/__init__.py

@@ -13,7 +13,7 @@ from .coerce import (  # noqa
     frozenset_of,
     frozenset_of_or_none,
     frozenset_or_none,
-    map,
+    map,  # noqa
     map_of,
     map_of_or_none,
     map_or_none,

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/omlish/formats/props.py

@@ -548,7 +548,7 @@ class Properties(collections.abc.MutableMapping):
             month = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
             now = time.gmtime()
             print(
-                '#%s %s %02d %02d:%02d:%02d UTC %04d' % (
+                '#%s %s %02d %02d:%02d:%02d UTC %04d' % (  # noqa
                     day_of_week[now.tm_wday],
                     month[now.tm_mon - 1],
                     now.tm_mday,

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/omlish/http/consts.py

@@ -11,7 +11,7 @@ import http
 
 
 def format_status(status: http.HTTPStatus) -> str:
-    return '%d %s' % (int(status), status.phrase)
+    return f'{int(status)} {status.phrase}'
 
 
 STATUS_OK = format_status(http.HTTPStatus.OK)

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/omlish/inject/impl/inspect.py

@@ -10,12 +10,12 @@ import inspect
 import typing as ta
 import weakref
 
+from ... import check
 from ... import reflect as rfl
 from ..exceptions import ConflictingKeyError
 from ..inspect import Kwarg
 from ..inspect import KwargsTarget
 from ..keys import Key
-from ..keys import as_key
 from ..types import Tag
 
 
@@ -72,15 +72,22 @@ def build_kwargs_target(
         obj: ta.Any,
         *,
         skip_args: int = 0,
-        skip_kwargs: ta.Iterable[ta.Any] | None = None,
+        skip_kwargs: ta.Iterable[str] | None = None,
         raw_optional: bool = False,
 ) -> KwargsTarget:
     sig = signature(obj)
     tags = _TAGS.get(obj)
 
-    seen: set[Key] = set(map(as_key, skip_kwargs)) if skip_kwargs is not None else set()
+    skip_names: set[str] = set()
+    if skip_kwargs is not None:
+        skip_names.update(check.not_isinstance(skip_kwargs, str))
+
+    seen: set[Key] = set()
     kws: list[Kwarg] = []
     for p in list(sig.parameters.values())[skip_args:]:
+        if p.name in skip_names:
+            continue
+
         if p.annotation is inspect.Signature.empty:
             if p.default is not inspect.Parameter.empty:
                 raise KeyError(f'{obj}, {p.name}')

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/omlish/lang/__init__.py

@@ -1,5 +1,3 @@
-# This module should import nothing but stdlib modules, and as few as possible. That *includes* lite - no using lite.
-
 from .cached import (  # noqa
     cached_function,
     cached_property,
@@ -219,14 +217,19 @@ from .timeouts import (  # noqa
 )
 
 from .typing import (  # noqa
-    AnyFunc,
     BytesLike,
-    Func0,
-    Func1,
-    Func2,
-    Func3,
     SequenceNotStr,
     protocol_check,
     typed_lambda,
     typed_partial,
 )
+
+##
+
+from ..lite.typing import (  # noqa
+    AnyFunc,
+    Func0,
+    Func1,
+    Func2,
+    Func3,
+)

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/omlish/lang/typing.py

@@ -5,7 +5,6 @@ TODO:
   - probably need to gen types per inst
  - typed_factory
 """
-import dataclasses as dc
 import functools
 import inspect
 import typing as ta
@@ -17,11 +16,6 @@ T = ta.TypeVar('T')
 T_co = ta.TypeVar('T_co', covariant=True)
 T_contra = ta.TypeVar('T_contra', contravariant=True)
 
-A0 = ta.TypeVar('A0')
-A1 = ta.TypeVar('A1')
-A2 = ta.TypeVar('A2')
-
-
 BytesLike: ta.TypeAlias = bytes | bytearray
 
 
@@ -102,50 +96,6 @@ def typed_partial(obj, **kw):  # noqa
     return _update_wrapper_no_anns(lam, obj)
 
 
-##
-# A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
-
-
-@dc.dataclass(frozen=True)
-class AnyFunc(ta.Generic[T]):
-    fn: ta.Callable[..., T]
-
-    def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
-        return self.fn(*args, **kwargs)
-
-
-@dc.dataclass(frozen=True)
-class Func0(ta.Generic[T]):
-    fn: ta.Callable[[], T]
-
-    def __call__(self) -> T:
-        return self.fn()
-
-
-@dc.dataclass(frozen=True)
-class Func1(ta.Generic[A0, T]):
-    fn: ta.Callable[[A0], T]
-
-    def __call__(self, a0: A0) -> T:
-        return self.fn(a0)
-
-
-@dc.dataclass(frozen=True)
-class Func2(ta.Generic[A0, A1, T]):
-    fn: ta.Callable[[A0, A1], T]
-
-    def __call__(self, a0: A0, a1: A1) -> T:
-        return self.fn(a0, a1)
-
-
-@dc.dataclass(frozen=True)
-class Func3(ta.Generic[A0, A1, A2, T]):
-    fn: ta.Callable[[A0, A1, A2], T]
-
-    def __call__(self, a0: A0, a1: A1, a2: A2) -> T:
-        return self.fn(a0, a1, a2)
-
-
 ##
 
 

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/omlish/lite/http/parsing.py

@@ -1,4 +1,39 @@
 # ruff: noqa: UP006 UP007
+# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+# --------------------------------------------
+#
+# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
+# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
+# documentation.
+#
+# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
+# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
+# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
+# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+# 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights Reserved" are retained in Python
+# alone or in any derivative version prepared by Licensee.
+#
+# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
+# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
+# any such work a brief summary of the changes made to Python.
+#
+# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
+# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
+# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
+# RIGHTS.
+#
+# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
+# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
+# ADVISED OF THE POSSIBILITY THEREOF.
+#
+# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
+#
+# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
+# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
+# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
+#
+# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
+# License Agreement.
 import abc
 import http.client
 import http.server

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/omlish/lite/inject.py

@@ -14,10 +14,10 @@ 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')
+U = ta.TypeVar('U')
 
 InjectorKeyCls = ta.Union[type, ta.NewType]
 
@@ -90,11 +90,23 @@ class Injector(abc.ABC):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
+    def provide_kwargs(
+            self,
+            obj: ta.Any,
+            *,
+            skip_args: int = 0,
+            skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
+    ) -> ta.Mapping[str, ta.Any]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def inject(self, obj: ta.Any) -> ta.Any:
+    def inject(
+            self,
+            obj: ta.Any,
+            *,
+            args: ta.Optional[ta.Sequence[ta.Any]] = None,
+            kwargs: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+    ) -> ta.Any:
         raise NotImplementedError
 
     def __getitem__(
@@ -108,8 +120,12 @@ class Injector(abc.ABC):
 # exceptions
 
 
+class InjectorError(Exception):
+    pass
+
+
 @dc.dataclass(frozen=True)
-class InjectorKeyError(Exception):
+class InjectorKeyError(InjectorError):
     key: InjectorKey
 
     source: ta.Any = None
@@ -316,29 +332,49 @@ def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey,
 # inspection
 
 
-# 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]
+    args_offset: int
 
 
 _INJECTION_INSPECTION_CACHE: ta.MutableMapping[ta.Any, _InjectionInspection] = weakref.WeakKeyDictionary()
 
 
 def _do_injection_inspect(obj: ta.Any) -> _InjectionInspection:
-    uw = obj
+    tgt = obj
+    if isinstance(tgt, type) and tgt.__init__ is not object.__init__:  # type: ignore[misc]
+        # Python 3.8's inspect.signature can't handle subclasses overriding __new__, always generating *args/**kwargs.
+        #  - https://bugs.python.org/issue40897
+        #  - https://github.com/python/cpython/commit/df7c62980d15acd3125dfbd81546dad359f7add7
+        tgt = tgt.__init__  # type: ignore[misc]
+        has_generic_base = True
+    else:
+        has_generic_base = False
+
+    # 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.
+    uw = tgt
+    has_partial = False
     while True:
         if isinstance(uw, functools.partial):
+            has_partial = True
             uw = uw.func
         else:
             if (uw2 := inspect.unwrap(uw)) is uw:
                 break
             uw = uw2
 
+    if has_generic_base and has_partial:
+        raise InjectorError(
+            'Injector inspection does not currently support both a typing.Generic base and a functools.partial: '
+            f'{obj}',
+        )
+
     return _InjectionInspection(
-        inspect.signature(obj),
+        inspect.signature(tgt),
         ta.get_type_hints(uw),
+        1 if has_generic_base else 0,
     )
 
 
@@ -369,14 +405,23 @@ def build_injection_kwargs_target(
         obj: ta.Any,
         *,
         skip_args: int = 0,
-        skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
+        skip_kwargs: ta.Optional[ta.Iterable[str]] = None,
         raw_optional: bool = False,
 ) -> InjectionKwargsTarget:
     insp = _injection_inspect(obj)
 
-    seen: ta.Set[InjectorKey] = set(map(as_injector_key, skip_kwargs)) if skip_kwargs is not None else set()
+    params = list(insp.signature.parameters.values())
+
+    skip_names: ta.Set[str] = set()
+    if skip_kwargs is not None:
+        skip_names.update(check_not_isinstance(skip_kwargs, str))
+
+    seen: ta.Set[InjectorKey] = set()
     kws: ta.List[InjectionKwarg] = []
-    for p in list(insp.signature.parameters.values())[skip_args:]:
+    for p in params[insp.args_offset + skip_args:]:
+        if p.name in skip_names:
+            continue
+
         if p.annotation is inspect.Signature.empty:
             if p.default is not inspect.Parameter.empty:
                 raise KeyError(f'{obj}, {p.name}')
@@ -385,6 +430,7 @@ def build_injection_kwargs_target(
         if p.kind not in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY):
             raise TypeError(insp)
 
+        # 3.8 inspect.signature doesn't eval_str but typing.get_type_hints does, so prefer that.
         ann = insp.type_hints.get(p.name, p.annotation)
         if (
                 not raw_optional and
@@ -452,8 +498,19 @@ class _Injector(Injector):
             return v.must()
         raise UnboundInjectorKeyError(key)
 
-    def provide_kwargs(self, obj: ta.Any) -> ta.Mapping[str, ta.Any]:
-        kt = build_injection_kwargs_target(obj)
+    def provide_kwargs(
+            self,
+            obj: ta.Any,
+            *,
+            skip_args: int = 0,
+            skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
+    ) -> ta.Mapping[str, ta.Any]:
+        kt = build_injection_kwargs_target(
+            obj,
+            skip_args=skip_args,
+            skip_kwargs=skip_kwargs,
+        )
+
         ret: ta.Dict[str, ta.Any] = {}
         for kw in kt.kwargs:
             if kw.has_default:
@@ -465,9 +522,24 @@ class _Injector(Injector):
             ret[kw.name] = v
         return ret
 
-    def inject(self, obj: ta.Any) -> ta.Any:
-        kws = self.provide_kwargs(obj)
-        return obj(**kws)
+    def inject(
+            self,
+            obj: ta.Any,
+            *,
+            args: ta.Optional[ta.Sequence[ta.Any]] = None,
+            kwargs: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+    ) -> ta.Any:
+        provided = self.provide_kwargs(
+            obj,
+            skip_args=len(args) if args is not None else 0,
+            skip_kwargs=kwargs if kwargs is not None else None,
+        )
+
+        return obj(
+            *(args if args is not None else ()),
+            **(kwargs if kwargs is not None else {}),
+            **provided,
+        )
 
 
 ###
@@ -606,16 +678,42 @@ class InjectorBinder:
 
 
 def make_injector_factory(
-        factory_cls: ta.Any,
-        factory_fn: ta.Callable[..., T],
-) -> ta.Callable[..., Func[T]]:
-    def outer(injector: Injector) -> factory_cls:
+        fn: ta.Callable[..., T],
+        cls: U,
+        ann: ta.Any = None,
+) -> ta.Callable[..., U]:
+    if ann is None:
+        ann = cls
+
+    def outer(injector: Injector) -> ann:
         def inner(*args, **kwargs):
-            return injector.inject(functools.partial(factory_fn, *args, **kwargs))
-        return Func(inner)
+            return injector.inject(fn, args=args, kwargs=kwargs)
+        return cls(inner)  # type: ignore
+
     return outer
 
 
+def make_injector_array_type(
+        ele: ta.Union[InjectorKey, InjectorKeyCls],
+        cls: U,
+        ann: ta.Any = None,
+) -> ta.Callable[..., U]:
+    if isinstance(ele, InjectorKey):
+        if not ele.array:
+            raise InjectorError('Provided key must be array', ele)
+        key = ele
+    else:
+        key = dc.replace(as_injector_key(ele), array=True)
+
+    if ann is None:
+        ann = cls
+
+    def inner(injector: Injector) -> ann:
+        return cls(injector.provide(key))  # type: ignore[operator]
+
+    return inner
+
+
 ##
 
 
@@ -650,8 +748,8 @@ class Injection:
     # injector
 
     @classmethod
-    def create_injector(cls, *args: InjectorBindingOrBindings, p: ta.Optional[Injector] = None) -> Injector:
-        return _Injector(as_injector_bindings(*args), p)
+    def create_injector(cls, *args: InjectorBindingOrBindings, parent: ta.Optional[Injector] = None) -> Injector:
+        return _Injector(as_injector_bindings(*args), parent)
 
     # binder
 
@@ -691,10 +789,20 @@ class Injection:
     @classmethod
     def bind_factory(
             cls,
-            factory_cls: ta.Any,
-            factory_fn: ta.Callable[..., T],
+            fn: ta.Callable[..., T],
+            cls_: U,
+            ann: ta.Any = None,
+    ) -> InjectorBindingOrBindings:
+        return cls.bind(make_injector_factory(fn, cls_, ann))
+
+    @classmethod
+    def bind_array_type(
+            cls,
+            ele: ta.Union[InjectorKey, InjectorKeyCls],
+            cls_: U,
+            ann: ta.Any = None,
     ) -> InjectorBindingOrBindings:
-        return cls.bind(make_injector_factory(factory_cls, factory_fn))
+        return cls.bind(make_injector_array_type(ele, cls_, ann))
 
 
 inj = Injection

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/omlish/lite/logs.py

@@ -92,7 +92,7 @@ class StandardLogFormatter(logging.Formatter):
             return ct.strftime(datefmt)  # noqa
         else:
             t = ct.strftime('%Y-%m-%d %H:%M:%S')
-            return '%s.%03d' % (t, record.msecs)
+            return '%s.%03d' % (t, record.msecs)  # noqa
 
 
 ##

omlish-0.0.0.dev128/omlish/lite/typing.py

@@ -0,0 +1,53 @@
+import dataclasses as dc
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+A0 = ta.TypeVar('A0')
+A1 = ta.TypeVar('A1')
+A2 = ta.TypeVar('A2')
+
+
+##
+# A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
+
+
+@dc.dataclass(frozen=True)
+class AnyFunc(ta.Generic[T]):
+    fn: ta.Callable[..., T]
+
+    def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self.fn(*args, **kwargs)
+
+
+@dc.dataclass(frozen=True)
+class Func0(ta.Generic[T]):
+    fn: ta.Callable[[], T]
+
+    def __call__(self) -> T:
+        return self.fn()
+
+
+@dc.dataclass(frozen=True)
+class Func1(ta.Generic[A0, T]):
+    fn: ta.Callable[[A0], T]
+
+    def __call__(self, a0: A0) -> T:
+        return self.fn(a0)
+
+
+@dc.dataclass(frozen=True)
+class Func2(ta.Generic[A0, A1, T]):
+    fn: ta.Callable[[A0, A1], T]
+
+    def __call__(self, a0: A0, a1: A1) -> T:
+        return self.fn(a0, a1)
+
+
+@dc.dataclass(frozen=True)
+class Func3(ta.Generic[A0, A1, A2, T]):
+    fn: ta.Callable[[A0, A1, A2], T]
+
+    def __call__(self, a0: A0, a1: A1, a2: A2) -> T:
+        return self.fn(a0, a1, a2)

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/omlish/specs/jmespath/__init__.py

@@ -33,7 +33,7 @@ from . import lexer  # noqa
 from . import parser  # noqa
 
 from .parser import (  # noqa
-    compile,
+    compile,  # noqa
     search,
 )
 

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/omlish/specs/jmespath/cli.py

@@ -11,7 +11,7 @@ from .exceptions import JmespathTypeError
 from .exceptions import JmespathValueError
 from .exceptions import ParseError
 from .exceptions import UnknownFunctionError
-from .parser import compile
+from .parser import compile  # noqa
 from .parser import search
 from .visitor import node_type
 

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/omlish/text/asdl.py

@@ -403,7 +403,7 @@ class AsdlParser:
         * Reads in the next token
         """
 
-        if isinstance(kind, tuple) and self.cur().kind in kind or self.cur().kind == kind:
+        if (isinstance(kind, tuple) and self.cur().kind in kind) or self.cur().kind == kind:
             value = self.cur().value
             self._advance()
             return value

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev126
+Version: 0.0.0.dev128
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev126 → omlish-0.0.0.dev128}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev126'
+version = '0.0.0.dev128'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',

omlish-0.0.0.dev126/omlish/lite/typing.py

@@ -1,13 +0,0 @@
-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)