omlish 0.0.0.dev1__py3-none-any.whl → 0.0.0.dev3__py3-none-any.whl

omlish/lang/contextmanagers.py

@@ -19,16 +19,16 @@ class ContextManaged:
 
     def __exit__(
             self,
-            exc_type: ta.Optional[ta.Type[Exception]],
-            exc_val: ta.Optional[Exception],
-            exc_tb: ta.Optional[types.TracebackType]
-    ) -> ta.Optional[bool]:
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: types.TracebackType | None,
+    ) -> bool | None:
         return None
 
 
 class NopContextManaged(ContextManaged):
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         raise TypeError
 
 
@@ -37,7 +37,7 @@ NOP_CONTEXT_MANAGED = NopContextManaged()
 
 class NopContextManager:
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         raise TypeError
 
     def __call__(self, *args, **kwargs):
@@ -51,7 +51,7 @@ NOP_CONTEXT_MANAGER = NopContextManager()
 
 
 @contextlib.contextmanager
-def defer(fn: ta.Callable) -> ta.Iterator[ta.Callable]:
+def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
     try:
         yield fn
     finally:
@@ -59,7 +59,7 @@ def defer(fn: ta.Callable) -> ta.Iterator[ta.Callable]:
 
 
 @contextlib.asynccontextmanager
-async def a_defer(fn: ta.Awaitable) -> ta.AsyncIterator[ta.Awaitable]:
+async def a_defer(fn: ta.Awaitable) -> ta.AsyncGenerator[ta.Awaitable, None]:
     try:
         yield fn
     finally:
@@ -84,11 +84,11 @@ def disposing(obj: T, attr: str = 'dispose') -> ta.Iterator[T]:
 
 
 @contextlib.contextmanager
-def breakpoint_on_exception():
+def breakpoint_on_exception():  # noqa
     try:
         yield
     except Exception as e:  # noqa
-        breakpoint()
+        breakpoint()  # noqa
         raise
 
 
@@ -102,7 +102,7 @@ def context_var_setting(var: contextvars.ContextVar[T], val: T) -> ta.Iterator[T
 
 
 @contextlib.contextmanager
-def attr_setting(obj, attr, val, *, default=None):
+def attr_setting(obj, attr, val, *, default=None):  # noqa
     not_set = object()
     orig = getattr(obj, attr, not_set)
     try:
@@ -146,10 +146,10 @@ class ExitStacked:
 
     def __exit__(
             self,
-            exc_type: ta.Optional[ta.Type[Exception]],
-            exc_val: ta.Optional[Exception],
-            exc_tb: ta.Optional[types.TracebackType]
-    ) -> ta.Optional[bool]:
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: types.TracebackType | None,
+    ) -> bool | None:
         self._exit_stack.__exit__(exc_type, exc_val, exc_tb)
         try:
             superfn = super().__exit__  # type: ignore
@@ -162,20 +162,28 @@ class ExitStacked:
 ##
 
 
-ContextWrappable: ta.TypeAlias = ta.Union[ta.ContextManager, str, ta.Callable[..., ta.ContextManager]]
+ContextWrappable: ta.TypeAlias = ta.ContextManager | str | ta.Callable[..., ta.ContextManager]
 
 
 class ContextWrapped:
 
-    def __init__(self, fn: ta.Callable, cm: ta.Union[str, ContextWrappable]) -> None:
+    def __init__(self, fn: ta.Callable, cm: str | ContextWrappable) -> None:
         super().__init__()
 
-        self._fn = fn
+        self._fn = (fn,)
         self._cm = cm
         self._name: str | None = None
 
         functools.update_wrapper(self, fn)
 
+    @property
+    def _fn(self):
+        return self.__fn
+
+    @_fn.setter
+    def _fn(self, x):
+        self.__fn = x
+
     def __set_name__(self, owner, name):
         if name is not None:
             if self._name is not None:
@@ -187,7 +195,7 @@ class ContextWrapped:
     def __get__(self, instance, owner=None):
         if instance is None and owner is None:
             return self
-        fn = self._fn.__get__(instance, owner)  # noqa
+        fn = self._fn[0].__get__(instance, owner)  # noqa
         cm: ta.Any = self._cm
         if isinstance(self._cm, str):
             if instance is not None:
