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

omlish/lang/__init__.py

@@ -1,112 +1,172 @@
-from .cached import cached_function  # noqa
-from .cached import cached_property  # noqa
-from .classes import Abstract # noqa
-from .classes import Callable  # noqa
-from .classes import Descriptor  # noqa
-from .classes import Final  # noqa
-from .classes import FinalException  # noqa
-from .classes import LazySingleton  # noqa
-from .classes import Marker  # noqa
-from .classes import Namespace  # noqa
-from .classes import NoBool  # noqa
-from .classes import NotInstantiable  # noqa
-from .classes import NotPicklable  # noqa
-from .classes import PackageSealed  # noqa
-from .classes import Picklable  # noqa
-from .classes import Sealed  # noqa
-from .classes import SealedException  # noqa
-from .classes import SimpleMetaDict  # noqa
-from .classes import Singleton  # noqa
-from .classes import Virtual  # noqa
-from .classes import is_abstract # noqa
-from .classes import is_abstract_class # noqa
-from .classes import is_abstract_method # noqa
-from .classes import make_abstract  # noqa
-from .classes import no_bool  # noqa
-from .classes import virtual_check  # noqa
-from .clsdct import ClassDctFn  # noqa
-from .clsdct import cls_dct_fn  # noqa
-from .clsdct import get_caller_cls_dct  # noqa
-from .clsdct import is_possibly_cls_dct  # noqa
-from .cmp import Infinity  # noqa
-from .cmp import InfinityType  # noqa
-from .cmp import NegativeInfinity  # noqa
-from .cmp import NegativeInfinityType  # noqa
-from .cmp import cmp  # noqa
-from .contextmanagers import ContextManaged  # noqa
-from .contextmanagers import ContextWrapped  # noqa
-from .contextmanagers import DefaultLockable  # noqa
-from .contextmanagers import ExitStacked  # noqa
-from .contextmanagers import Lockable  # noqa
-from .contextmanagers import NOP_CONTEXT_MANAGED  # noqa
-from .contextmanagers import NOP_CONTEXT_MANAGER  # noqa
-from .contextmanagers import NopContextManaged  # noqa
-from .contextmanagers import NopContextManager  # noqa
-from .contextmanagers import a_defer  # noqa
-from .contextmanagers import attr_setting  # noqa
-from .contextmanagers import breakpoint_on_exception  # noqa
-from .contextmanagers import context_var_setting  # noqa
-from .contextmanagers import context_wrapped  # noqa
-from .contextmanagers import default_lock  # noqa
-from .contextmanagers import defer  # noqa
-from .contextmanagers import disposing  # noqa
-from .contextmanagers import maybe_managing  # noqa
-from .datetimes import months_ago  # noqa
-from .datetimes import parse_date  # noqa
-from .datetimes import parse_timedelta  # noqa
-from .datetimes import to_seconds  # noqa
-from .descriptors import AccessForbiddenException  # noqa
-from .descriptors import access_forbidden  # noqa
-from .descriptors import is_method_descriptor  # noqa
-from .descriptors import unwrap_method_descriptors  # noqa
-from .functions import VoidException  # noqa
-from .functions import constant  # noqa
-from .functions import identity  # noqa
-from .functions import is_lambda  # noqa
-from .functions import is_none  # noqa
-from .functions import is_not_none  # noqa
-from .functions import maybe_call  # noqa
-from .functions import raise_  # noqa
-from .functions import recurse  # noqa
-from .functions import ticking_timeout  # noqa
-from .functions import try_  # noqa
-from .functions import unwrap_func  # noqa
-from .functions import unwrap_func_with_partials  # noqa
-from .functions import void  # noqa
-from .imports import import_all  # noqa
-from .imports import import_module  # noqa
-from .imports import import_module_attr  # noqa
-from .imports import lazy_import  # noqa
-from .imports import proxy_import  # noqa
-from .imports import try_import  # noqa
-from .imports import yield_import_all  # noqa
-from .imports import yield_importable  # noqa
-from .iterables import BUILTIN_SCALAR_ITERABLE_TYPES  # noqa
-from .iterables import asrange  # noqa
-from .iterables import exhaust  # noqa
-from .iterables import ilen  # noqa
-from .iterables import peek  # noqa
-from .iterables import prodrange  # noqa
-from .iterables import take  # noqa
-from .maybes import Maybe  # noqa
-from .maybes import empty  # noqa
-from .maybes import just  # noqa
-from .maybes import maybe  # noqa
-from .objects import SimpleProxy  # noqa
-from .objects import arg_repr  # noqa
-from .objects import attr_repr  # noqa
-from .objects import new_type  # noqa
-from .objects import super_meta  # noqa
-from .strings import camel_case  # noqa
-from .strings import indent_lines  # noqa
-from .strings import is_dunder  # noqa
-from .strings import is_ident  # noqa
-from .strings import is_ident_cont  # noqa
-from .strings import is_ident_start  # noqa
-from .strings import is_sunder  # noqa
-from .strings import prefix_lines  # noqa
-from .strings import snake_case  # noqa
-from .typing import BytesLike  # noqa
-from .typing import protocol_check  # noqa
-from .typing import typed_lambda  # noqa
-from .typing import typed_partial  # noqa
+from .cached import (  # noqa
+    cached_function,
+    cached_property,
+)
+
+from .classes import (  # noqa
+    Abstract,
+    Callable,
+    Descriptor,
+    Final,
+    FinalError,
+    LazySingleton,
+    Marker,
+    Namespace,
+    NoBool,
+    NotInstantiable,
+    NotPicklable,
+    PackageSealed,
+    Picklable,
+    Sealed,
+    SealedError,
+    SimpleMetaDict,
+    Singleton,
+    Virtual,
+    is_abstract,
+    is_abstract_class,
+    is_abstract_method,
+    make_abstract,
+    no_bool,
+    virtual_check,
+)
+
+from .clsdct import (  # noqa
+    ClassDctFn,
+    cls_dct_fn,
+    get_caller_cls_dct,
+    is_possibly_cls_dct,
+)
+
+from .cmp import (  # noqa
+    Infinity,
+    InfinityType,
+    NegativeInfinity,
+    NegativeInfinityType,
+    cmp,
+)
+
+from .contextmanagers import (  # noqa
+    ContextManaged,
+    ContextWrapped,
+    DefaultLockable,
+    ExitStacked,
+    Lockable,
+    NOP_CONTEXT_MANAGED,
+    NOP_CONTEXT_MANAGER,
+    NopContextManaged,
+    NopContextManager,
+    a_defer,
+    attr_setting,
+    breakpoint_on_exception,
+    context_var_setting,
+    context_wrapped,
+    default_lock,
+    defer,
+    disposing,
+    maybe_managing,
+)
+
+from .datetimes import (  # noqa
+    months_ago,
+    parse_date,
+    parse_timedelta,
+    to_seconds,
+)
+
+from .descriptors import (  # noqa
+    AccessForbiddenError,
+    access_forbidden,
+    attr_property,
+    classonly,
+    is_method_descriptor,
+    item_property,
+    unwrap_method_descriptors,
+)
+
+from .exceptions import (  # noqa
+    Unreachable,
+)
+
+from .functions import (  # noqa
+    Args,
+    VoidError,
+    constant,
+    finally_,
+    identity,
+    is_lambda,
+    is_none,
+    is_not_none,
+    maybe_call,
+    periodically,
+    raise_,
+    raising,
+    recurse,
+    try_,
+    unwrap_func,
+    unwrap_func_with_partials,
+    void,
+)
+
+from .imports import (  # noqa
+    import_all,
+    import_module,
+    import_module_attr,
+    lazy_import,
+    proxy_import,
+    try_import,
+    yield_import_all,
+    yield_importable,
+)
+
+from .iterables import (  # noqa
+    BUILTIN_SCALAR_ITERABLE_TYPES,
+    asrange,
+    exhaust,
+    ilen,
+    peek,
+    prodrange,
+    take,
+)
+
+from .maybes import (  # noqa
+    Maybe,
+    empty,
+    just,
+    maybe,
+)
+
+from .objects import (  # noqa
+    SimpleProxy,
+    arg_repr,
+    attr_repr,
+    new_type,
+    opt_repr,
+    super_meta,
+)
+
+from .strings import (  # noqa
+    camel_case,
+    indent_lines,
+    is_dunder,
+    is_ident,
+    is_ident_cont,
+    is_ident_start,
+    is_sunder,
+    prefix_lines,
+    snake_case,
+)
+
+from .timeouts import (  # noqa
+    DeadlineTimeout,
+    InfiniteTimeout,
+    Timeout,
+    TimeoutLike,
+    timeout,
+)
+
+from .typing import (  # noqa
+    BytesLike,
+    protocol_check,
+    typed_lambda,
+    typed_partial,
+)

