omlish 0.0.0.dev2__py3-none-any.whl → 0.0.0.dev4__py3-none-any.whl

omlish/inject/__init__.py

@@ -18,13 +18,13 @@ from .elements import (  # noqa
 )
 
 from .exceptions import (  # noqa
-    CyclicDependencyException,
-    DuplicateKeyException,
-    KeyException,
-    ScopeAlreadyOpenException,
-    ScopeException,
-    ScopeNotOpenException,
-    UnboundKeyException,
+    BaseKeyError,
+    CyclicDependencyError,
+    DuplicateKeyError,
+    ScopeAlreadyOpenError,
+    ScopeError,
+    ScopeNotOpenError,
+    UnboundKeyError,
 )
 
 from .injector import (  # noqa

omlish/inject/elements.py

@@ -27,7 +27,7 @@ class Elements(lang.Final):
 
 def as_elements(*args: Element | Elements) -> Elements:
     es: set[Element] = set()
-    cs: set['Elements'] = set()
+    cs: set[Elements] = set()
     for a in args:
         if isinstance(a, Element):
             es.add(a)

omlish/inject/exceptions.py

@@ -9,7 +9,7 @@ from .types import Scope
 
 
 @dc.dataclass()
-class KeyException(Exception):
+class BaseKeyError(Exception):
     key: Key
 
     source: ta.Any = None
@@ -17,17 +17,17 @@ class KeyException(Exception):
 
 
 @dc.dataclass()
-class UnboundKeyException(KeyException):
+class UnboundKeyError(KeyError):
     pass
 
 
 @dc.dataclass()
-class DuplicateKeyException(KeyException):
+class DuplicateKeyError(KeyError):
     pass
 
 
 @dc.dataclass()
-class CyclicDependencyException(KeyException):
+class CyclicDependencyError(KeyError):
     pass
 
 
@@ -35,15 +35,15 @@ class CyclicDependencyException(KeyException):
 
 
 @dc.dataclass()
-class ScopeException(Exception):
+class ScopeError(Exception):
     scope: Scope
 
 
 @dc.dataclass()
-class ScopeAlreadyOpenException(ScopeException):
+class ScopeAlreadyOpenError(ScopeError):
     pass
 
 
 @dc.dataclass()
-class ScopeNotOpenException(ScopeException):
+class ScopeNotOpenError(ScopeError):
     pass

omlish/inject/impl/elements.py

@@ -14,7 +14,7 @@ Element Types:
  - Overrides
  - Expose
  - Private
- - ScopeSeed
+ - ScopeBinding
 """
 import typing as ta
 
@@ -25,12 +25,13 @@ from ..bindings import Binding
 from ..eagers import Eager
 from ..elements import Element
 from ..elements import Elements
-from ..exceptions import DuplicateKeyException
+from ..exceptions import DuplicateKeyError
 from ..keys import Key
 from ..overrides import Overrides
 from ..private import Expose
 from ..private import Private
 from ..scopes import ScopeBinding
+from ..types import Scope
 from .bindings import BindingImpl
 from .providers import MultiProviderImpl
 from .providers import make_provider_impl
@@ -51,7 +52,7 @@ class ElementCollection(lang.Final):
 
         self._es = check.isinstance(es, Elements)
 
-        self._private_infos: ta.MutableMapping[Private, 'private_.PrivateInfo'] | None = None
+        self._private_infos: ta.MutableMapping[Private, private_.PrivateInfo] | None = None
 
     ##
 
@@ -98,7 +99,7 @@ class ElementCollection(lang.Final):
                     try:
                         bs = ovr[k]
                     except KeyError:
-                        bs = src[k]
+                        bs = b
                     add(k, *bs)
 
             else:
@@ -139,7 +140,7 @@ class ElementCollection(lang.Final):
                 mm.setdefault(k, []).extend(bis)
             else:
                 if len(bis) > 1:
-                    raise DuplicateKeyException(k)
+                    raise DuplicateKeyError(k)
                 [pm[k]] = bis
 
         if mm:
@@ -152,3 +153,14 @@ class ElementCollection(lang.Final):
     @lang.cached_function
     def binding_impl_map(self) -> ta.Mapping[Key, BindingImpl]:
         return self._build_binding_impl_map(self.element_multimap())
+
+    ##
+
+    @lang.cached_function
+    def eager_keys_by_scope(self) -> ta.Mapping[Scope, ta.Sequence[Key]]:
+        bim = self.binding_impl_map()
+        ret: dict[Scope, list[Key]] = {}
+        for e in self.elements_of_type(Eager):
+            bi = bim[e.key]
+            ret.setdefault(bi.scope, []).append(e.key)
+        return ret

omlish/inject/impl/injector.py

@@ -7,6 +7,8 @@ TODO:
   - config is probably shared with ElementCollection... but not 'bound', must be shared everywhere
   - InjectorRoot object?
  - ** eagers in any scope, on scope init/open
+ - injection listeners
+ - unions - raise on ambiguous - usecase: sql.AsyncEngineLike
 """
 import contextlib
 import typing as ta
@@ -14,10 +16,9 @@ import weakref
 
 from ... import check
 from ... import lang
-from ..eagers import Eager
 from ..elements import Elements
-from ..exceptions import CyclicDependencyException
-from ..exceptions import UnboundKeyException
+from ..exceptions import CyclicDependencyError
+from ..exceptions import UnboundKeyError
 from ..injector import Injector
 from ..inspect import KwargsTarget
 from ..keys import Key
@@ -52,9 +53,10 @@ class InjectorImpl(Injector, lang.Final):
         }
 
         self._bim = ec.binding_impl_map()
+        self._ekbs = ec.eager_keys_by_scope()
 
         self._cs: weakref.WeakSet[InjectorImpl] | None = None
-        self._root: InjectorImpl = p._root if p is not None else self
+        self._root: InjectorImpl = p._root if p is not None else self  # noqa
 
         self.__cur_req: InjectorImpl._Request | None = None
 
@@ -66,13 +68,13 @@ class InjectorImpl(Injector, lang.Final):
             s: make_scope_impl(s) for s in ss
         }
 
-        self._instantiate_eagers()
+        self._instantiate_eagers(Unscoped())
 
     _root: 'InjectorImpl'
 
-    def _instantiate_eagers(self) -> None:
-        for e in self._ec.elements_of_type(Eager):
-            self.provide(e.key)
+    def _instantiate_eagers(self, sc: Scope) -> None:
+        for k in self._ekbs.get(sc, ()):
+            self.provide(k)
 
     def get_scope_impl(self, sc: Scope) -> ScopeImpl:
         return self._scopes[sc]
@@ -97,7 +99,7 @@ class InjectorImpl(Injector, lang.Final):
             except KeyError:
                 pass
             if key in self._seen_keys:
-                raise CyclicDependencyException(key)
+                raise CyclicDependencyError(key)
             self._seen_keys.add(key)
             return lang.empty()
 
@@ -154,7 +156,7 @@ class InjectorImpl(Injector, lang.Final):
         v = self.try_provide(key)
         if v.present:
             return v.must()
-        raise UnboundKeyException(key)
+        raise UnboundKeyError(key)
 
     def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
         ret: dict[str, ta.Any] = {}

omlish/inject/impl/inspect.py

@@ -11,7 +11,7 @@ import typing as ta
 import weakref
 
 from ... import reflect as rfl
-from ..exceptions import DuplicateKeyException
+from ..exceptions import DuplicateKeyError
 from ..inspect import Kwarg
 from ..inspect import KwargsTarget
 from ..keys import Key
