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

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/sys.py

@@ -0,0 +1,7 @@
+import sys
+
+
+def is_gil_enabled() -> bool:
+    if (fn := getattr(sys, '_is_gil_enabled', None)) is not None:
+        return fn()
+    return True

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,

omlish/math.py

@@ -66,7 +66,7 @@ class FixedWidthInt(int):
 
     MASK: ta.ClassVar[int]
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls) -> None:
         super().__init_subclass__()
 
         if not isinstance(cls.BITS, int):
@@ -82,13 +82,13 @@ class FixedWidthInt(int):
         cls.MASK = (1 << cls.BITS) - 1
 
     @classmethod
-    def clamp(cls, value):
+    def clamp(cls, value: int) -> int:
         return ((value - cls.MIN) & cls.MASK) + cls.MIN
 
-    def __new__(cls, value, *args, **kwargs):
-        return super().__new__(cls, cls.clamp(value))
+    def __new__(cls, value: int) -> 'FixedWidthInt':
+        return super().__new__(cls, cls.clamp(value))  # noqa
 
-    SCALAR_PROXY_METHODS = {
+    SCALAR_PROXY_METHODS = frozenset([
         '__abs__',
         '__add__',
         '__and__',
@@ -117,12 +117,12 @@ class FixedWidthInt(int):
         '__sub__',
         '__truediv__',
         '__xor__',
-    }
+    ])
 
-    TUPLE_PROXY_METHODS = {
+    TUPLE_PROXY_METHODS = frozenset([
         '__divmod__',
         '__rdivmod__',
-    }
+    ])
 
     for _proxy_name in SCALAR_PROXY_METHODS:
         locals()[_proxy_name] = _gen_scalar_proxy_method(_proxy_name)
@@ -130,7 +130,7 @@ class FixedWidthInt(int):
         locals()[_proxy_name] = _gen_tuple_proxy_method(_proxy_name)
     del _proxy_name
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'{self.__class__.__name__}({int(self)})'
 
 

omlish/reflect.py

@@ -21,7 +21,7 @@ else:
 
 _NoneType = types.NoneType  # type: ignore
 
-_NONE_TYPE_FROZENSET: ta.FrozenSet['Type'] = frozenset([_NoneType])
+_NONE_TYPE_FROZENSET: frozenset['Type'] = frozenset([_NoneType])
 
 
 _GenericAlias = ta._GenericAlias  # type: ignore  # noqa
@@ -99,7 +99,7 @@ Type = ta.Union[
 
 
 class Union(ta.NamedTuple):
-    args: ta.FrozenSet[Type]
+    args: frozenset[Type]
 
     @property
     def is_optional(self) -> bool:
@@ -121,7 +121,7 @@ class Generic(ta.NamedTuple):
     # params2: tuple[ta.TypeVar, ...]  # map[int, V] = (V,)     | map[T, T] = (T,)
     obj: ta.Any
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return (
             f'{self.__class__.__name__}('
             f'cls={self.cls.__name__}, '

omlish/sql/__init__.py

@@ -0,0 +1,9 @@
+from .asyncs import (  # noqa
+    AsyncConnection,
+    AsyncConnectionLike,
+    AsyncEngine,
+    AsyncEngineLike,
+    AsyncTransaction,
+    AsyncTransactionLike,
+    async_adapt,
+)

omlish/sql/asyncs.py

@@ -0,0 +1,148 @@
+"""
+TODO:
+ - Maysync impls?
+ - base Protocol so adapters and real sa impls can be used interchangeably (if in asyncio ctx)?
+"""
+import contextlib
+import typing as ta
+
+import sqlalchemy as sa
+import sqlalchemy.ext.asyncio as saa
+
+from .. import asyncs as au
+
+
+T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
+
+
+AsyncEngineLike = ta.Union[saa.AsyncEngine, 'AsyncEngine']
+AsyncConnectionLike = ta.Union[saa.AsyncConnection, 'AsyncConnection']
+AsyncTransactionLike = ta.Union[saa.AsyncTransaction, 'AsyncTransaction']
+
+
+class AsyncTransaction:
+    def __init__(self, underlying: saa.AsyncTransaction) -> None:
+        super().__init__()
+        self._underlying = underlying
+
+    @property
+    def underlying(self) -> saa.AsyncTransaction:
+        return self._underlying
+
+    ##
+
+    @au.mark_asyncio
+    async def close(self) -> None:
+        await au.from_asyncio(self._underlying.close)()
+
+    @au.mark_asyncio
+    async def rollback(self) -> None:
+        await au.from_asyncio(self._underlying.rollback)()
+
+    @au.mark_asyncio
+    async def commit(self) -> None:
+        await au.from_asyncio(self._underlying.commit)()
+
+
+class AsyncConnection:
+    def __init__(self, underlying: saa.AsyncConnection) -> None:
+        super().__init__()
+        self._underlying = underlying
+
+    @property
+    def underlying(self) -> saa.AsyncConnection:
+        return self._underlying
+
+    ##
+
+    @contextlib.asynccontextmanager
+    @au.mark_asyncio
+    async def begin(self) -> ta.AsyncIterator[AsyncTransaction]:
+        async with au.from_asyncio_context(self._underlying.begin()) as u:
+            yield AsyncTransaction(u)
+
+    @au.mark_asyncio
+    async def execute(
+            self,
+            statement: ta.Any,
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> sa.CursorResult[ta.Any]:
+        return await au.from_asyncio(self._underlying.execute)(statement, *args, **kwargs)
+
+    @au.mark_asyncio
+    async def run_sync(
+            self,
+            fn: ta.Callable[ta.Concatenate[sa.Connection, P], T],
+            *args: P.args,
+            **kwargs: P.kwargs,
+    ) -> T:
+        return await au.from_asyncio(self._underlying.run_sync)(fn, *args, **kwargs)
+
+
+class AsyncEngine:
+    def __init__(self, underlying: saa.AsyncEngine) -> None:
+        super().__init__()
+        self._underlying = underlying
+
+    @property
+    def underlying(self) -> saa.AsyncEngine:
+        return self._underlying
+
+    ##
+
+    @contextlib.asynccontextmanager
+    @au.mark_asyncio
+    async def connect(self) -> ta.AsyncIterator[AsyncConnection]:
+        async with au.from_asyncio_context(self._underlying.connect()) as u:
+            yield AsyncConnection(u)
+
+    @au.mark_asyncio
+    async def dispose(self, close: bool = True) -> None:
+        await au.from_asyncio(self._underlying.dispose)(close)
+
+
+##
+
+
+@ta.overload
+def async_adapt(obj: AsyncEngine) -> AsyncEngine:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: AsyncConnection) -> AsyncConnection:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: AsyncTransaction) -> AsyncTransaction:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: saa.AsyncEngine) -> AsyncEngine:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: saa.AsyncConnection) -> AsyncConnection:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: saa.AsyncTransaction) -> AsyncTransaction:
+    ...
+
+
+def async_adapt(obj: ta.Any) -> ta.Any:
+    if isinstance(obj, (AsyncEngine, AsyncConnection, AsyncTransaction)):
+        return obj
+    if isinstance(obj, saa.AsyncTransaction):
+        return AsyncTransaction(obj)
+    if isinstance(obj, saa.AsyncConnection):
+        return AsyncConnection(obj)
+    if isinstance(obj, saa.AsyncEngine):
+        return AsyncEngine(obj)
+    raise TypeError(obj)

omlish/stats.py

@@ -5,6 +5,7 @@ TODO:
 """
 import bisect
 import collections
+import contextlib
 import dataclasses as dc
 import math
 import operator
@@ -215,7 +216,7 @@ class Stats(ta.Sequence[float]):
         else:
             bins = [float(x) for x in bins]
             if self.min < bins[0]:
-                bins = [self.min] + bins
+                bins = [self.min, *bins]
 
         round_factor = 10.0 ** bin_digits
         bins = [math.floor(b * round_factor) / round_factor for b in bins]
@@ -251,7 +252,7 @@ class SamplingHistogram:
         sample_percentiles: list['SamplingHistogram.Percentile']
 
     DEFAULT_SIZE = 1000
-    DEFAULT_PERCENTILES = [0.5, 0.75, 0.9, 0.95, 0.99]
+    DEFAULT_PERCENTILES = (0.5, 0.75, 0.9, 0.95, 0.99)
 
     def __init__(
             self,
@@ -291,10 +292,8 @@ class SamplingHistogram:
 
         sample_pos = None
         if self._sample_pos_queue:
-            try:
+            with contextlib.suppress(IndexError):
                 sample_pos = self._sample_pos_queue.pop()
-            except IndexError:
-                pass
         if sample_pos is None:
             sample_pos = random.randrange(0, self._size)
         self._sample[sample_pos] = entry

omlish/term.py

@@ -208,7 +208,7 @@ BG24_RGB = ControlSequence(
     '24-Bit Background Color (RGB)')
 
 
-def main():
+def main() -> None:
     import sys
 
     sys.stdout.write(SGR(SGRs.RESET))