omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/asyncs/bridge.py

@@ -1,359 +0,0 @@
-"""
-A system for bridging sync and async code. Supports nesting / reentrancy. Robust, but not the most efficient
-implementation - its primary usecase are heavy and init-time ops like lock management and connection establishment, not
-so much for packet-level ops.
-
-==
-
-The code is written in a very dumb, simple, explicit style to keep the bookkeeping center-stage and front-of-mind. To
-quote kubernetes:
-
-  https://github.com/kubernetes/kubernetes/blob/60c4c2b2521fb454ce69dee737e3eb91a25e0535/pkg/controller/volume/persistentvolume/pv_controller.go#L60-L63
-
-  ==================================================================
-  PLEASE DO NOT ATTEMPT TO SIMPLIFY THIS CODE.
-  KEEP THE SPACE SHUTTLE FLYING.
-  ==================================================================
-
-==
-
-TODO:
- - reuse greenlet if nested somehow?
- - test cancel
-
-See:
- - https://github.com/sqlalchemy/sqlalchemy/blob/21ea01eebe0350ad1185c7288dca61f363ebd2fe/lib/sqlalchemy/util/concurrency.py
-   - ( https://gist.github.com/snaury/202bf4f22c41ca34e56297bae5f33fef )
-   - Baked into sqlalchemy and hard-bound to asyncio.
- - https://github.com/oremanj/greenback/blob/ca69b023a9b7b58b715f3b1d78fc116e788a2c9f/greenback/_impl.py
-   - ( https://gist.github.com/oremanj/f18ef3e55b9487c2e93eee42232583f2 )
-   - Similar to this, but does horrible things with ctypes and is hard-bound to greenlet.
- - https://github.com/fastapi/asyncer/blob/2a4b8ef2540ec687af13d3f361c4ed0cf0cb624d/asyncer/_main.py
- - https://github.com/django/asgiref/blob/05ae3eee3fae4005ae4cfb0bb22d281725fabade/asgiref/sync.py
-   - Both are much heavier weight and hard-bound to threads.
-"""  # noqa
-import functools  # noqa
-import itertools
-import sys  # noqa
-import types
-import typing as ta
-import weakref
-
-from .. import check
-from .. import lang
-from .. import sync
-from ..concurrent import threadlets
-
-
-if ta.TYPE_CHECKING:
-    import asyncio
-
-    from . import anyio as aiu
-
-else:
-    asyncio = lang.proxy_import('asyncio')
-
-    aiu = lang.proxy_import('.anyio', __package__)
-
-
-T = ta.TypeVar('T')
-
-
-##
-
-
-def trivial_s_to_a(fn):
-    async def inner(*args, **kwargs):
-        return fn(*args, **kwargs)
-    return inner
-
-
-def trivial_a_to_s(fn):
-    def inner(*args, **kwargs):
-        return lang.sync_await(fn(*args, **kwargs))
-    return inner
-
-
-##
-# https://gist.github.com/snaury/202bf4f22c41ca34e56297bae5f33fef
-
-
-_THREADLETS_IMPL = threadlets.GreenletThreadlets
-# from ..concurrent.tests.real import RealThreadlets
-# _THREADLETS_IMPL = RealThreadlets
-
-_THREADLETS = sync.LazyFn(lambda: _THREADLETS_IMPL())
-
-
-def _threadlets() -> threadlets.Threadlets:
-    return _THREADLETS.get()
-
-
-#
-
-
-class BridgeAwaitRequiredError(Exception):
-    pass
-
-
-class MissingBridgeThreadletError(Exception):
-    pass
-
-
-class UnexpectedBridgeNestingError(Exception):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        # breakpoint()
-
-
-#
-
-
-_DEBUG_PRINT: ta.Callable[..., None] | None = None
-# _DEBUG_PRINT = functools.partial(print, file=sys.stderr)  # noqa
-
-_TRACK_TRANSITION_OBJS = False
-
-
-#
-
-
-_BRIDGE_TRANSITIONS_SEQ = itertools.count()
-
-
-class _BridgeTransition(ta.NamedTuple):
-    seq: int
-    a_to_s: bool
-
-    obj_cls: type
-    obj_id: int
-
-    obj: ta.Any
-
-
-def _make_transition(seq: int, a_to_s: bool, obj: ta.Any) -> _BridgeTransition:
-    return _BridgeTransition(seq, a_to_s, obj.__class__, id(obj), (obj if _TRACK_TRANSITION_OBJS else None))
-
-
-_BRIDGED_TASKS: ta.MutableMapping[ta.Any, list[_BridgeTransition]] = weakref.WeakKeyDictionary()
-
-_BRIDGE_THREADLET_ATTR = f'__{__package__.replace(".", "__")}__bridge_threadlet__'
-
-
-def _push_transition(a_to_s: bool, l: list[_BridgeTransition], t: _BridgeTransition) -> _BridgeTransition:
-    l.append(t)
-    if _DEBUG_PRINT:
-        _DEBUG_PRINT(f'_push_transition: {a_to_s=} {id(l)=} {t=}')
-    return t
-
-
-def _pop_transition(a_to_s: bool, l: list[_BridgeTransition]) -> _BridgeTransition:
-    t = l.pop()
-    if _DEBUG_PRINT:
-        _DEBUG_PRINT(f'_pop_transition: {a_to_s=} {id(l)=} {t=}')
-    return t
-
-
-def _get_transitions() -> list[_BridgeTransition]:
-    l: list[_BridgeTransition] = []
-
-    if (t := aiu.get_current_backend_task()) is not None:
-        try:
-            tl = _BRIDGED_TASKS[t]
-        except KeyError:
-            pass
-        else:
-            l.extend(tl)
-
-    g = _threadlets().get_current()
-    try:
-        gl = getattr(g.underlying, _BRIDGE_THREADLET_ATTR)
-    except AttributeError:
-        pass
-    else:
-        l.extend(gl)
-
-    l.sort(key=lambda t: (t.seq, t.a_to_s))
-    return l
-
-
-def is_in_bridge() -> bool:
-    if _DEBUG_PRINT:
-        _DEBUG_PRINT(_get_transitions())
-
-    if (t := aiu.get_current_backend_task()) is not None:
-        try:
-            tl = _BRIDGED_TASKS[t]
-        except KeyError:
-            last_t = None
-        else:
-            if tl:
-                last_t = tl[-1]
-            else:
-                last_t = None
-    else:
-        last_t = None
-
-    g = _threadlets().get_current()
-    try:
-        gl = getattr(g.underlying, _BRIDGE_THREADLET_ATTR)
-    except AttributeError:
-        last_g = None
-    else:
-        if gl:
-            last_g = gl[-1]
-        else:
-            last_g = None
-
-    if last_t is None:
-        if last_g is None:
-            return False
-        o = last_g
-    else:  # noqa
-        if last_g is None or last_g.seq < last_t.seq:
-            o = last_t
-        else:
-            o = last_g
-
-    in_a = (t is not None)
-
-    if _DEBUG_PRINT:
-        _DEBUG_PRINT(f'{o.a_to_s=} {in_a=}')
-
-    return in_a != o.a_to_s
-
-
-def _safe_cancel_awaitable(awaitable: ta.Awaitable[ta.Any]) -> None:
-    # https://docs.python.org/3/reference/datamodel.html#coroutine.close
-    if asyncio.iscoroutine(awaitable):
-        awaitable.close()  # noqa
-
-
-def s_to_a_await(awaitable: ta.Awaitable[T]) -> T:
-    g = _threadlets().get_current()
-
-    if not getattr(g.underlying, _BRIDGE_THREADLET_ATTR, False):
-        _safe_cancel_awaitable(awaitable)
-        raise MissingBridgeThreadletError
-
-    return check.not_none(g.parent).switch(awaitable)
-
-
-def s_to_a(fn, *, require_await=False):
-    @types.coroutine
-    def outer(*args, **kwargs):
-        def inner():
-            try:
-                return fn(*args, **kwargs)
-            finally:
-                if (gl2 := getattr(g.underlying, _BRIDGE_THREADLET_ATTR)) is not gl:  # noqa
-                    raise UnexpectedBridgeNestingError
-                if (cur_g := _pop_transition(False, gl)) is not added_g:  # noqa
-                    raise UnexpectedBridgeNestingError
-                if gl:
-                    raise UnexpectedBridgeNestingError
-
-        seq = next(_BRIDGE_TRANSITIONS_SEQ)
-
-        g = _threadlets().spawn(inner)
-        setattr(g.underlying, _BRIDGE_THREADLET_ATTR, gl := [])  # type: ignore
-        added_g = _push_transition(False, gl, _make_transition(seq, False, g))
-
-        if (t := aiu.get_current_backend_task()) is not None:
-            try:
-                tl = _BRIDGED_TASKS[t]
-            except KeyError:
-                tl = _BRIDGED_TASKS[t] = []
-            added_t = _push_transition(False, tl, _make_transition(seq, False, g))
-
-        try:
-            result: ta.Any = g.switch()
-            switch_occurred = False
-            while not g.dead:
-                switch_occurred = True
-                try:
-                    value = yield result
-                except BaseException as e:  # noqa
-                    result = g.throw(e)
-                else:
-                    result = g.switch(value)
-
-            if require_await and not switch_occurred:
-                raise BridgeAwaitRequiredError
-
-            return result
-
-        finally:
-            if t is not None:
-                if (tl2 := _BRIDGED_TASKS[t]) is not tl:  # noqa
-                    raise UnexpectedBridgeNestingError
-                if (cur_t := _pop_transition(False, tl)) is not added_t:  # noqa
-                    raise UnexpectedBridgeNestingError
-
-    return outer
-
-
-def a_to_s(fn):
-    def inner(*args, **kwargs):
-        seq = next(_BRIDGE_TRANSITIONS_SEQ)
-
-        if (t := aiu.get_current_backend_task()) is not None:
-            try:
-                tl = _BRIDGED_TASKS[t]
-            except KeyError:
-                tl = _BRIDGED_TASKS[t] = []
-            added_t = _push_transition(True, tl, _make_transition(seq, True, t))
-        else:
-            added_t = None
-
-        g = _threadlets().get_current()
-        try:
-            gl = getattr(g.underlying, _BRIDGE_THREADLET_ATTR)
-        except AttributeError:
-            setattr(g.underlying, _BRIDGE_THREADLET_ATTR, gl := [])
-        added_g = _push_transition(True, gl, _make_transition(seq, True, g))
-
-        try:
-            ret = missing = object()
-
-            async def gate():
-                nonlocal ret
-                ret = await fn(*args, **kwargs)
-
-            cr = gate()
-            sv = None
-            he = False
-            try:
-                while True:
-                    if not he:
-                        try:
-                            sv = cr.send(sv)
-                        except StopIteration:
-                            break
-                    he = False
-
-                    if ret is missing or cr.cr_await is not None or cr.cr_running:
-                        try:
-                            sv = s_to_a_await(sv)  # type: ignore
-                        except BaseException as e:  # noqa
-                            sv = cr.throw(e)
-                            he = True
-
-            finally:
-                cr.close()
-
-        finally:
-            if t is not None:
-                if (tl2 := _BRIDGED_TASKS[t]) is not tl:  # noqa
-                    raise UnexpectedBridgeNestingError
-                if (cur_t := _pop_transition(True, tl)) is not added_t:  # noqa
-                    raise UnexpectedBridgeNestingError
-
-            if (gl2 := getattr(g.underlying, _BRIDGE_THREADLET_ATTR)) is not gl:  # noqa
-                raise UnexpectedBridgeNestingError
-            if (cur_g := _pop_transition(True, gl)) is not added_g:  # noqa
-                raise UnexpectedBridgeNestingError
-
-        return ret
-
-    return inner

omlish/asyncs/utils.py

@@ -1,18 +0,0 @@
-import contextlib
-import typing as ta
-
-
-P = ta.ParamSpec('P')
-T = ta.TypeVar('T')
-
-
-##
-
-
-async def call_with_async_exit_stack(
-        fn: ta.Callable[ta.Concatenate[contextlib.AsyncExitStack, P], ta.Awaitable[T]],
-        *args: ta.Any,
-        **kwargs: ta.Any,
-) -> T:
-    async with contextlib.AsyncExitStack() as aes:
-        return await fn(aes, *args, **kwargs)

omlish/dataclasses/impl/generation/mangling.py

@@ -1,18 +0,0 @@
-from ....text.mangle import StringMangler
-
-
-##
-
-
-ESCAPED_IDENT_CHARS = ''.join(
-    chr(i)
-    for i in range(128)
-    if not (
-        chr(i).isalpha() or
-        chr(i).isdigit() or
-        chr(i) == '_' or
-        ord(chr(i)) > 127
-    )
-)
-
-IDENT_MANGLER = StringMangler.of('_', ESCAPED_IDENT_CHARS)

omlish/defs.py

@@ -1,216 +0,0 @@
-"""
-A self-awarely unpythonic set of helpers for defining common boilerplate methods (repr, hash_eq, delegates, etc) in
-class definitions. Should be used sparingly for methods not directly used by humans (like repr) - @property's should
-remain @property's for type annotation, tool assistance, debugging, and otherwise, but these are still nice to have in
-certain circumstances (the real-world alternative usually being simply not adding them).
-"""
-# ruff: noqa: ANN201
-import abc
-import functools
-import operator
-import threading
-
-from . import lang
-
-
-##
-
-
-_repr = repr
-
-BASICS = {}
-
-
-def _basic(fn):
-    if fn.__name__ in BASICS:
-        raise NameError(fn.__name__)
-
-    BASICS[fn.__name__] = fn
-    return fn
-
-
-@lang.cls_dct_fn()
-def basic(cls_dct, *attrs, basics=None):
-    if basics is None:
-        basics = BASICS.keys()
-
-    for k in basics:
-        fn = BASICS[k]
-        fn(*attrs, cls_dct=cls_dct)
-
-
-_REPR_SEEN = threading.local()
-
-
-def _repr_guard(fn):
-    @functools.wraps(fn)
-    def inner(obj, *args, **kwargs):
-        try:
-            ids = _REPR_SEEN.ids
-
-        except AttributeError:
-            ids = _REPR_SEEN.ids = set()
-            try:
-                ids.add(id(obj))
-                return fn(obj, *args, **kwargs)
-            finally:
-                del _REPR_SEEN.ids
-
-        else:
-            if id(obj) in ids:
-                return f'<seen:{type(obj).__name__}@{hex(id(obj))[2:]}>'
-            ids.add(id(obj))
-            return fn(obj, *args, **kwargs)
-
-    return inner
-
-
-@_repr_guard
-def build_attr_repr(obj, *, mro=False):
-    if mro:
-        attrs = [
-            attr
-            for ty in sorted(  # noqa
-                reversed(type(obj).__mro__),
-                key=lambda _ty: _ty.__dict__.get('__repr_priority__', 0),
-            )
-            for attr in ty.__dict__.get('__repr_attrs__', [])
-        ]
-
-    else:
-        attrs = obj.__repr_attrs__
-
-    s = ', '.join(f'{a}={"<self>" if v is obj else _repr(v)}' for a in attrs for v in [getattr(obj, a)])
-    return f'{type(obj).__name__}@{hex(id(obj))[2:]}({s})'
-
-
-@_repr_guard
-def build_repr(obj, *attrs):
-    return (
-        f'{type(obj).__name__}'
-        f'@{hex(id(obj))[2:]}'
-        f'({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
-    )
-
-
-@_basic
-@lang.cls_dct_fn()
-def repr(cls_dct, *attrs, mro=False, priority=None):  # noqa
-    def __repr__(self):  # noqa
-        return build_attr_repr(self, mro=mro)
-
-    cls_dct['__repr_attrs__'] = attrs
-    if priority is not None:
-        cls_dct['__repr_priority__'] = priority
-
-    cls_dct['__repr__'] = __repr__
-
-
-@lang.cls_dct_fn()
-def bare_repr(cls_dct, *attrs):
-    def __repr__(self):  # noqa
-        return lang.attr_repr(self, *attrs)
-
-    cls_dct['__repr__'] = __repr__
-
-
-@lang.cls_dct_fn()
-def name_repr(cls_dct):
-    def __repr__(self):  # noqa
-        return self.__name__
-
-    cls_dct['__repr__'] = __repr__
-
-
-@lang.cls_dct_fn()
-def ne(cls_dct):
-    def __ne__(self, other):  # noqa
-        return not (self == other)
-
-    cls_dct['__ne__'] = __ne__
-
-
-@lang.cls_dct_fn()
-def no_order(cls_dct, *, raise_=None):
-    def fn(self, other):
-        if raise_ is None:
-            return NotImplemented
-        else:
-            raise raise_
-
-    for att in [
-        '__lt__',
-        '__le__',
-        '__gt__',
-        '__ge__',
-    ]:
-        cls_dct[att] = fn
-
-
-@_basic
-@lang.cls_dct_fn()
-def hash_eq(cls_dct, *attrs):
-    def __hash__(self):  # noqa
-        return hash(tuple(getattr(self, attr) for attr in attrs))
-
-    cls_dct['__hash__'] = __hash__
-
-    def __eq__(self, other):  # noqa
-        if type(other) is not type(self):
-            return False
-
-        for attr in attrs:  # noqa
-            if getattr(self, attr) != getattr(other, attr):
-                return False
-
-        return True
-
-    cls_dct['__eq__'] = __eq__
-
-    ne(cls_dct=cls_dct)
-
-
-@lang.cls_dct_fn()
-def getter(cls_dct, *attrs):
-    for attr in attrs:
-        cls_dct[attr] = property(operator.attrgetter('_' + attr))
-
-
-@lang.cls_dct_fn()
-def not_implemented(cls_dct, *names, **kwargs):
-    wrapper = kwargs.pop('wrapper', lambda _: _)
-    if kwargs:
-        raise TypeError(kwargs)
-
-    ret = []
-    for name in names:
-        @wrapper
-        def not_implemented(self, *args, **kwargs):
-            raise NotImplementedError
-
-        not_implemented.__name__ = name
-        cls_dct[name] = not_implemented
-        ret.append(not_implemented)
-
-    return tuple(ret)
-
-
-@lang.cls_dct_fn()
-def abstract_method(cls_dct, *names):
-    return not_implemented(cls_dct, *names, wrapper=abc.abstractmethod)
-
-
-@lang.cls_dct_fn()
-def abstract_property(cls_dct, *names):
-    return not_implemented(cls_dct, *names, wrapper=lambda o: property(abc.abstractmethod(o)))
-
-
-@lang.cls_dct_fn()
-def abstract_hash_eq(cls_dct):
-    return not_implemented(
-        cls_dct,
-        '__hash__',
-        '__eq__',
-        '__ne__',
-        wrapper=abc.abstractmethod,
-    )