omlish/lang/cached.py

@@ -105,11 +105,11 @@ class _CachedFunction(ta.Generic[T]):
             opts: Opts = Opts(),
             keyer: ta.Callable[..., tuple] | None = None,
             values: ta.MutableMapping | None = None,
-            value_fn: ta.Optional[ta.Callable[P, T]] = None,
+            value_fn: ta.Callable[P, T] | None = None,
     ) -> None:
         super().__init__()
 
-        self._fn = fn
+        self._fn = (fn,)
         self._opts = opts
         self._keyer = keyer if keyer is not None else _make_cache_keyer(fn, simple=opts.simple_key)
 
@@ -118,6 +118,14 @@ class _CachedFunction(ta.Generic[T]):
         self._value_fn = value_fn if value_fn is not None else fn
         functools.update_wrapper(self, fn)
 
+    @property
+    def _fn(self):
+        return self.__fn
+
+    @_fn.setter
+    def _fn(self, x):
+        self.__fn = x
+
     def reset(self) -> None:
         self._values = {}
 
@@ -157,8 +165,8 @@ class _CachedFunctionDescriptor(_CachedFunction[T]):
             *,
             instance: ta.Any = None,
             owner: ta.Any = None,
-            name: ta.Optional[str] = None,
-            **kwargs
+            name: str | None = None,
+            **kwargs,
     ) -> None:
         super().__init__(fn, **kwargs)
 
