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

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:

omlish/lang/objects.py

@@ -9,18 +9,22 @@ T = ta.TypeVar('T')
 
 
 def attr_repr(obj: ta.Any, *attrs: str) -> str:
-    return '%s(%s)' % (
-        type(obj).__name__,
-        ', '.join('%s=%r' % (attr, getattr(obj, attr)) for attr in attrs))
+    return f'{type(obj).__name__}({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
 
 
 def arg_repr(*args, **kwargs) -> str:
     return ', '.join(*(
         list(map(repr, args)) +
-        [f'{k}={repr(v)}' for k, v in kwargs.items()]
+        [f'{k}={v!r}' for k, v in kwargs.items()]
     ))
 
 
+def opt_repr(obj: ta.Any) -> str | None:
+    if obj is None:
+        return None
+    return repr(obj)
+
+
 ##
 
 
@@ -29,7 +33,7 @@ def new_type(
         bases: ta.Sequence[ta.Any],
         namespace: ta.Mapping[str, ta.Any],
         **kwargs,
-) -> ta.Type:
+) -> type:
     return types.new_class(
         name,
         tuple(bases),
@@ -40,12 +44,12 @@ def new_type(
 
 def super_meta(
         super_meta: ta.Any,
-        meta: ta.Type,
+        meta: type,
         name: str,
         bases: ta.Sequence[ta.Any],
         namespace: ta.MutableMapping[str, ta.Any],
         **kwargs,
-) -> ta.Type:
+) -> type:
     """Per types.new_class"""
     resolved_bases = types.resolve_bases(bases)
     if resolved_bases is not bases:
@@ -75,19 +79,21 @@ class SimpleProxy(ta.Generic[T]):
             if instance is None:
                 return self
             setattr(object.__getattribute__(instance, '__wrapped__'), self._attr, value)
+            return None
 
         def __delete__(self, instance):
             if instance is None:
                 return self
             delattr(object.__getattribute__(instance, '__wrapped__'), self._attr)
+            return None
 
-    __wrapped_attrs__: ta.Iterable[str] = set()
+    __wrapped_attrs__: ta.ClassVar[ta.Iterable[str]] = ()
 
     def __init__(self, wrapped: T) -> None:
         super().__init__()
         object.__setattr__(self, '__wrapped__', wrapped)
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 
         for attr in cls.__wrapped_attrs__:

omlish/lang/resolving.py

@@ -45,6 +45,6 @@ def get_fqcn_cls(fqcn: str, *, nocheck: bool = False) -> type:
 
 
 class Resolvable:
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
         get_cls_fqcn(cls, nocheck=True)

omlish/lang/strings.py

@@ -22,7 +22,7 @@ def camel_case(name: str) -> str:
 
 def snake_case(name: str) -> str:
     uppers: list[int | None] = [i for i, c in enumerate(name) if c.isupper()]
-    return '_'.join([name[l:r].lower() for l, r in zip([None] + uppers, uppers + [None])]).strip('_')
+    return '_'.join([name[l:r].lower() for l, r in zip([None, *uppers], [*uppers, None])]).strip('_')
 
 
 def is_dunder(name: str) -> bool:

omlish/lang/typing.py

@@ -37,13 +37,13 @@ def _update_wrapper_no_anns(wrapper, wrapped):
     return wrapper
 
 
-def typed_lambda(ret=_MISSING, **kw):
+def typed_lambda(ret=_MISSING, **kw):  # noqa
     def inner(fn):
         ns = {}
         ns['__fn'] = fn
         proto = ['def __lam(']
         call = ['return __fn(']
-        pkw = {k: v for k, v in kw.items()}
+        pkw = dict(kw)
         for i, (n, t) in enumerate(pkw.items()):
             if i:
                 call.append(', ')
@@ -69,7 +69,7 @@ def typed_lambda(ret=_MISSING, **kw):
     return inner
 
 
-def typed_partial(obj, **kw):
+def typed_partial(obj, **kw):  # noqa
     for k in kw:
         if k.startswith('__'):
             raise NameError(k)

omlish/libc.py

@@ -1,3 +1,7 @@
+# ruff: noqa: ANN201
+# ruff: noqa: N801
+# ruff: noqa: N802
+
 import ctypes as ct
 import errno
 import platform
@@ -37,14 +41,14 @@ def lasterr() -> tuple[int, str]:
 
 
 # int raise(int sig);
-libc._raise = libc['raise']  # type: ignore
-libc._raise.restype = ct.c_int
-libc._raise.argtypes = [ct.c_int]
-_raise = libc._raise
+libc._raise = libc['raise']  # type: ignore  # noqa
+libc._raise.restype = ct.c_int  # noqa
+libc._raise.argtypes = [ct.c_int]  # noqa
+_raise = libc._raise  # noqa
 
 
 def sigtrap() -> None:
-    libc._raise(signal.SIGTRAP)
+    libc._raise(signal.SIGTRAP)  # noqa
 
 
 ##

omlish/logs/_abc.py

@@ -1,3 +1,7 @@
+# ruff: noqa: A002
+# ruff: noqa: N802
+# ruff: noqa: N815
+
 import types
 import typing as ta
 
@@ -181,7 +185,7 @@ class Logger(Filterer, ta.Protocol):
 
     def log(self, level: Level, msg: str, *args: ta.Any, **kwargs: ta.Any) -> None: ...
 
-    def findCaller(self, stack_info: bool = False, stacklevel: int = 1) -> Caller: ...  #
+    def findCaller(self, stack_info: bool = False, stacklevel: int = 1) -> Caller: ...
 
     def makeRecord(
         self,

omlish/logs/filters.py

@@ -1,3 +1,5 @@
+# ruff: noqa: ANN201
+
 import logging
 import threading
 

omlish/logs/formatters.py

@@ -1,5 +1,9 @@
+# ruff: noqa: ANN201
+# ruff: noqa: N802
+
 import datetime
 import logging
+import typing as ta
 
 from .. import json
 from .. import term
@@ -20,7 +24,7 @@ class StandardLogFormatter(logging.Formatter):
 
 class ColorLogFormatter(StandardLogFormatter):
 
-    LEVEL_COLORS = {
+    LEVEL_COLORS: ta.Mapping[int, term.SGRs.FG] = {
         logging.WARNING: term.SGRs.FG.BRIGHT_YELLOW,
         logging.ERROR: term.SGRs.FG.BRIGHT_RED,
         logging.CRITICAL: term.SGRs.FG.BRIGHT_RED,
@@ -39,7 +43,7 @@ class ColorLogFormatter(StandardLogFormatter):
 
 class JsonLogFormatter(logging.Formatter):
 
-    KEYS = {
+    KEYS: ta.Mapping[str, bool] = {
         'name': False,
         'msg': False,
         'args': False,

omlish/logs/utils.py

@@ -5,7 +5,7 @@ import logging
 log = logging.getLogger(__name__)
 
 
-def error_logging(log=log):
+def error_logging(log=log):  # noqa
     def outer(fn):
         @functools.wraps(fn)
         def inner(*args, **kwargs):

omlish/marshal/base.py

@@ -81,7 +81,7 @@ from .. import check
 from .. import collections as col
 from .. import lang
 from .. import reflect as rfl
-from .exceptions import UnhandledTypeException
+from .exceptions import UnhandledTypeError
 from .factories import Factory
 from .factories import RecursiveTypeFactory
 from .registries import Registry
@@ -152,7 +152,7 @@ class MarshalContext(BaseContext, lang.Final):
         rty = rfl.type_(o)
         if (m := check.not_none(self.factory)(self, rty)) is not None:  # noqa
             return m
-        raise UnhandledTypeException(rty)
+        raise UnhandledTypeError(rty)
 
 
 @dc.dataclass(frozen=True)
@@ -163,7 +163,7 @@ class UnmarshalContext(BaseContext, lang.Final):
         rty = rfl.type_(o)
         if (m := check.not_none(self.factory)(self, rty)) is not None:  # noqa
             return m
-        raise UnhandledTypeException(rty)
+        raise UnhandledTypeError(rty)
 
 
 ##

omlish/marshal/exceptions.py

@@ -1,7 +1,7 @@
 from .. import reflect as rfl
 
 
-class UnhandledTypeException(Exception):
+class UnhandledTypeError(Exception):
     @property
     def rty(self) -> rfl.Type:
         return self.args[0]

omlish/marshal/global_.py

@@ -1,8 +1,14 @@
-from .registries import Registry
-from .standard import new_standard_marshaler_factory
+import typing as ta
+
 from .base import MarshalContext
 from .base import UnmarshalContext
+from .registries import Registry
+from .standard import new_standard_marshaler_factory
 from .standard import new_standard_unmarshaler_factory
+from .values import Value
+
+
+T = ta.TypeVar('T')
 
 
 ##
@@ -17,7 +23,7 @@ GLOBAL_REGISTRY = Registry()
 GLOBAL_MARSHALER_FACTORY = new_standard_marshaler_factory()
 
 
-def marshal(obj, ty=None, **kwargs):
+def marshal(obj: ta.Any, ty: type | None = None, **kwargs: ta.Any) -> Value:
     mc = MarshalContext(GLOBAL_REGISTRY, factory=GLOBAL_MARSHALER_FACTORY, **kwargs)
     return mc.make(ty if ty is not None else type(obj)).marshal(mc, obj)
 
@@ -28,6 +34,6 @@ def marshal(obj, ty=None, **kwargs):
 GLOBAL_UNMARSHALER_FACTORY = new_standard_unmarshaler_factory()
 
 
-def unmarshal(v, ty, **kwargs):
+def unmarshal(v: Value, ty: type[T], **kwargs: ta.Any) -> T:
     uc = UnmarshalContext(GLOBAL_REGISTRY, factory=GLOBAL_UNMARSHALER_FACTORY, **kwargs)
     return uc.make(ty).unmarshal(uc, v)

omlish/marshal/objects.py

@@ -98,8 +98,7 @@ class ObjectUnmarshaler(Unmarshaler):
                 if ukf is not None:
                     ukf[ks] = mv  # FIXME: unmarshal?
                     continue
-                else:
-                    raise
+                raise
             if fi.name in kw:
                 raise KeyError(f'Duplicate keys for field {fi.name!r}: {ks!r}')
             kw[fi.name] = u.unmarshal(ctx, mv)

omlish/marshal/registries.py

@@ -1,13 +1,13 @@
-import abc
 import dataclasses as dc
 import threading
 import typing as ta
 
 from .. import check
+from .. import lang
 from .. import reflect as rfl
 
 
-class RegistryItem(abc.ABC):
+class RegistryItem(lang.Abstract):
     pass
 
 
@@ -31,7 +31,7 @@ class Registry:
         super().__init__()
         self._mtx = threading.Lock()
         self._dct: dict[rfl.Type, _TypeRegistry] = {}
-        self._ps: ta.Sequence['Registry'] = []
+        self._ps: ta.Sequence[Registry] = []
 
     def register(self, rty: rfl.Type, *items: RegistryItem) -> 'Registry':
         check.isinstance(rty, rfl.TYPES)

omlish/marshal/utils.py

@@ -19,5 +19,5 @@ class _Proxy(ta.Generic[T]):
         self.__obj = obj
 
     @classmethod
-    def _new(cls):
-        return (p := cls()), p._set_obj
+    def _new(cls) -> tuple[ta.Any, ta.Callable[[ta.Any], None]]:
+        return (p := cls()), p._set_obj  # noqa

omlish/marshal/values.py

@@ -13,7 +13,7 @@ Any
 import typing as ta
 
 
-Value = ta.Union[
+Value = ta.Union[  # noqa
     None,
 
     bool,