@@ -204,10 +212,8 @@ class ContextWrapped:
             raise TypeError(cm)
         ret = type(self)(fn, cm)
         if self._name is not None:
-            try:
+            with contextlib.suppress(TypeError):
                 instance.__dict__[self._name] = ret
-            except TypeError:
-                pass
         return ret
 
     def __call__(self, *args, **kwargs):
@@ -217,10 +223,10 @@ class ContextWrapped:
         if not hasattr(cm, '__enter__') and callable(cm):
             cm = cm(*args, **kwargs)
         with cm:  # type: ignore
-            return self._fn(*args, **kwargs)
+            return self._fn[0](*args, **kwargs)
 
 
-def context_wrapped(cm):  # ContextWrappable -> ta.Callable[[CallableT], CallableT]:
+def context_wrapped(cm):  # ContextWrappable -> ta.Callable[[CallableT], CallableT]:  # noqa
     def inner(fn):
         return ContextWrapped(fn, cm)
     return inner
@@ -230,7 +236,7 @@ def context_wrapped(cm):  # ContextWrappable -> ta.Callable[[CallableT], Callabl
 
 
 Lockable = ta.Callable[[], ta.ContextManager]
-DefaultLockable = ta.Union[None, bool, Lockable, ta.ContextManager]
+DefaultLockable = bool | Lockable | ta.ContextManager | None
 
 
 def default_lock(value: DefaultLockable, default: DefaultLockable) -> Lockable:

omlish/lang/datetimes.py

@@ -62,6 +62,6 @@ def parse_timedelta(s: str) -> datetime.timedelta:
         for k, v in match.groupdict().items()
         if k != 'negative' and v is not None}
     if not timedelta_kwargs:
-        raise ValueError()
+        raise ValueError
     sign = -1 if match.groupdict().get('negative') else 1
     return sign * datetime.timedelta(**timedelta_kwargs)

omlish/lang/descriptors.py

@@ -1,6 +1,22 @@
+import functools
+import operator
 import typing as ta
 
 
+T = ta.TypeVar('T')
+
+
+##
+
+
+def attr_property(n: str):
+    return property(operator.attrgetter(n))
+
+
+def item_property(n: str):
+    return property(operator.itemgetter(n))
+
+
 ##
 
 
@@ -24,29 +40,58 @@ def unwrap_method_descriptors(fn: ta.Callable) -> ta.Callable:
 ##
 
 
-class AccessForbiddenException(Exception):
+class AccessForbiddenError(Exception):
 
-    def __init__(self, name: ta.Optional[str] = None, *args: ta.Any, **kwargs: ta.Any) -> None:
+    def __init__(self, name: str | None = None, *args: ta.Any, **kwargs: ta.Any) -> None:
         super().__init__(*((name,) if name is not None else ()), *args, **kwargs)  # noqa
         self.name = name
 
 
 class AccessForbiddenDescriptor:
 
-    def __init__(self, name: ta.Optional[str] = None) -> None:
+    def __init__(self, name: str | None = None) -> None:
         super().__init__()
 
         self._name = name
 
-    def __set_name__(self, owner: ta.Type, name: str) -> None:
+    def __set_name__(self, owner: type, name: str) -> None:
         if self._name is None:
             self._name = name
         elif name != self._name:
             raise NameError(name)
 
     def __get__(self, instance, owner=None):
-        raise AccessForbiddenException(self._name)
+        raise AccessForbiddenError(self._name)
 
 
-def access_forbidden():
+def access_forbidden():  # noqa
     return AccessForbiddenDescriptor()
+
+
+##
+
+
+class _ClassOnly:
+    def __init__(self, mth):
+        if not isinstance(mth, classmethod):
+            raise TypeError(f'must be classmethod: {mth}')
+        super().__init__()
+        self._mth = (mth,)
+        functools.update_wrapper(self, mth)  # type: ignore
+
+    @property
+    def _mth(self):
+        return self.__mth
+
+    @_mth.setter
+    def _mth(self, x):
+        self.__mth = x
+
+    def __get__(self, instance, owner):
+        if instance is not None:
+            raise TypeError(f'method must not be used on instance: {self._mth}')
+        return self._mth[0].__get__(instance, owner)
+
+
+def classonly(obj: T) -> T:  # noqa
+    return _ClassOnly(obj)  # type: ignore