omlish/dispatch/_dispatch2.py

@@ -1,69 +0,0 @@
-import abc
-import typing as ta
-import weakref
-
-from .impls import find_impl as default_find_impl
-
-
-T = ta.TypeVar('T')
-
-
-##
-
-
-class Dispatcher(ta.Generic[T]):
-    def __init__(self, find_impl: ta.Callable[[type, ta.Mapping[type, T]], T | None] | None = None) -> None:
-        super().__init__()
-
-        if find_impl is None:
-            find_impl = default_find_impl
-        self._find_impl = find_impl
-
-        self._impls_by_arg_cls: dict[type, T] = {}
-        self._dispatch_cache: dict[ta.Any, T | None] = {}
-
-        def cache_remove(k, self_ref=weakref.ref(self)):
-            if (ref_self := self_ref()) is not None:
-                cache = ref_self._dispatch_cache  # noqa
-                try:
-                    del cache[k]
-                except KeyError:
-                    pass
-
-        self._cache_remove = cache_remove
-
-        self._cache_token: ta.Any = None
-
-    def cache_size(self) -> int:
-        return len(self._dispatch_cache)
-
-    def register(self, impl: T, cls_col: ta.Iterable[type]) -> T:
-        for cls in cls_col:
-            self._impls_by_arg_cls[cls] = impl
-
-            if self._cache_token is None and hasattr(cls, '__abstractmethods__'):
-                self._cache_token = abc.get_cache_token()
-
-        self._dispatch_cache.clear()
-        return impl
-
-    def dispatch(self, cls: type) -> T | None:
-        if self._cache_token is not None and (current_token := abc.get_cache_token()) != self._cache_token:
-            self._dispatch_cache.clear()
-            self._cache_token = current_token
-
-        cls_ref = weakref.ref(cls)
-        try:
-            return self._dispatch_cache[cls_ref]
-        except KeyError:
-            pass
-        del cls_ref
-
-        impl: T | None
-        try:
-            impl = self._impls_by_arg_cls[cls]
-        except KeyError:
-            impl = self._find_impl(cls, self._impls_by_arg_cls)
-
-        self._dispatch_cache[weakref.ref(cls, self._cache_remove)] = impl
-        return impl