omlish 0.0.0.dev6__py3-none-any.whl → 0.0.0.dev8__py3-none-any.whl

omlish/inject/elements.py

@@ -8,7 +8,7 @@ from .impl.origins import HasOriginsImpl
 
 
 class Element(HasOriginsImpl, lang.Abstract, lang.PackageSealed):
-    pass
+    """Note: inheritors must be dataclasses."""
 
 
 class ElementGenerator(lang.Abstract, lang.PackageSealed):

omlish/inject/impl/injector.py

@@ -1,5 +1,7 @@
 """
 TODO:
+ - ** can currently bind in a child/private scope shadowing an external parent binding **
+ - better source tracking
  - cache/export ElementCollections lol
  - scope bindings, auto in root
  - injector-internal / blacklisted bindings (Injector itself, default scopes) without rebuilding ElementCollection
@@ -14,6 +16,7 @@ TODO:
 import contextlib
 import functools
 import itertools
+import logging
 import typing as ta
 import weakref
 
@@ -39,6 +42,9 @@ from .scopes import ScopeImpl
 from .scopes import make_scope_impl
 
 
+log = logging.getLogger(__name__)
+
+
 DEFAULT_SCOPES: list[Scope] = [
     Unscoped(),
     Singleton(),
@@ -103,10 +109,11 @@ class InjectorImpl(Injector, lang.Final):
         def __init__(self, injector: 'InjectorImpl') -> None:
             super().__init__()
             self._injector = injector
-            self._provisions: dict[Key, ta.Any] = {}
+            self._provisions: dict[Key, lang.Maybe] = {}
             self._seen_keys: set[Key] = set()
+            self._source_stack: list[ta.Any] = []
 
-        def handle_key(self, key: Key) -> lang.Maybe:
+        def handle_key(self, key: Key) -> lang.Maybe[lang.Maybe]:
             try:
                 return lang.just(self._provisions[key])
             except KeyError:
@@ -116,10 +123,21 @@ class InjectorImpl(Injector, lang.Final):
             self._seen_keys.add(key)
             return lang.empty()
 
-        def handle_provision(self, key: Key, v: ta.Any) -> None:
+        def handle_provision(self, key: Key, mv: lang.Maybe) -> lang.Maybe:
             check.in_(key, self._seen_keys)
             check.not_in(key, self._provisions)
-            self._provisions[key] = v
+            self._provisions[key] = mv
+            return mv
+
+        @contextlib.contextmanager
+        def push_source(self, source: ta.Any) -> ta.Iterator[None]:
+            self._source_stack.append(source)
+            try:
+                yield
+            finally:
+                nsource = self._source_stack.pop()
+                if source is not nsource:
+                    raise Exception(f'Stack error: {source=} is not {nsource=}')
 
         def __enter__(self) -> ta.Self:
             return self
@@ -140,38 +158,50 @@ class InjectorImpl(Injector, lang.Final):
             finally:
                 self.__cur_req = None
 
-    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+    def _try_provide(self, key: ta.Any, *, source: ta.Any = None) -> lang.Maybe[ta.Any]:
         key = as_key(key)
 
+        cr: InjectorImpl._Request
         with self._current_request() as cr:
-            ic = self._internal_consts.get(key)
-            if ic is not None:
-                return lang.just(ic)
+            with cr.push_source(source):
+                if (rv := cr.handle_key(key)).present:
+                    return rv.must()
 
-            if (rv := cr.handle_key(key)).present:
-                return rv
+                ic = self._internal_consts.get(key)
+                if ic is not None:
+                    return cr.handle_provision(key, lang.just(ic))
 
-            bi = self._bim.get(key)
-            if bi is not None:
-                sc = self._scopes[bi.scope]
+                bi = self._bim.get(key)
+                if bi is not None:
+                    sc = self._scopes[bi.scope]
 
-                fn = lambda: sc.provide(bi, self)  # noqa
-                for pl in self._pls:
-                    fn = functools.partial(pl, self, key, bi.binding, fn)
-                v = fn()
+                    fn = lambda: sc.provide(bi, self)  # noqa
+                    for pl in self._pls:
+                        fn = functools.partial(pl, self, key, bi.binding, fn)
+                    v = fn()
 
-                cr.handle_provision(key, v)
-                return lang.just(v)
+                    return cr.handle_provision(key, lang.just(v))
 
-            if self._p is not None:
-                pv = self._p.try_provide(key)
-                if pv is not None:
-                    return pv
+                if self._p is not None:
+                    pv = self._p._try_provide(key, source=source)  # noqa
+                    if pv.present:
+                        return cr.handle_provision(key, pv)
 
-            return lang.empty()
+                return cr.handle_provision(key, lang.empty())
+
+    def _provide(self, key: ta.Any, *, source: ta.Any = None) -> ta.Any:
+        v = self._try_provide(key, source=source)
+        if v.present:
+            return v.must()
+        raise UnboundKeyError(key)
+
+    #
+
+    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+        return self.try_provide(key)
 
     def provide(self, key: ta.Any) -> ta.Any:
-        v = self.try_provide(key)
+        v = self._try_provide(key)
         if v.present:
             return v.must()
         raise UnboundKeyError(key)
@@ -180,11 +210,11 @@ class InjectorImpl(Injector, lang.Final):
         ret: dict[str, ta.Any] = {}
         for kw in kt.kwargs:
             if kw.has_default:
-                if not (mv := self.try_provide(kw.key)).present:
+                if not (mv := self._try_provide(kw.key, source=kt)).present:
                     continue
                 v = mv.must()
             else:
-                v = self.provide(kw.key)
+                v = self._provide(kw.key, source=kt)
             ret[kw.name] = v
         return ret
 

omlish/inject/impl/origins.py

@@ -64,6 +64,8 @@ def set_origins(obj: HasOriginsT, origins: Origins) -> HasOriginsT:
 
 
 class HasOriginsImpl(HasOrigins):
+    """Note: inheritors must be dataclasses."""
+
     @property
     def origins(self) -> Origins:
         return self.__dict__[ORIGINS_ATTR]

omlish/inject/origins.py

@@ -5,6 +5,9 @@ from .. import dataclasses as dc
 from .. import lang
 
 
+T = ta.TypeVar('T')
+
+
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Origin:

omlish/inject/utils.py

@@ -0,0 +1,18 @@
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+from .impl.origins import HasOriginsImpl
+
+
+T = ta.TypeVar('T')
+
+
+@dc.dataclass(frozen=True, eq=False)
+class ConstFn(HasOriginsImpl, lang.Final, ta.Generic[T]):
+    """An origin tracking provider function for a constant value. Equivalent to `lambda: v` but transparent."""
+
+    v: T
+
+    def __call__(self) -> T:
+        return self.v

omlish/iterators.py

@@ -1,9 +1,13 @@
 import collections
+import dataclasses as dc
 import functools
 import heapq
 import itertools
 import typing as ta
 
+# from . import check
+from . import lang
+
 
 T = ta.TypeVar('T')
 U = ta.TypeVar('U')
@@ -13,10 +17,10 @@ _MISSING = object()
 
 class PeekIterator(ta.Iterator[T]):
 
-    def __init__(self, it: ta.Iterator[T]) -> None:
+    def __init__(self, it: ta.Iterable[T]) -> None:
         super().__init__()
 
-        self._it = it
+        self._it = iter(it)
         self._pos = -1
         self._next_item: ta.Any = _MISSING
 
@@ -231,3 +235,66 @@ def sliding_window(it: ta.Iterable[T], n: int) -> ta.Iterator[tuple[T, ...]]:
     for x in iterator:
         window.append(x)
         yield tuple(window)
+
+
+##
+
+
+@dc.dataclass()
+class UniqueStats:
+    key: ta.Any
+    num_seen: int
+    first_idx: int
+    last_idx: int
+
+
+@dc.dataclass(frozen=True)
+class UniqueItem(ta.Generic[T]):
+    idx: int
+    item: T
+    stats: UniqueStats
+    out: lang.Maybe[T]
+
+
+class UniqueIterator(ta.Iterator[UniqueItem[T]]):
+    def __init__(
+            self,
+            it: ta.Iterable[T],
+            keyer: ta.Callable[[T], ta.Any] = lang.identity,
+    ) -> None:
+        super().__init__()
+        self._it = enumerate(it)
+        self._keyer = keyer
+
+        self.stats: dict[ta.Any, UniqueStats] = {}
+
+    def __next__(self) -> UniqueItem[T]:
+        idx, item = next(self._it)
+        key = self._keyer(item)
+
+        try:
+            stats = self.stats[key]
+
+        except KeyError:
+            stats = self.stats[key] = UniqueStats(
+                key,
+                num_seen=1,
+                first_idx=idx,
+                last_idx=idx,
+            )
+            return UniqueItem(
+                idx,
+                item,
+                stats,
+                lang.just(item),
+            )
+
+        else:
+            stats.num_seen += 1
+            stats.last_idx = idx
+            return UniqueItem(
+                idx,
+                item,
+                stats,
+                lang.empty(),
+            )

omlish/lang/__init__.py

@@ -68,13 +68,6 @@ from .contextmanagers import (  # noqa
     maybe_managing,
 )
 
-from .datetimes import (  # noqa
-    months_ago,
-    parse_date,
-    parse_timedelta,
-    to_seconds,
-)
-
 from .descriptors import (  # noqa
     AccessForbiddenError,
     access_forbidden,
@@ -121,6 +114,7 @@ from .imports import (  # noqa
     import_module_attr,
     lazy_import,
     proxy_import,
+    resolve_import_name,
     try_import,
     yield_import_all,
     yield_importable,
@@ -128,8 +122,11 @@ from .imports import (  # noqa
 
 from .iterables import (  # noqa
     BUILTIN_SCALAR_ITERABLE_TYPES,
+    Generator,
     asrange,
     exhaust,
+    flatmap,
+    flatten,
     ilen,
     itergen,
     peek,
@@ -149,12 +146,18 @@ from .objects import (  # noqa
     SimpleProxy,
     arg_repr,
     attr_repr,
+    can_weakref,
+    deep_subclasses,
     new_type,
     opt_repr,
     super_meta,
 )
 
 from .strings import (  # noqa
+    BOOL_FALSE_STRINGS,
+    BOOL_STRINGS,
+    BOOL_TRUE_STRINGS,
+    STRING_BOOL_VALUES,
     camel_case,
     indent_lines,
     is_dunder,
@@ -167,6 +170,8 @@ from .strings import (  # noqa
 )
 
 from .sys import (  # noqa
+    REQUIRED_PYTHON_VERSION,
+    check_runtime_version,
     is_gil_enabled,
 )
 
@@ -180,6 +185,10 @@ from .timeouts import (  # noqa
 
 from .typing import (  # noqa
     BytesLike,
+    Func0,
+    Func1,
+    Func2,
+    Func3,
     protocol_check,
     typed_lambda,
     typed_partial,

omlish/lang/classes/restrict.py

@@ -97,9 +97,19 @@ class NotInstantiable(Abstract):
 class NotPicklable:
     __slots__ = ()
 
+    @ta.final
+    def __reduce__(self) -> ta.NoReturn:
+        raise TypeError
+
+    @ta.final
+    def __reduce_ex__(self, protocol) -> ta.NoReturn:
+        raise TypeError
+
+    @ta.final
     def __getstate__(self) -> ta.NoReturn:
         raise TypeError
 
+    @ta.final
     def __setstate__(self, state) -> ta.NoReturn:
         raise TypeError
 

omlish/lang/contextmanagers.py

@@ -307,7 +307,7 @@ Lockable = ta.Callable[[], ta.ContextManager]
 DefaultLockable = bool | Lockable | ta.ContextManager | None
 
 
-def default_lock(value: DefaultLockable, default: DefaultLockable) -> Lockable:
+def default_lock(value: DefaultLockable, default: DefaultLockable = None) -> Lockable:
     if value is None:
         value = default
 

omlish/lang/descriptors.py

@@ -114,7 +114,7 @@ class _decorator_descriptor:  # noqa
             self._wrapper, self._fn = wrapper, fn
             update_wrapper_except_dict(self, fn)
 
-        def __get__(self, instance, owner):
+        def __get__(self, instance, owner=None):
             return functools.update_wrapper(functools.partial(self._wrapper, fn := self._fn.__get__(instance, owner)), fn)  # noqa
 
     else:
@@ -123,7 +123,7 @@ class _decorator_descriptor:  # noqa
             self._md = _has_method_descriptor(fn)
             update_wrapper_except_dict(self, fn)
 
-        def __get__(self, instance, owner):
+        def __get__(self, instance, owner=None):
             fn = self._fn.__get__(instance, owner)
             if self._md or instance is not None:
                 @functools.wraps(fn)
@@ -218,7 +218,7 @@ class _ClassOnly:
     def _mth(self, x):
         self.__mth = x
 
-    def __get__(self, instance, owner):
+    def __get__(self, instance, owner=None):
         if instance is not None:
             raise TypeError(f'method must not be used on instance: {self._mth}')
         return self._mth[0].__get__(instance, owner)

omlish/lang/imports.py

@@ -155,3 +155,70 @@ def try_import(spec: str) -> types.ModuleType | None:
         return __import__(s, globals(), level=l)
     except ImportError:
         return None
+
+
+##
+
+
+def resolve_import_name(name: str, package: str | None = None) -> str:
+    level = 0
+
+    if name.startswith('.'):
+        if not package:
+            raise TypeError("the 'package' argument is required to perform a relative import for {name!r}")
+        for character in name:
+            if character != '.':
+                break
+            level += 1
+
+    name = name[level:]
+
+    if not isinstance(name, str):
+        raise TypeError(f'module name must be str, not {type(name)}')
+    if level < 0:
+        raise ValueError('level must be >= 0')
+    if level > 0:
+        if not isinstance(package, str):
+            raise TypeError('__package__ not set to a string')
+        elif not package:
+            raise ImportError('attempted relative import with no known parent package')
+    if not name and level == 0:
+        raise ValueError('Empty module name')
+
+    if level > 0:
+        bits = package.rsplit('.', level - 1)  # type: ignore
+        if len(bits) < level:
+            raise ImportError('attempted relative import beyond top-level package')
+        base = bits[0]
+        name = f'{base}.{name}' if name else base
+
+    return name
+
+
+##
+
+
+_REGISTERED_CONDITIONAL_IMPORTS: dict[str, list[str] | None] = {}
+
+
+def _register_conditional_import(when: str, then: str, package: str | None = None) -> None:
+    wn = resolve_import_name(when, package)
+    tn = resolve_import_name(then, package)
+    if tn in sys.modules:
+        return
+    if wn in sys.modules:
+        __import__(tn)
+    else:
+        tns = _REGISTERED_CONDITIONAL_IMPORTS.setdefault(wn, [])
+        if tns is None:
+            raise Exception(f'Conditional import trigger already cleared: {wn=} {tn=}')
+        tns.append(tn)
+
+
+def _trigger_conditional_imports(package: str) -> None:
+    tns = _REGISTERED_CONDITIONAL_IMPORTS.get(package, [])
+    if tns is None:
+        raise Exception(f'Conditional import trigger already cleared: {package=}')
+    _REGISTERED_CONDITIONAL_IMPORTS[package] = None
+    for tn in tns:
+        __import__(tn)

omlish/lang/iterables.py

@@ -4,6 +4,8 @@ import typing as ta
 
 
 T = ta.TypeVar('T')
+S = ta.TypeVar('S')
+R = ta.TypeVar('R')
 
 
 BUILTIN_SCALAR_ITERABLE_TYPES: tuple[type, ...] = (
@@ -71,3 +73,41 @@ class itergen(ta.Generic[T]):  # noqa
 
 def renumerate(it: ta.Iterable[T]) -> ta.Iterable[tuple[T, int]]:
     return ((e, i) for i, e in enumerate(it))
+
+
+flatten = itertools.chain.from_iterable
+
+
+def flatmap(fn: ta.Callable[[T], ta.Iterable[R]], it: ta.Iterable[T]) -> ta.Iterable[R]:
+    return flatten(map(fn, it))
+
+
+class Generator(ta.Generator[T, S, R]):
+    def __init__(self, gen: ta.Generator[T, S, R]) -> None:
+        super().__init__()
+        self.gen = gen
+
+    value: R
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return self.send(None)
+
+    def send(self, v):
+        try:
+            return self.gen.send(v)
+        except StopIteration as e:
+            self.value = e.value
+            raise
+
+    def throw(self, *args):
+        try:
+            return self.gen.throw(*args)
+        except StopIteration as e:
+            self.value = e.value
+            raise
+
+    def close(self):
+        self.gen.close()

omlish/lang/maybes.py

@@ -65,6 +65,9 @@ class Maybe(abc.ABC, ta.Generic[T]):
 class _Maybe(Maybe[T], tuple):
     __slots__ = ()
 
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
     @property
     def present(self) -> bool:
         return bool(self)

omlish/lang/objects.py

@@ -1,5 +1,6 @@
 import types
 import typing as ta
+import weakref
 
 
 T = ta.TypeVar('T')
@@ -28,6 +29,28 @@ def opt_repr(obj: ta.Any) -> str | None:
 ##
 
 
+_CAN_WEAKREF_TYPE_MAP: ta.MutableMapping[type, bool] = weakref.WeakKeyDictionary()
+
+
+def can_weakref(obj: ta.Any) -> bool:
+    _type = type(obj)
+    try:
+        return _CAN_WEAKREF_TYPE_MAP[_type]
+    except KeyError:
+        pass
+    try:
+        weakref.ref(obj)
+    except TypeError:
+        ret = False
+    else:
+        ret = True
+    _CAN_WEAKREF_TYPE_MAP[_type] = ret
+    return ret
+
+
+##
+
+
 def new_type(
         name: str,
         bases: ta.Sequence[ta.Any],
@@ -62,6 +85,21 @@ def super_meta(
 ##
 
 
+def deep_subclasses(cls: type) -> ta.Iterator[type]:
+    seen = set()
+    todo = list(reversed(cls.__subclasses__()))
+    while todo:
+        cur = todo.pop()
+        if cur in seen:
+            continue
+        seen.add(cur)
+        yield cur
+        todo.extend(reversed(cur.__subclasses__()))
+
+
+##
+
+
 class SimpleProxy(ta.Generic[T]):
 
     class Descriptor:

omlish/lang/strings.py

@@ -126,3 +126,28 @@ def is_ident_cont(c: str) -> bool:
 
 def is_ident(name: str) -> bool:
     return is_ident_start(name[0]) and all(is_ident_cont(c) for c in name[1:])
+
+
+##
+
+
+BOOL_STRINGS: ta.Sequence[tuple[str, str]] = [
+    ('n', 'y'),
+    ('no', 'yes'),
+    ('f', 't'),
+    ('false', 'true'),
+    ('off', 'on'),
+    ('0', '1'),
+]
+
+BOOL_FALSE_STRINGS = frozenset(tup[0] for tup in BOOL_STRINGS)
+BOOL_TRUE_STRINGS = frozenset(tup[1] for tup in BOOL_STRINGS)
+
+STRING_BOOL_VALUES: ta.Mapping[str, bool] = {
+    k: v
+    for ks, v in [
+        (BOOL_FALSE_STRINGS, False),
+        (BOOL_TRUE_STRINGS, True),
+    ]
+    for k in ks
+}

omlish/lang/sys.py

@@ -1,6 +1,15 @@
 import sys
 
 
+REQUIRED_PYTHON_VERSION = (3, 12)
+
+
+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
+
+
 def is_gil_enabled() -> bool:
     if (fn := getattr(sys, '_is_gil_enabled', None)) is not None:
         return fn()