omlish/lang/exceptions.py

@@ -0,0 +1,2 @@
+class Unreachable(Exception):  # noqa
+    pass

omlish/lang/functions.py

@@ -1,3 +1,4 @@
+import dataclasses as dc
 import functools
 import time
 import typing as ta
@@ -6,6 +7,11 @@ from .descriptors import is_method_descriptor
 
 
 T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
+CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
+
+
+##
 
 
 def is_lambda(f: ta.Any) -> bool:
@@ -13,6 +19,9 @@ def is_lambda(f: ta.Any) -> bool:
     return isinstance(f, type(l)) and f.__name__ == l.__name__
 
 
+##
+
+
 def maybe_call(obj: ta.Any, att: str, *args, default: ta.Any = None, **kwargs) -> ta.Any:
     try:
         fn = getattr(obj, att)
@@ -22,6 +31,16 @@ def maybe_call(obj: ta.Any, att: str, *args, default: ta.Any = None, **kwargs) -
         return fn(*args, **kwargs)
 
 
+def recurse(fn: ta.Callable[..., T], *args, **kwargs) -> T:
+    def rec(*args, **kwargs) -> T:
+        return fn(rec, *args, **kwargs)
+
+    return rec(*args, **kwargs)
+
+
+##
+
+
 def unwrap_func(fn: ta.Callable) -> ta.Callable:
     fn, _ = unwrap_func_with_partials(fn)
     return fn
@@ -39,38 +58,51 @@ def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functo
             nxt = getattr(fn, '__wrapped__', None)
             if not callable(nxt):
                 break
-            elif nxt is fn:
+            if nxt is fn:
                 raise TypeError(fn)
             fn = nxt
     return fn, ps
 
 
+##
+
+
 def raise_(o: BaseException) -> ta.NoReturn:
     raise o
 
 
+def raising(o: BaseException) -> ta.Callable[..., ta.NoReturn]:
+    def inner(*args, **kwargs):
+        raise o
+    return inner
+
+
 def try_(
-        exc: ta.Union[type[Exception], ta.Iterable[type[Exception]]] = Exception,
-        default: ta.Optional[T] = None,
-) -> ta.Callable[..., T]:
-    def outer(fn):
-        def inner(*args, **kwargs):
-            try:
-                return fn(*args, **kwargs)
-            except exct:
-                return default
-
-        return inner
+        fn: ta.Callable[P, T],
+        exc: type[Exception] | ta.Iterable[type[Exception]] = Exception,
+        default: T | None = None,
+) -> ta.Callable[P, T]:
+    def inner(*args, **kwargs):
+        try:
+            return fn(*args, **kwargs)
+        except exct:
+            return default
 
     exct = (exc,) if isinstance(exc, type) else tuple(exc)
-    return outer
+    return inner
 
 
-def recurse(fn: ta.Callable[..., T], *args, **kwargs) -> T:
-    def rec(*args, **kwargs) -> T:
-        return fn(rec, *args, **kwargs)
+def finally_(fn: ta.Callable[P, T], fin: ta.Callable) -> ta.Callable[P, T]:
+    def inner(*args, **kwargs):
+        try:
+            return fn(*args, **kwargs)
+        finally:
+            fin()
 
-    return rec(*args, **kwargs)
+    return inner
+
+
+##
 
 
 def identity(obj: T) -> T:
@@ -96,31 +128,65 @@ def is_not_none(o: ta.Any) -> bool:
     return o is not None
 
 
-class VoidException(Exception):
+class VoidError(Exception):
     pass
 
 
 class Void:
 
-    def __new__(cls, *args, **kwargs):
-        raise VoidException
+    def __new__(cls, *args: ta.Any, **kwargs: ta.Any) -> None:  # type: ignore  # noqa
+        raise VoidError
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        raise VoidError
+
+
+def void(*args: ta.Any, **kwargs: ta.Any) -> ta.NoReturn:
+    raise VoidError
+
 