@@ -173,7 +181,7 @@ class _CachedFunctionDescriptor(_CachedFunction[T]):
         if owner is self._owner and (instance is self._instance or scope is classmethod):
             return self
 
-        fn = self._fn
+        fn, = self._fn
         name = self._name
         bound_fn = fn.__get__(instance, owner)
         if self._bound_keyer is None:
@@ -199,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)
@@ -209,9 +217,6 @@ def cached_function(fn=None, **kwargs):
     return _CachedFunctionDescriptor(fn, scope, opts=opts)
 
 
-cached_function = cached_function
-
-
 ##
 
 
@@ -261,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

@@ -1,24 +1,35 @@
-from .abstract import Abstract # noqa
-from .abstract import is_abstract # noqa
-from .abstract import is_abstract_class # noqa
-from .abstract import is_abstract_method # noqa
-from .abstract import make_abstract  # noqa
-from .restrict import Final  # noqa
-from .restrict import FinalException  # noqa
-from .restrict import NoBool  # noqa
-from .restrict import NotInstantiable  # noqa
-from .restrict import NotPicklable  # noqa
-from .restrict import PackageSealed  # noqa
-from .restrict import Sealed  # noqa
-from .restrict import SealedException  # noqa
-from .restrict import no_bool  # noqa
-from .simple import LazySingleton  # noqa
-from .simple import Marker  # noqa
-from .simple import Namespace  # noqa
-from .simple import SimpleMetaDict  # noqa
-from .simple import Singleton  # noqa
-from .virtual import Callable  # noqa
-from .virtual import Descriptor  # noqa
-from .virtual import Picklable  # noqa
-from .virtual import Virtual  # noqa
-from .virtual import virtual_check  # noqa
+from .abstract import (  # noqa
+    Abstract,
+    is_abstract,
+    is_abstract_class,
+    is_abstract_method,
+    make_abstract,
+)
+
+from .restrict import (  # noqa
+    Final,
+    FinalError,
+    NoBool,
+    NotInstantiable,
+    NotPicklable,
+    PackageSealed,
+    Sealed,
+    SealedError,
+    no_bool,
+)
+
+from .simple import (  # noqa
+    LazySingleton,
+    Marker,
+    Namespace,
+    SimpleMetaDict,
+    Singleton,
+)
+
+from .virtual import (  # noqa
+    Callable,
+    Descriptor,
+    Picklable,
+    Virtual,
+    virtual_check,
+)

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:
@@ -48,7 +48,7 @@ class Abstract(abc.ABC):
             if ams:
                 raise TypeError(
                     f'Cannot subclass abstract class {cls.__name__} with abstract methods'
-                    f'{", ".join(map(str, sorted(ams)))}'
+                    f'{", ".join(map(str, sorted(ams)))}',
                 )
 
 

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: ta.Any, **kwargs: ta.Any) -> ta.NoReturn:  # noqa
         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

@@ -26,7 +26,7 @@ Namespace: type = _Namespace()  # type: ignore
 ##
 
 
-_MARKER_NAMESPACE_KEYS: ta.Optional[set[str]] = None
+_MARKER_NAMESPACE_KEYS: set[str] | None = None
 
 
 class _MarkerMeta(abc.ABCMeta):
@@ -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

@@ -37,7 +37,7 @@ def get_caller_cls_dct(offset: int = 0) -> ta.MutableMapping[str, ta.Any]:
 
 class ClassDctFn:
 
-    def __init__(self, fn: ta.Callable, offset: ta.Optional[int] = None, *, wrap=True) -> None:
+    def __init__(self, fn: ta.Callable, offset: int | None = None, *, wrap=True) -> None:
         super().__init__()
 
         self._fn = fn
@@ -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: