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

omlish/iterators.py

@@ -22,66 +22,61 @@ class PeekIterator(ta.Iterator[T]):
 
     _item: T
 
-    def __iter__(self) -> ta.Iterator[T]:
+    def __iter__(self) -> ta.Self:
         return self
 
     @property
     def done(self) -> bool:
         try:
             self.peek()
-            return False
         except StopIteration:
             return True
+        else:
+            return False
 
     def __next__(self) -> T:
         if self._next_item is not _MISSING:
             self._item = ta.cast(T, self._next_item)
             self._next_item = _MISSING
         else:
-            try:
-                self._item = next(self._it)
-            except StopIteration:
-                raise
+            self._item = next(self._it)
         self._pos += 1
         return self._item
 
     def peek(self) -> T:
         if self._next_item is not _MISSING:
             return ta.cast(T, self._next_item)
-        try:
-            self._next_item = next(self._it)
-        except StopIteration:
-            raise
+        self._next_item = next(self._it)
         return self._next_item
 
     def next_peek(self) -> T:
         next(self)
         return self.peek()
 
-    def takewhile(self, fn):
+    def takewhile(self, fn: ta.Callable[[T], bool]) -> ta.Iterator[T]:
         while fn(self.peek()):
             yield next(self)
 
-    def skipwhile(self, fn):
+    def skipwhile(self, fn: ta.Callable[[T], bool]) -> None:
         while fn(self.peek()):
             next(self)
 
-    def takeuntil(self, fn):
+    def takeuntil(self, fn: ta.Callable[[T], bool]) -> ta.Iterator[T]:
         return self.takewhile(lambda e: not fn(e))
 
-    def skipuntil(self, fn):
+    def skipuntil(self, fn: ta.Callable[[T], bool]) -> None:
         self.skipwhile(lambda e: not fn(e))
 
-    def takethrough(self, pos):
+    def takethrough(self, pos: int) -> ta.Iterator[T]:
         return self.takewhile(lambda _: self._pos < pos)
 
-    def skipthrough(self, pos):
+    def skipthrough(self, pos: int) -> None:
         self.skipwhile(lambda _: self._pos < pos)
 
-    def taketo(self, pos):
+    def taketo(self, pos: int) -> ta.Iterator[T]:
         return self.takethrough(pos - 1)
 
-    def skipto(self, pos):
+    def skipto(self, pos: int) -> None:
         self.skipthrough(pos - 1)
 
 
@@ -90,7 +85,7 @@ class ProxyIterator(ta.Iterator[T]):
     def __init__(self, fn: ta.Callable[[], T]) -> None:
         self._fn = fn
 
-    def __iter__(self) -> ta.Iterator[T]:
+    def __iter__(self) -> ta.Self:
         return self
 
     def __next__(self) -> T:
@@ -103,9 +98,9 @@ class PrefetchIterator(ta.Iterator[T]):
         super().__init__()
 
         self._fn = fn
-        self._deque: ta.Deque[T] = collections.deque()
+        self._deque: collections.deque[T] = collections.deque()
 
-    def __iter__(self) -> ta.Iterator[T]:
+    def __iter__(self) -> ta.Self:
         return self
 
     def push(self, item) -> None:
@@ -116,7 +111,7 @@ class PrefetchIterator(ta.Iterator[T]):
             return self._deque.popleft()
         except IndexError:
             if self._fn is None:
-                raise StopIteration
+                raise StopIteration from None
         return self._fn()
 
 
@@ -126,9 +121,9 @@ class RetainIterator(ta.Iterator[T]):
         super().__init__()
 
         self._fn = fn
-        self._deque: ta.Deque[T] = collections.deque()
+        self._deque: collections.deque[T] = collections.deque()
 
-    def __iter__(self) -> ta.Iterator[T]:
+    def __iter__(self) -> ta.Self:
         return self
 
     def pop(self) -> None:

omlish/json.py

@@ -1,5 +1,6 @@
 import functools
 import json as _json
+import typing as ta
 
 
 dump = _json.dump
@@ -15,25 +16,25 @@ loads = _json.loads
 
 PRETTY_INDENT = 2
 
-PRETTY_KWARGS = dict(
+PRETTY_KWARGS: ta.Mapping[str, ta.Any] = dict(
     indent=PRETTY_INDENT,
 )
 
-dump_pretty = functools.partial(dump, **PRETTY_KWARGS)
-dumps_pretty = functools.partial(dumps, **PRETTY_KWARGS)
+dump_pretty: ta.Callable[..., bytes] = functools.partial(dump, **PRETTY_KWARGS)  # type: ignore
+dumps_pretty: ta.Callable[..., str] = functools.partial(dumps, **PRETTY_KWARGS)
 
 ##
 
 
 COMPACT_SEPARATORS = (',', ':')
 
-COMPACT_KWARGS = dict(
+COMPACT_KWARGS: ta.Mapping[str, ta.Any] = dict(
     indent=0,
     separators=COMPACT_SEPARATORS,
 )
 
-dump_compact = functools.partial(dump, **COMPACT_KWARGS)
-dumps_compact = functools.partial(dumps, **COMPACT_KWARGS)
+dump_compact: ta.Callable[..., bytes] = functools.partial(dump, **COMPACT_KWARGS)  # type: ignore
+dumps_compact: ta.Callable[..., str] = functools.partial(dumps, **COMPACT_KWARGS)
 
 
 ##

omlish/lang/__init__.py

@@ -8,7 +8,7 @@ from .classes import (  # noqa
     Callable,
     Descriptor,
     Final,
-    FinalException,
+    FinalError,
     LazySingleton,
     Marker,
     Namespace,
@@ -18,7 +18,7 @@ from .classes import (  # noqa
     PackageSealed,
     Picklable,
     Sealed,
-    SealedException,
+    SealedError,
     SimpleMetaDict,
     Singleton,
     Virtual,
@@ -74,10 +74,12 @@ from .datetimes import (  # noqa
 )
 
 from .descriptors import (  # noqa
-    AccessForbiddenException,
+    AccessForbiddenError,
     access_forbidden,
+    attr_property,
     classonly,
     is_method_descriptor,
+    item_property,
     unwrap_method_descriptors,
 )
 
@@ -87,8 +89,9 @@ from .exceptions import (  # noqa
 
 from .functions import (  # noqa
     Args,
-    VoidException,
+    VoidError,
     constant,
+    finally_,
     identity,
     is_lambda,
     is_none,
@@ -96,6 +99,7 @@ from .functions import (  # noqa
     maybe_call,
     periodically,
     raise_,
+    raising,
     recurse,
     try_,
     unwrap_func,
@@ -136,6 +140,7 @@ from .objects import (  # noqa
     arg_repr,
     attr_repr,
     new_type,
+    opt_repr,
     super_meta,
 )
 

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

@@ -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