omlish 0.0.0.dev5__py3-none-any.whl → 0.0.0.dev7__py3-none-any.whl

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,21 +68,18 @@ 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,
     attr_property,
     classonly,
+    decorator,
     is_method_descriptor,
     item_property,
+    unwrap_func,
+    unwrap_func_with_partials,
     unwrap_method_descriptors,
+    update_wrapper_except_dict,
 )
 
 from .exceptions import (  # noqa
@@ -99,14 +96,14 @@ from .functions import (  # noqa
     is_lambda,
     is_none,
     is_not_none,
+    isinstance_of,
+    issubclass_of,
     maybe_call,
     periodically,
     raise_,
     raising,
     recurse,
     try_,
-    unwrap_func,
-    unwrap_func_with_partials,
     void,
 )
 
@@ -117,6 +114,7 @@ from .imports import (  # noqa
     import_module_attr,
     lazy_import,
     proxy_import,
+    resolve_import_name,
     try_import,
     yield_import_all,
     yield_importable,
@@ -124,11 +122,16 @@ from .imports import (  # noqa
 
 from .iterables import (  # noqa
     BUILTIN_SCALAR_ITERABLE_TYPES,
+    Generator,
     asrange,
     exhaust,
+    flatmap,
+    flatten,
     ilen,
+    itergen,
     peek,
     prodrange,
+    renumerate,
     take,
 )
 
@@ -143,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,
@@ -161,6 +170,8 @@ from .strings import (  # noqa
 )
 
 from .sys import (  # noqa
+    REQUIRED_PYTHON_VERSION,
+    check_runtime_version,
     is_gil_enabled,
 )
 
@@ -174,6 +185,10 @@ from .timeouts import (  # noqa
 
 from .typing import (  # noqa
     BytesLike,
+    Func0,
+    Func1,
+    Func2,
+    Func3,
     protocol_check,
     typed_lambda,
     typed_partial,

omlish/lang/cached.py

@@ -11,8 +11,8 @@ import typing as ta
 
 from .contextmanagers import DefaultLockable
 from .contextmanagers import default_lock
-from .functions import unwrap_func
-from .functions import unwrap_func_with_partials
+from .descriptors import unwrap_func
+from .descriptors import unwrap_func_with_partials
 
 
 P = ta.ParamSpec('P')

omlish/lang/classes/restrict.py

@@ -78,7 +78,8 @@ class PackageSealed:
         for base in cls.__bases__:
             if base is not Abstract:
                 if PackageSealed in base.__bases__:
-                    if cls.__module__.split('.')[:-1] != base.__module__.split('.')[:-1]:
+                    pfx = base.__module__.split('.')[:-1]
+                    if cls.__module__.split('.')[:len(pfx)] != pfx:
                         raise SealedError(base)
         super().__init_subclass__(**kwargs)
 
@@ -96,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/classes/simple.py

@@ -14,13 +14,25 @@ V = ta.TypeVar('V')
 ##
 
 
-class _Namespace(Final):
+class _NamespaceMeta(abc.ABCMeta):
+    def __new__(mcls, name, bases, namespace):
+        if bases:
+            for nc in (NotInstantiable,):
+                if nc not in bases:
+                    bases += (nc,)
+        return super().__new__(mcls, name, bases, namespace)
 
-    def __mro_entries__(self, bases, **kwargs):
-        return (Final, NotInstantiable)
+    def __iter__(cls) -> ta.Iterator[tuple[str, ta.Any]]:
+        for a in dir(cls):
+            if not a.startswith('_'):
+                yield (a, getattr(cls, a))
 
+    def __getitem__(cls, n: str) -> ta.Any:
+        return getattr(cls, n)
 
-Namespace: type = _Namespace()  # type: ignore
+
+class Namespace(metaclass=_NamespaceMeta):
+    pass
 
 
 ##
@@ -54,8 +66,6 @@ class _MarkerMeta(abc.ABCMeta):
 class Marker(NotInstantiable, metaclass=_MarkerMeta):
     """A marker."""
 
-    __slots__ = ()
-
 
 ##
 
@@ -77,7 +87,7 @@ _SINGLETON_LOCK = threading.RLock()
 
 
 def _set_singleton_instance(inst):
-    cls = type(inst)
+    cls = inst.__class__
     if _SINGLETON_INSTANCE_ATTR in cls.__dict__:
         raise TypeError(cls)
 
@@ -86,7 +96,7 @@ def _set_singleton_instance(inst):
 
     @functools.wraps(old_init)
     def new_init(self):
-        if type(self) is not cls:
+        if self.__class__ is not cls:
             old_init(self)  # noqa
 
     setattr(cls, '__init__', new_init)

omlish/lang/contextmanagers.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - AsyncExitStacked
+"""
 import abc
 import contextlib
 import contextvars
@@ -15,7 +19,7 @@ T = ta.TypeVar('T')
 
 class ContextManaged:
 
-    def __enter__(self: ta.Self) -> ta.Self:
+    def __enter__(self) -> ta.Self:
         return self
 
     def __exit__(
@@ -77,7 +81,7 @@ class ContextManager(abc.ABC, ta.Generic[T]):
             exc_type: type[BaseException] | None,
             exc_val: BaseException | None,
             exc_tb: types.TracebackType | None,
-    ) -> None:
+    ) -> bool | None:
         return self._contextmanager.__exit__(exc_type, exc_val, exc_tb)
 
 
@@ -198,7 +202,7 @@ class ExitStacked:
     def _enter_context(self, context_manager: ta.ContextManager[T]) -> T:
         return self._exit_stack.enter_context(ta.cast(ta.ContextManager, context_manager))
 
-    def __enter__(self: ta.Self) -> ta.Self:
+    def __enter__(self) -> ta.Self:
         try:
             superfn = super().__enter__  # type: ignore
         except AttributeError:
@@ -303,17 +307,22 @@ 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
+
     if value is True:
         lock = threading.RLock()
         return lambda: lock
+
     elif value is False or value is None:
         return NOP_CONTEXT_MANAGER
+
     elif callable(value):
         return value
+
     elif isinstance(value, ta.ContextManager):
         return lambda: value
+
     else:
         raise TypeError(value)

omlish/lang/descriptors.py

@@ -1,9 +1,11 @@
 import functools
 import operator
+import types
 import typing as ta
 
 
 T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
 
 
 ##
@@ -31,6 +33,19 @@ def is_method_descriptor(obj: ta.Any) -> bool:
     return isinstance(obj, (*BUILTIN_METHOD_DESCRIPTORS, _MethodDescriptor))
 
 
+def _has_method_descriptor(obj: ta.Any) -> bool:
+    while True:
+        if is_method_descriptor(obj):
+            return True
+        elif isinstance(obj, functools.partial):
+            obj = obj.func
+        else:
+            try:
+                obj = getattr(obj, '__wrapped__')
+            except AttributeError:
+                return False
+
+
 def unwrap_method_descriptors(fn: ta.Callable) -> ta.Callable:
     while is_method_descriptor(fn):
         fn = fn.__func__  # type: ignore  # noqa
@@ -40,6 +55,122 @@ def unwrap_method_descriptors(fn: ta.Callable) -> ta.Callable:
 ##
 
 
+def unwrap_func(fn: ta.Callable) -> ta.Callable:
+    fn, _ = unwrap_func_with_partials(fn)
+    return fn
+
+
+def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functools.partial]]:
+    ps = []
+    while True:
+        if is_method_descriptor(fn) or isinstance(fn, types.MethodType):
+            fn = fn.__func__  # type: ignore
+        elif hasattr(fn, '__wrapped__'):
+            nxt = fn.__wrapped__
+            if not callable(nxt):
+                raise TypeError(nxt)
+            if nxt is fn:
+                raise TypeError(fn)
+            fn = nxt
+        # NOTE: __wrapped__ takes precedence - a partial might point to a bound Method when the important information is
+        # still the unbound func. see _decorator_descriptor for an example of this.
+        elif isinstance(fn, functools.partial):
+            ps.append(fn)
+            fn = fn.func
+        else:
+            break
+    return fn, ps
+
+
+##
+
+
+WRAPPER_UPDATES_EXCEPT_DICT = tuple(a for a in functools.WRAPPER_UPDATES if a != '__dict__')
+
+
+def update_wrapper_except_dict(
+        wrapper,
+        wrapped,
+        assigned=functools.WRAPPER_ASSIGNMENTS,
+        updated=WRAPPER_UPDATES_EXCEPT_DICT,
+):
+    return functools.update_wrapper(
+        wrapper,
+        wrapped,
+        assigned=assigned,
+        updated=updated,
+    )
+
+
+##
+
+
+_DECORATOR_HANDLES_UNBOUND_METHODS = True
+
+
+class _decorator_descriptor:  # noqa
+    if not _DECORATOR_HANDLES_UNBOUND_METHODS:
+        def __init__(self, wrapper, fn):
+            self._wrapper, self._fn = wrapper, fn
+            update_wrapper_except_dict(self, fn)
+
+        def __get__(self, instance, owner=None):
+            return functools.update_wrapper(functools.partial(self._wrapper, fn := self._fn.__get__(instance, owner)), fn)  # noqa
+
+    else:
+        def __init__(self, wrapper, fn):
+            self._wrapper, self._fn = wrapper, fn
+            self._md = _has_method_descriptor(fn)
+            update_wrapper_except_dict(self, fn)
+
+        def __get__(self, instance, owner=None):
+            fn = self._fn.__get__(instance, owner)
+            if self._md or instance is not None:
+                @functools.wraps(fn)
+                def inner(*args, **kwargs):
+                    return self._wrapper(fn, *args, **kwargs)
+                return inner
+            else:
+                @functools.wraps(fn)
+                def outer(this, *args, **kwargs):
+                    @functools.wraps(self._fn)
+                    def inner(*args2, **kwargs2):
+                        return fn(this, *args2, **kwargs2)
+                    return self._wrapper(inner, *args, **kwargs)
+                return outer
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}<{self._wrapper}, {self._fn}>'
+
+    def __call__(self, *args, **kwargs):
+        return self._wrapper(self._fn, *args, **kwargs)
+
+
+class _decorator:  # noqa
+    def __init__(self, wrapper):
+        self._wrapper = wrapper
+        update_wrapper_except_dict(self, wrapper)
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}<{self._wrapper}>'
+
+    def __call__(self, fn):
+        return _decorator_descriptor(self._wrapper, fn)  # noqa
+
+
+# FIXME:
+# def decorator(
+#         wrapper: ta.Callable[ta.Concatenate[ta.Any, P], T],  # FIXME: https://youtrack.jetbrains.com/issue/PY-72164  # noqa
+# ) -> ta.Callable[[ta.Callable[P, T]], ta.Callable[P, T]]:
+#     return _decorator(wrapper)
+
+
+decorator = _decorator
+
+
+##
+
+
 class AccessForbiddenError(Exception):
 
     def __init__(self, name: str | None = None, *args: ta.Any, **kwargs: ta.Any) -> None:
@@ -87,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/functions.py

@@ -3,8 +3,6 @@ import functools
 import time
 import typing as ta
 
-from .descriptors import is_method_descriptor
-
 
 T = ta.TypeVar('T')
 P = ta.ParamSpec('P')
@@ -41,32 +39,6 @@ def recurse(fn: ta.Callable[..., T], *args, **kwargs) -> T:
 ##
 
 
-def unwrap_func(fn: ta.Callable) -> ta.Callable:
-    fn, _ = unwrap_func_with_partials(fn)
-    return fn
-
-
-def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functools.partial]]:
-    ps = []
-    while True:
-        if is_method_descriptor(fn):
-            fn = fn.__func__  # type: ignore
-        elif isinstance(fn, functools.partial):
-            ps.append(fn)
-            fn = fn.func
-        else:
-            nxt = getattr(fn, '__wrapped__', None)
-            if not callable(nxt):
-                break
-            if nxt is fn:
-                raise TypeError(fn)
-            fn = nxt
-    return fn, ps
-
-
-##
-
-
 def raise_(o: BaseException) -> ta.NoReturn:
     raise o
 
@@ -128,6 +100,14 @@ def is_not_none(o: ta.Any) -> bool:
     return o is not None
 
 
+def isinstance_of(class_or_tuple: ta.Any) -> ta.Callable[[ta.Any], bool]:
+    return lambda o: isinstance(o, class_or_tuple)
+
+
+def issubclass_of(class_or_tuple: ta.Any) -> ta.Callable[[ta.Any], bool]:
+    return lambda o: issubclass(o, class_or_tuple)
+
+
 class VoidError(Exception):
     pass
 

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)