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

omlish/lang/cached.py

@@ -207,7 +207,7 @@ class _CachedFunctionDescriptor(_CachedFunction[T]):
         return bound
 
 
-def cached_function(fn=None, **kwargs):
+def cached_function(fn=None, **kwargs):  # noqa
     if fn is None:
         return functools.partial(cached_function, **kwargs)
     opts = _CachedFunction.Opts(**kwargs)
@@ -217,9 +217,6 @@ def cached_function(fn=None, **kwargs):
     return _CachedFunctionDescriptor(fn, scope, opts=opts)
 
 
-cached_function = cached_function
-
-
 ##
 
 
@@ -269,7 +266,7 @@ class _CachedProperty:
         raise TypeError(self._name)
 
 
-def cached_property(fn=None, **kwargs):
+def cached_property(fn=None, **kwargs):  # noqa
     if fn is None:
         return functools.partial(cached_property, **kwargs)
     return _CachedProperty(fn, **kwargs)

omlish/lang/classes/__init__.py

@@ -8,13 +8,13 @@ from .abstract import (  # noqa
 
 from .restrict import (  # noqa
     Final,
-    FinalException,
+    FinalError,
     NoBool,
     NotInstantiable,
     NotPicklable,
     PackageSealed,
     Sealed,
-    SealedException,
+    SealedError,
     no_bool,
 )
 

omlish/lang/classes/abstract.py

@@ -23,7 +23,7 @@ def make_abstract(obj: T) -> T:
         return obj
 
 
-class Abstract(abc.ABC):
+class Abstract(abc.ABC):  # noqa
     __slots__ = ()
 
     def __forceabstract__(self):
@@ -31,7 +31,7 @@ class Abstract(abc.ABC):
 
     setattr(__forceabstract__, '__isabstractmethod__', True)
 
-    def __init_subclass__(cls, **kwargs) -> None:
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         if Abstract in cls.__bases__:
             cls.__forceabstract__ = Abstract.__forceabstract__  # type: ignore
         else:

omlish/lang/classes/restrict.py

@@ -8,9 +8,9 @@ from .abstract import is_abstract
 ##
 
 
-class FinalException(TypeError):
+class FinalError(TypeError):
 
-    def __init__(self, _type: ta.Type) -> None:
+    def __init__(self, _type: type) -> None:
         super().__init__()
 
         self._type = _type
@@ -22,17 +22,17 @@ class FinalException(TypeError):
 class Final(Abstract):
     __slots__ = ()
 
-    def __init_subclass__(cls, **kwargs) -> None:
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 
         abstracts: set[ta.Any] = set()
         for base in cls.__bases__:
             if base is Abstract:
-                raise FinalException(base)
+                raise FinalError(base)
             elif base is Final:
                 continue
             elif Final in base.__mro__:
-                raise FinalException(base)
+                raise FinalError(base)
             else:
                 abstracts.update(getattr(base, '__abstractmethods__', []))
 
@@ -40,15 +40,15 @@ class Final(Abstract):
             try:
                 v = cls.__dict__[a]
             except KeyError:
-                raise FinalException(a)
+                raise FinalError(a) from None
             if is_abstract(v):
-                raise FinalException(a)
+                raise FinalError(a)
 
 
 ##
 
 
-class SealedException(TypeError):
+class SealedError(TypeError):
 
     def __init__(self, _type) -> None:
         super().__init__()
@@ -62,24 +62,24 @@ class SealedException(TypeError):
 class Sealed:
     __slots__ = ()
 
-    def __init_subclass__(cls, **kwargs) -> None:
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         for base in cls.__bases__:
             if base is not Abstract:
                 if Sealed in base.__bases__:
                     if cls.__module__ != base.__module__:
-                        raise SealedException(base)
+                        raise SealedError(base)
         super().__init_subclass__(**kwargs)
 
 
 class PackageSealed:
     __slots__ = ()
 
-    def __init_subclass__(cls, **kwargs) -> None:
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         for base in cls.__bases__:
             if base is not Abstract:
                 if PackageSealed in base.__bases__:
                     if cls.__module__.split('.')[:-1] != base.__module__.split('.')[:-1]:
-                        raise SealedException(base)
+                        raise SealedError(base)
         super().__init_subclass__(**kwargs)
 
 
@@ -89,7 +89,7 @@ class PackageSealed:
 class NotInstantiable(Abstract):
     __slots__ = ()
 
-    def __new__(cls, *args, **kwargs) -> ta.NoReturn:
+    def __new__(cls, *args, **kwargs):
         raise TypeError
 
 
@@ -133,5 +133,5 @@ class _NoBoolDescriptor:
         return self._fn(*args, **kwargs)
 
 
-def no_bool(fn):
+def no_bool(fn):  # noqa
     return _NoBoolDescriptor(fn)

omlish/lang/classes/simple.py

@@ -100,7 +100,7 @@ class Singleton:
     def __new__(cls):
         return cls.__dict__[_SINGLETON_INSTANCE_ATTR]
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
         _set_singleton_instance(super().__new__(cls))  # noqa
 

omlish/lang/classes/virtual.py

@@ -15,10 +15,10 @@ Ty = ta.TypeVar('Ty', bound=type)
 
 
 def _make_not_instantiable():
-    def __new__(cls, *args, **kwargs):
+    def __new__(cls, *args, **kwargs):  # noqa
         raise TypeError(cls)
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs):  # noqa
         raise TypeError(self)
 
     return {
@@ -49,7 +49,7 @@ class _VirtualMeta(abc.ABCMeta):
                 reqset -= set(mro_cls.__dict__)
             return reqset
 
-        def __subclasshook__(cls, subclass):
+        def __subclasshook__(cls, subclass):  # noqa
             if cls is not kls:
                 return super(kls, cls).__subclasshook__(subclass)  # type: ignore
             if get_missing_reqs(subclass):
@@ -117,11 +117,11 @@ class Callable(NotInstantiable, Final, ta.Generic[T]):
         raise TypeError
 
     @classmethod
-    def __instancecheck__(cls, instance):
+    def __instancecheck__(cls, instance: object) -> bool:
         return callable(instance)
 
     @classmethod
-    def __subclasscheck__(cls, subclass):
+    def __subclasscheck__(cls, subclass: type) -> bool:
         if not hasattr(subclass, '__call__'):
             return False
         call = subclass.__call__

omlish/lang/clsdct.py

@@ -60,7 +60,7 @@ class ClassDctFn:
         return self._fn(cls_dct, *args, **kwargs)
 
 
-def cls_dct_fn(offset=1, *, wrap=True):
+def cls_dct_fn(offset=1, *, wrap=True):  # noqa
     def outer(fn):
         return ClassDctFn(fn, offset, wrap=wrap)
 

omlish/lang/cmp.py

@@ -18,7 +18,7 @@ class InfinityType:
     def __le__(self, other: ta.Any) -> bool:
         return False
 
-    def __eq__(self, other: ta.Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         return isinstance(other, self.__class__)
 
     def __gt__(self, other: ta.Any) -> bool:
@@ -47,7 +47,7 @@ class NegativeInfinityType:
     def __le__(self, other: ta.Any) -> bool:
         return True
 
-    def __eq__(self, other: ta.Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         return isinstance(other, self.__class__)
 
     def __gt__(self, other: ta.Any) -> bool:

omlish/lang/contextmanagers.py

@@ -19,8 +19,8 @@ class ContextManaged:
 
     def __exit__(
             self,
-            exc_type: ta.Type[Exception] | None,
-            exc_val: Exception | None,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
             exc_tb: types.TracebackType | None,
     ) -> bool | None:
         return None
@@ -28,7 +28,7 @@ class ContextManaged:
 
 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):
@@ -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,8 +146,8 @@ class ExitStacked:
 
     def __exit__(
             self,
-            exc_type: ta.Type[Exception] | None,
-            exc_val: Exception | None,
+            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)
@@ -212,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):
@@ -228,7 +226,7 @@ class ContextWrapped:
             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
@@ -238,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/descriptors.py

@@ -1,4 +1,5 @@
 import functools
+import operator
 import typing as ta
 
 
@@ -8,6 +9,17 @@ T = ta.TypeVar('T')
 ##
 
 
+def attr_property(n: str):
+    return property(operator.attrgetter(n))
+
+
+def item_property(n: str):
+    return property(operator.itemgetter(n))
+
+
+##
+
+
 BUILTIN_METHOD_DESCRIPTORS = (classmethod, staticmethod)
 
 
@@ -28,7 +40,7 @@ def unwrap_method_descriptors(fn: ta.Callable) -> ta.Callable:
 ##
 
 
-class AccessForbiddenException(Exception):
+class AccessForbiddenError(Exception):
 
     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
@@ -42,17 +54,17 @@ class AccessForbiddenDescriptor:
 
         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()
 
 

omlish/lang/exceptions.py

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

omlish/lang/functions.py

@@ -7,14 +7,21 @@ 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:
     l = lambda: 0
     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)