-    def __init_subclass__(cls, **kwargs):
-        raise VoidException
+##
 
 
-def void(*args, **kwargs) -> ta.NoReturn:
-    raise VoidException
+_MISSING = object()
 
 
-def ticking_timeout(
-        s: int | float | None,
-        ex: type[BaseException] | BaseException = TimeoutError,
-) -> ta.Callable[[], None]:
-    if s is None:
-        return lambda: None
-    def tick():  # noqa
-        if time.time() >= deadline:
-            raise ex
-    deadline = time.time() + s
-    return tick
+def periodically(
+        fn: CallableT,
+        interval_s: float,
+        initial: ta.Any = _MISSING,
+        *,
+        include_runtime: bool = False,
+) -> CallableT:
+    nxt = time.time() + interval_s
+    ret = initial
+
+    @functools.wraps(fn)
+    def inner(*args, **kwargs):
+        nonlocal nxt, ret
+        if time.time() >= nxt or ret is _MISSING:
+            if include_runtime:
+                nxt = time.time() + interval_s
+            ret = fn(*args, **kwargs)
+            if not include_runtime:
+                nxt = time.time() + interval_s
+        return ret
+
+    return inner  # type: ignore
+
+
+##
+
+
+@dc.dataclass(init=False)
+class Args:
+    args: ta.Sequence[ta.Any]
+    kwargs: ta.Mapping[str, ta.Any]
+
+    def __init__(self, *args: ta.Any, **kwargs: ta.Any) -> None:
+        super().__init__()
+        self.args = args
+        self.kwargs = kwargs
+
+    def __call__(self, fn: ta.Callable[..., T]) -> T:
+        return fn(*self.args, **self.kwargs)

omlish/lang/imports.py

@@ -1,5 +1,6 @@
+import contextlib
 import functools
-import importlib
+import importlib.resources
 import sys
 import types
 import typing as ta
@@ -10,14 +11,14 @@ from .cached import cached_function
 ##
 
 
-def lazy_import(name: str, package: ta.Optional[str] = None) -> ta.Callable[[], ta.Any]:
+def lazy_import(name: str, package: str | None = None) -> ta.Callable[[], ta.Any]:
     return cached_function(functools.partial(importlib.import_module, name, package=package))
 
 
-def proxy_import(name: str, package: ta.Optional[str] = None) -> types.ModuleType:
+def proxy_import(name: str, package: str | None = None) -> types.ModuleType:
     omod = None
 
-    def __getattr__(att):
+    def __getattr__(att):  # noqa
         nonlocal omod
         if omod is None:
             omod = importlib.import_module(name, package=package)
@@ -31,9 +32,6 @@ def proxy_import(name: str, package: ta.Optional[str] = None) -> types.ModuleTyp
 ##
 
 
-_pkg_resources = lazy_import('pkg_resources')
-
-
 def import_module(dotted_path: str) -> types.ModuleType:
     if not dotted_path:
         raise ImportError(dotted_path)
@@ -42,7 +40,7 @@ def import_module(dotted_path: str) -> types.ModuleType:
         try:
             mod = getattr(mod, name)
         except AttributeError:
-            raise AttributeError('Module %r has no attribute %r' % (mod, name))
+            raise AttributeError(f'Module {mod!r} has no attribute {name!r}') from None
     return mod
 
 
@@ -52,7 +50,7 @@ def import_module_attr(dotted_path: str) -> ta.Any:
     try:
         return getattr(mod, class_name)
     except AttributeError:
-        raise AttributeError('Module %r has no attr %r' % (module_name, class_name))
+        raise AttributeError(f'Module {module_name!r} has no attr {class_name!r}') from None
 
 
 SPECIAL_IMPORTABLE: ta.AbstractSet[str] = frozenset([
@@ -65,46 +63,43 @@ def yield_importable(
         package_root: str,
         *,
         recursive: bool = False,
-        filter: ta.Optional[ta.Callable[[str], bool]] = None,
+        filter: ta.Callable[[str], bool] | None = None,  # noqa
         include_special: bool = False,
 ) -> ta.Iterator[str]:
-    def rec(dir):
-        if dir.split('.')[-1] == '__pycache__':
+    def rec(cur):
+        if cur.split('.')[-1] == '__pycache__':
             return
 
         try:
-            module = sys.modules[dir]
+            module = sys.modules[cur]
         except KeyError:
             try:
-                __import__(dir)
+                __import__(cur)
             except ImportError:
                 return
-            module = sys.modules[dir]
+            module = sys.modules[cur]
 
         # FIXME: pyox
         if getattr(module, '__file__', None) is None:
             return
 
-        for file in _pkg_resources().resource_listdir(dir, '.'):
-            if file.endswith('.py'):
-                if not (include_special or file not in SPECIAL_IMPORTABLE):
+        for file in importlib.resources.files(cur).iterdir():
+            if file.is_file() and file.name.endswith('.py'):
+                if not (include_special or file.name not in SPECIAL_IMPORTABLE):
                     continue
 
-                name = dir + '.' + file[:-3]
+                name = cur + '.' + file.name[:-3]
                 if filter is not None and not filter(name):
                     continue
 
                 yield name
 
-            elif recursive and '.' not in file:
-                name = dir + '.' + file
+            elif recursive and file.is_dir():
+                name = cur + '.' + file.name
                 if filter is not None and not filter(name):
                     continue
-
-                try:
+                with contextlib.suppress(ImportError, NotImplementedError):
                     yield from rec(name)
-                except (ImportError, NotImplementedError):
-                    pass
 
     yield from rec(package_root)
 
@@ -112,10 +107,10 @@ def yield_importable(
 def yield_import_all(
         package_root: str,
         *,
-        globals: ta.Optional[dict[str, ta.Any]] = None,
-        locals: ta.Optional[dict[str, ta.Any]] = None,
+        globals: dict[str, ta.Any] | None = None,  # noqa
+        locals: dict[str, ta.Any] | None = None,  # noqa
         recursive: bool = False,
-        filter: ta.Optional[ta.Callable[[str], bool]] = None,
+        filter: ta.Callable[[str], bool] | None = None,  # noqa
         include_special: bool = False,
 ) -> ta.Iterator[str]:
     for import_path in yield_importable(
@@ -132,7 +127,7 @@ def import_all(
         package_root: str,
         *,
         recursive: bool = False,
-        filter: ta.Optional[ta.Callable[[str], bool]] = None,
+        filter: ta.Callable[[str], bool] | None = None,  # noqa
         include_special: bool = False,
 ) -> None:
     for _ in yield_import_all(
@@ -144,7 +139,7 @@ def import_all(
         pass
 
 
-def try_import(spec: str) -> ta.Optional[types.ModuleType]:
+def try_import(spec: str) -> types.ModuleType | None:
     s = spec.lstrip('.')
     l = len(spec) - len(s)
     try:

omlish/lang/iterables.py

@@ -28,13 +28,13 @@ def exhaust(it: ta.Iterable[ta.Any]) -> None:
         pass
 
 
-def peek(vs: ta.Iterable[T]) -> ta.Tuple[T, ta.Iterator[T]]:
+def peek(vs: ta.Iterable[T]) -> tuple[T, ta.Iterator[T]]:
     it = iter(vs)
     v = next(it)
     return v, itertools.chain(iter((v,)), it)
 
 
-Rangeable: ta.TypeAlias = ta.Union[int, ta.Tuple[int], ta.Tuple[int, int], ta.Iterable[int]]
+Rangeable: ta.TypeAlias = int | tuple[int] | tuple[int, int] | ta.Iterable[int]
 
 
 def asrange(i: Rangeable) -> ta.Iterable[int]:

omlish/lang/maybes.py

@@ -63,6 +63,7 @@ class Maybe(abc.ABC, ta.Generic[T]):
 
 
 class _Maybe(Maybe[T], tuple):
+    __slots__ = ()
 
     @property
     def present(self) -> bool:
@@ -130,7 +131,7 @@ def empty() -> Maybe[T]:
     return _empty  # noqa
 
 
-def maybe(o: ta.Optional[T]) -> Maybe[T]:
+def maybe(o: T | None) -> Maybe[T]:
     if o is None:
         return _empty  # noqa
     return just(o)