@@ -83,7 +83,7 @@ def build_kwargs_target(
             k = tag(k, pt)
 
         if k in seen:
-            raise DuplicateKeyException(k)
+            raise DuplicateKeyError(k)
         seen.add(k)
 
         kws.append(Kwarg(

omlish/inject/impl/scopes.py

@@ -9,8 +9,8 @@ from ... import lang
 from ..bindings import Binding
 from ..elements import Elements
 from ..elements import as_elements
-from ..exceptions import ScopeAlreadyOpenException
-from ..exceptions import ScopeNotOpenException
+from ..exceptions import ScopeAlreadyOpenError
+from ..exceptions import ScopeNotOpenError
 from ..injector import Injector
 from ..keys import Key
 from ..providers import Provider
@@ -134,27 +134,28 @@ class SeededScopeImpl(ScopeImpl):
 
     def must_state(self) -> 'SeededScopeImpl.State':
         if (st := self._st) is None:
-            raise ScopeNotOpenException(self._ss)
+            raise ScopeNotOpenError(self._ss)
         return st
 
     class Manager(SeededScope.Manager, lang.Final):
         def __init__(self, ss: SeededScope, i: Injector) -> None:
             super().__init__()
             self._ss = check.isinstance(ss, SeededScope)
-            ii = check.isinstance(i, injector_.InjectorImpl)
-            self._ssi = check.isinstance(ii.get_scope_impl(self._ss), SeededScopeImpl)
+            self._ii = check.isinstance(i, injector_.InjectorImpl)
+            self._ssi = check.isinstance(self._ii.get_scope_impl(self._ss), SeededScopeImpl)
 
         @contextlib.contextmanager
         def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.Generator[None, None, None]:
             try:
-                if self._ssi._st is not None:
-                    raise ScopeAlreadyOpenException(self._ss)
-                self._ssi._st = SeededScopeImpl.State(dict(seeds))
+                if self._ssi._st is not None:  # noqa
+                    raise ScopeAlreadyOpenError(self._ss)
+                self._ssi._st = SeededScopeImpl.State(dict(seeds))  # noqa
+                self._ii._instantiate_eagers(self._ss)  # noqa
                 yield
             finally:
-                if self._ssi._st is None:
-                    raise ScopeNotOpenException(self._ss)
-                self._ssi._st = None
+                if self._ssi._st is None:  # noqa
+                    raise ScopeNotOpenError(self._ss)
+                self._ssi._st = None  # noqa
 
     def auto_elements(self) -> Elements:
         return as_elements(

omlish/inject/proxy.py

@@ -22,7 +22,7 @@ def _cyclic_dependency_proxy() -> tuple[type, ta.Callable[[ta.Any, ta.Any], None
         def __init__(self, cls):
             super().__init__(_CyclicDependencyPlaceholder(cls))
             if isinstance(cls, type):
-                self._self__class__ = cls
+                self._self__class__ = cls  # noqa
 
         def __repr__(self) -> str:
             return f'_CyclicDependencyProxy({self.__wrapped__!r})'
@@ -35,14 +35,14 @@ def _cyclic_dependency_proxy() -> tuple[type, ta.Callable[[ta.Any, ta.Any], None
                     pass
             return object.__getattribute__(self, att)  # noqa
 
-    def set(prox, obj):
+    def set_obj(prox, obj):
         check.state(type(prox) is _CyclicDependencyProxy)
         check.not_isinstance(obj, _CyclicDependencyPlaceholder)
         check.isinstance(prox.__wrapped__, _CyclicDependencyPlaceholder)
         if hasattr(prox, '_self__class__'):
-            check.issubclass(type(obj), prox._self__class__)
+            check.issubclass(type(obj), prox._self__class__)  # noqa
         prox.__wrapped__ = obj
         if hasattr(prox, '_self__class__'):
-            del prox._self__class__
+            del prox._self__class__  # noqa
 
-    return (_CyclicDependencyProxy, set)  # noqa
+    return (_CyclicDependencyProxy, set_obj)  # noqa

omlish/iterators.py

@@ -22,66 +22,61 @@ class PeekIterator(ta.Iterator[T]):
 
     _item: T
 
-    def __iter__(self) -> ta.Iterator[T]:
+    def __iter__(self) -> ta.Self:
         return self
 
     @property
     def done(self) -> bool:
         try:
             self.peek()
-            return False
         except StopIteration:
             return True
+        else:
+            return False
 
     def __next__(self) -> T:
         if self._next_item is not _MISSING:
             self._item = ta.cast(T, self._next_item)
             self._next_item = _MISSING
         else:
-            try:
-                self._item = next(self._it)
-            except StopIteration:
-                raise
+            self._item = next(self._it)
         self._pos += 1
         return self._item
 
     def peek(self) -> T:
         if self._next_item is not _MISSING:
             return ta.cast(T, self._next_item)
-        try:
-            self._next_item = next(self._it)
-        except StopIteration:
-            raise
+        self._next_item = next(self._it)
         return self._next_item
 
     def next_peek(self) -> T:
         next(self)
         return self.peek()
 
-    def takewhile(self, fn):
+    def takewhile(self, fn: ta.Callable[[T], bool]) -> ta.Iterator[T]:
         while fn(self.peek()):
             yield next(self)
 
-    def skipwhile(self, fn):
+    def skipwhile(self, fn: ta.Callable[[T], bool]) -> None:
         while fn(self.peek()):
             next(self)
 
-    def takeuntil(self, fn):
+    def takeuntil(self, fn: ta.Callable[[T], bool]) -> ta.Iterator[T]:
         return self.takewhile(lambda e: not fn(e))
 
-    def skipuntil(self, fn):
+    def skipuntil(self, fn: ta.Callable[[T], bool]) -> None:
         self.skipwhile(lambda e: not fn(e))
 
-    def takethrough(self, pos):
+    def takethrough(self, pos: int) -> ta.Iterator[T]:
         return self.takewhile(lambda _: self._pos < pos)
 
-    def skipthrough(self, pos):
+    def skipthrough(self, pos: int) -> None:
         self.skipwhile(lambda _: self._pos < pos)
 
-    def taketo(self, pos):
+    def taketo(self, pos: int) -> ta.Iterator[T]:
         return self.takethrough(pos - 1)
 
-    def skipto(self, pos):
+    def skipto(self, pos: int) -> None:
         self.skipthrough(pos - 1)
 
 
@@ -90,7 +85,7 @@ class ProxyIterator(ta.Iterator[T]):
     def __init__(self, fn: ta.Callable[[], T]) -> None:
         self._fn = fn
 
-    def __iter__(self) -> ta.Iterator[T]:
+    def __iter__(self) -> ta.Self:
         return self
 
     def __next__(self) -> T:
@@ -103,9 +98,9 @@ class PrefetchIterator(ta.Iterator[T]):
         super().__init__()
 
         self._fn = fn
-        self._deque: ta.Deque[T] = collections.deque()
+        self._deque: collections.deque[T] = collections.deque()
 
-    def __iter__(self) -> ta.Iterator[T]:
+    def __iter__(self) -> ta.Self:
         return self
 
     def push(self, item) -> None:
@@ -116,7 +111,7 @@ class PrefetchIterator(ta.Iterator[T]):
             return self._deque.popleft()
         except IndexError:
             if self._fn is None:
-                raise StopIteration
+                raise StopIteration from None
         return self._fn()
 
 
@@ -126,9 +121,9 @@ class RetainIterator(ta.Iterator[T]):
         super().__init__()
 
         self._fn = fn
-        self._deque: ta.Deque[T] = collections.deque()
+        self._deque: collections.deque[T] = collections.deque()
 
-    def __iter__(self) -> ta.Iterator[T]:
+    def __iter__(self) -> ta.Self:
         return self
 
     def pop(self) -> None:

omlish/json.py

@@ -1,5 +1,141 @@
+"""
+json
+  dump
+    skipkeys=False
+    ensure_ascii=True
+    check_circular=True
+    allow_nan=True
+    cls=None
+    indent=None
+    separators=None
+    default=None
+    sort_keys=False
+  dumps
+    ^
+  load
+    cls=None
+    object_hook=None
+    parse_float=None
+    parse_int=None
+    parse_constant=None
+    object_pairs_hook=None
+  loads
+    ^
+
+ujson
+  dump
+    ensure_ascii
+    encode_html_chars
+    escape_forward_slashes
+    sort_keys
+    indent
+    allow_nan
+    reject_bytes
+    default
+    separators
+  dumps
+    ^
+  load
+  loads
+
+orjson
+  dumps
+    default
+    option
+      OPT_INDENT_2
+      OPT_NAIVE_UTC
+      OPT_NON_STR_KEYS
+      OPT_OMIT_MICROSECONDS
+      OPT_PASSTHROUGH_DATACLASS
+      OPT_PASSTHROUGH_DATETIME
+      OPT_PASSTHROUGH_SUBCLASS
+      OPT_SERIALIZE_DATACLASS
+      OPT_SERIALIZE_NUMPY
+      OPT_SERIALIZE_UUID
+      OPT_SORT_KEYS
+      OPT_STRICT_INTEGER
+      OPT_UTC_Z
+  loads
+
+rapidjson
+  dump
+    skipkeys=False,
+    ensure_ascii=True,
+    write_mode=WM_COMPACT,
+      WM_COMPACT
+      WM_PRETTY
+      WM_SINGLE_LINE_ARRAY
+    indent=4,
+    default=None,
+    sort_keys=False,
+    number_mode=None,
+      NM_NONE
+      NM_DECIMAL
+      NM_NAN
+      NM_NATIVE
+    datetime_mode=None,
+      DM_NONE
+      DM_ISO8601
+      DM_UNIX_TIME
+      DM_ONLY_SECONDS
+      DM_IGNORE_TZ
+      DM_NAIVE_IS_UTC
+      DM_SHIFT_TO_UTC
+    uuid_mode=None,
+      UM_NONE
+      UM_CANONICAL
+      UM_HEX
+    bytes_mode=BM_UTF8,
+      BM_NONE
+      BM_UTF8
+    iterable_mode=IM_ANY_ITERABLE,
+      IM_ANY_ITERABLE
+      IM_ONLY_LISTS
+    mapping_mode=MM_ANY_MAPPING,
+      MM_ANY_MAPPING
+      MM_ONLY_DICTS
+      MM_COERCE_KEYS_TO_STRINGS
+      MM_SKIP_NON_STRING_KEYS
+      MM_SORT_KEYS
+    chunk_size
+    allow_nan=True
+  dumps
+    ^
+    -chunk_size
+  load
+    object_hook=None,
+    number_mode=None,
+      ^
+    datetime_mode=None,
+      ^
+    uuid_mode=None,
+      ^
+    parse_mode=None,
+      PM_NONE
+      PM_COMMENTS
+      PM_TRAILING_COMMAS
+    chunk_size=65536,
+    allow_nan=True
+  loads
+    ^
+    -chunk_size
+
+"""
 import functools
 import json as _json
+import typing as ta
+
+from . import lang
+
+if ta.TYPE_CHECKING:
+    import orjson as _orjson
+    import ujson as _ujson
+else:
+    _orjson = lang.proxy_import('orjson')
+    _ujson = lang.proxy_import('ujson')
+
+
+##
 
 
 dump = _json.dump
@@ -10,30 +146,31 @@ detect_encoding = _json.detect_encoding
 load = _json.load
 loads = _json.loads
 
+
 ##
 
 
 PRETTY_INDENT = 2
 
-PRETTY_KWARGS = dict(
+PRETTY_KWARGS: ta.Mapping[str, ta.Any] = dict(
     indent=PRETTY_INDENT,
 )
 
-dump_pretty = functools.partial(dump, **PRETTY_KWARGS)
-dumps_pretty = functools.partial(dumps, **PRETTY_KWARGS)
+dump_pretty: ta.Callable[..., bytes] = functools.partial(dump, **PRETTY_KWARGS)  # type: ignore
+dumps_pretty: ta.Callable[..., str] = functools.partial(dumps, **PRETTY_KWARGS)
 
 ##
 
 
 COMPACT_SEPARATORS = (',', ':')
 
-COMPACT_KWARGS = dict(
+COMPACT_KWARGS: ta.Mapping[str, ta.Any] = dict(
     indent=0,
     separators=COMPACT_SEPARATORS,
 )
 
-dump_compact = functools.partial(dump, **COMPACT_KWARGS)
-dumps_compact = functools.partial(dumps, **COMPACT_KWARGS)
+dump_compact: ta.Callable[..., bytes] = functools.partial(dump, **COMPACT_KWARGS)  # type: ignore
+dumps_compact: ta.Callable[..., str] = functools.partial(dumps, **COMPACT_KWARGS)
 
 
 ##

omlish/lang/__init__.py

@@ -8,7 +8,7 @@ from .classes import (  # noqa
     Callable,
     Descriptor,
     Final,
-    FinalException,
+    FinalError,
     LazySingleton,
     Marker,
     Namespace,
@@ -18,7 +18,7 @@ from .classes import (  # noqa
     PackageSealed,
     Picklable,
     Sealed,
-    SealedException,
+    SealedError,
     SimpleMetaDict,
     Singleton,
     Virtual,
@@ -74,10 +74,12 @@ from .datetimes import (  # noqa
 )
 
 from .descriptors import (  # noqa
-    AccessForbiddenException,
+    AccessForbiddenError,
     access_forbidden,
+    attr_property,
     classonly,
     is_method_descriptor,
+    item_property,
     unwrap_method_descriptors,
 )
 
@@ -87,8 +89,9 @@ from .exceptions import (  # noqa
 
 from .functions import (  # noqa
     Args,
-    VoidException,
+    VoidError,
     constant,
+    finally_,
     identity,
     is_lambda,
     is_none,
@@ -96,6 +99,7 @@ from .functions import (  # noqa
     maybe_call,
     periodically,
     raise_,
+    raising,
     recurse,
     try_,
     unwrap_func,
@@ -136,6 +140,7 @@ from .objects import (  # noqa
     arg_repr,
     attr_repr,
     new_type,
+    opt_repr,
     super_meta,
 )
 
@@ -151,6 +156,10 @@ from .strings import (  # noqa
     snake_case,
 )
 
+from .sys import (  # noqa
+    is_gil_enabled,
+)
+
 from .timeouts import (  # noqa
     DeadlineTimeout,
     InfiniteTimeout,