@@ -24,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
@@ -41,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_(
+        fn: ta.Callable[P, T],
         exc: type[Exception] | ta.Iterable[type[Exception]] = Exception,
         default: T | None = None,
-) -> ta.Callable[..., T]:
-    def outer(fn):
-        def inner(*args, **kwargs):
-            try:
-                return fn(*args, **kwargs)
-            except exct:
-                return default
-
-        return inner
+) -> 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 inner
 
-    return rec(*args, **kwargs)
+
+##
 
 
 def identity(obj: T) -> T:
@@ -98,21 +128,24 @@ 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 __init_subclass__(cls, **kwargs):
-        raise VoidException
 
+def void(*args: ta.Any, **kwargs: ta.Any) -> ta.NoReturn:
+    raise VoidError
 
-def void(*args, **kwargs) -> ta.NoReturn:
-    raise VoidException
+
+##
 
 
 _MISSING = object()
@@ -142,6 +175,9 @@ def periodically(
     return inner  # type: ignore
 
 
+##
+
+
 @dc.dataclass(init=False)
 class Args:
     args: ta.Sequence[ta.Any]

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
@@ -17,7 +18,7 @@ def lazy_import(name: str, package: str | None = None) -> ta.Callable[[], ta.Any
 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: str | None = None) -> types.ModuleType:
 ##
 
 
-_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.Callable[[str], bool] | None = 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: dict[str, ta.Any] | None = None,
-        locals: dict[str, ta.Any] | None = None,
+        globals: dict[str, ta.Any] | None = None,  # noqa
+        locals: dict[str, ta.Any] | None = None,  # noqa
         recursive: bool = False,
-        filter: ta.Callable[[str], bool] | None = 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.Callable[[str], bool] | None = None,
+        filter: ta.Callable[[str], bool] | None = None,  # noqa
         include_special: bool = False,
 ) -> None:
     for _ in yield_import_all(

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 = 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: