omlish 0.0.0.dev447__py3-none-any.whl → 0.0.0.dev493__py3-none-any.whl

omlish/dispatch/methods.py

@@ -4,13 +4,11 @@ TODO:
  - ALT: A.f(super(), ... ? :/
  - classmethod/staticmethod
 """
-import contextlib
 import functools
 import typing as ta
-import weakref
 
 from .. import check
-from .. import lang
+from .. import collections as col
 from .dispatch import Dispatcher
 from .impls import get_impl_func_cls_set
 
@@ -34,9 +32,8 @@ class Method(ta.Generic[P, R]):
     it must be explicitly `@register`'ed itself. This is a feature, allowing for selective de-registration of
     implementations in subclasses via name shadowing.
 
-    Methods have ability to choose to allow external installation of implementations outside of direct subclasses. This
-    is to be used *extremely* rarely - basically only in the rare case of externally extensible type hierarchies with
-    visitors.
+    Methods can choose to allow external installation of implementations outside of direct subclasses. This is to be
+    used *extremely* rarely - basically only in the rare case of externally extensible type hierarchies with visitors.
     """
 
     def __init__(
@@ -45,6 +42,7 @@ class Method(ta.Generic[P, R]):
             *,
             installable: bool = False,
             requires_override: bool = False,
+            instance_cache: bool = False,
     ) -> None:
         super().__init__()
 
@@ -53,9 +51,16 @@ class Method(ta.Generic[P, R]):
 
         self._func = func
         self._installable = installable
-        self._requires_override = requires_override
+        self._instance_cache = instance_cache
 
-        self._impls: ta.MutableMapping[ta.Callable, frozenset[type] | None] = weakref.WeakKeyDictionary()
+        self._registry: col.AttrRegistry[ta.Callable, Method._Entry] = col.AttrRegistry(
+            requires_override=requires_override,
+        )
+
+        self._cache: col.AttrRegistryCache[ta.Callable, Method._Entry, ta.Callable] = col.AttrRegistryCache(
+            self._registry,
+            self._prepare,
+        )
 
         # bpo-45678: special-casing for classmethod/staticmethod in Python <=3.9, as functools.update_wrapper doesn't
         # work properly in singledispatchmethod.__get__ if it is applied to an unbound classmethod/staticmethod
@@ -68,19 +73,12 @@ class Method(ta.Generic[P, R]):
         self._is_abstractmethod = getattr(func, '__isabstractmethod__', False)  # noqa
         self.update_wrapper(self)
 
-        self._dispatch_func_cache: dict[ta.Any, ta.Callable] = {}
-
-        def dispatch_func_cache_remove(k, self_ref=weakref.ref(self)):
-            if (ref_self := self_ref()) is not None:
-                cache = ref_self._dispatch_func_cache  # noqa
-                with contextlib.suppress(KeyError):
-                    del cache[k]
-
-        self._dispatch_func_cache_remove = dispatch_func_cache_remove
-
         self._owner: type | None = None
         self._name: str | None = None
 
+    class _Entry:
+        cls_set: frozenset[type]
+
     def __set_name__(self, owner, name):
         if self._owner is None:
             self._owner = owner
@@ -102,83 +100,29 @@ class Method(ta.Generic[P, R]):
 
     def register(self, impl: T, cls_set: frozenset[type] | None = None) -> T:
         check.callable(impl)
-        if impl not in self._impls:
-            self._impls[impl] = cls_set  # type: ignore
-            self._dispatch_func_cache.clear()
-
-        return impl
-
-    def _is_impl(self, obj: ta.Any) -> bool:
-        try:
-            hash(obj)
-        except TypeError:
-            return False
-
-        return obj in self._impls
 
-    def build_attr_dispatcher(self, instance_cls: type, owner_cls: type | None = None) -> Dispatcher[str]:
-        if owner_cls is None:
-            owner_cls = instance_cls
+        entry = Method._Entry()
+        if cls_set is not None:
+            entry.cls_set = cls_set
 
-        mro = instance_cls.__mro__[-2::-1]
-        try:
-            mro_pos = mro.index(owner_cls)
-        except ValueError:
-            raise TypeError(f'Owner class {owner_cls} not in mro of instance class {instance_cls}') from None
+        self._registry.register(ta.cast(ta.Callable, impl), entry)
 
-        mro_dct: dict[str, list[tuple[type, ta.Any]]] = {}
-        for cur_cls in mro[:mro_pos + 1]:
-            for att, obj in cur_cls.__dict__.items():
-                if att not in mro_dct:
-                    if not self._is_impl(obj):
-                        continue
-
-                try:
-                    lst = mro_dct[att]
-                except KeyError:
-                    lst = mro_dct[att] = []
-                lst.append((cur_cls, obj))
-
-        #
+        return impl
 
+    def _build_dispatcher(self, collected: ta.Mapping[str, tuple[ta.Callable, _Entry]]) -> Dispatcher[str]:
         disp: Dispatcher[str] = Dispatcher()
 
-        seen: dict[ta.Any, str] = {}
-        for att, lst in mro_dct.items():
-            if not lst:
-                raise RuntimeError
-            _, obj = lst[-1]
-
-            if len(lst) > 1:
-                if self._requires_override and not lang.is_override(obj):
-                    raise lang.RequiresOverrideError(
-                        att,
-                        instance_cls,
-                        lst[-1][0],
-                        lst[0][0],
-                    )
-
-            if not self._is_impl(obj):
-                continue
-
-            cls_set = self._impls[obj]
-            if cls_set is None:
-                cls_set = get_impl_func_cls_set(obj, arg_offset=1)
-                self._impls[obj] = cls_set
-
+        for a, (f, e) in collected.items():
             try:
-                ex_att = seen[obj]
-            except KeyError:
-                pass
-            else:
-                raise TypeError(f'Duplicate impl: {owner_cls} {instance_cls} {att} {ex_att}')
-            seen[obj] = att
+                cls_set = e.cls_set
+            except AttributeError:
+                cls_set = e.cls_set = get_impl_func_cls_set(f, arg_offset=1)
 
-            disp.register(att, cls_set)
+            disp.register(a, cls_set)
 
         return disp
 
-    def build_dispatch_func(self, disp: Dispatcher[str]) -> ta.Callable:
+    def _build_dispatch_func(self, disp: Dispatcher[str]) -> ta.Callable:
         dispatch = disp.dispatch
         type_ = type
         getattr_ = getattr
@@ -190,25 +134,16 @@ class Method(ta.Generic[P, R]):
                 raise TypeError(f'{func_name} requires at least 1 positional argument')
 
             if (impl_att := dispatch(type_(args[0]))) is not None:
-                fn = getattr_(self, impl_att)
-                return fn(*args, **kwargs)
+                return getattr_(self, impl_att)(*args, **kwargs)
 
             return base_func.__get__(self)(*args, **kwargs)  # noqa
 
         self.update_wrapper(__call__)
         return __call__
 
-    def get_dispatch_func(self, instance_cls: type) -> ta.Callable:
-        cls_ref = weakref.ref(instance_cls)
-        try:
-            return self._dispatch_func_cache[cls_ref]
-        except KeyError:
-            pass
-        del cls_ref
-
-        att_disp = self.build_attr_dispatcher(instance_cls)
-        func = self.build_dispatch_func(att_disp)
-        self._dispatch_func_cache[weakref.ref(instance_cls, self._dispatch_func_cache_remove)] = func
+    def _prepare(self, instance_cls: type, collected: ta.Mapping[str, tuple[ta.Callable, _Entry]]) -> ta.Callable:
+        disp = self._build_dispatcher(collected)
+        func = self._build_dispatch_func(disp)
         return func
 
     def __get__(self, instance, owner=None):
@@ -216,16 +151,21 @@ class Method(ta.Generic[P, R]):
             # FIXME: classmethod/staticmethod
             return self
 
-        instance_cls = type(instance)
-        try:
-            func = self._dispatch_func_cache[weakref.ref(instance_cls)]
-        except KeyError:
-            func = self.get_dispatch_func(instance_cls)
-        return func.__get__(instance, owner)  # noqa
+        if self._instance_cache:
+            try:
+                return instance.__dict__[self._name]
+            except KeyError:
+                pass
+
+        bound = self._cache.get(type(instance)).__get__(instance, owner)  # noqa
+
+        if self._instance_cache:
+            instance.__dict__[self._name] = bound
+
+        return bound
 
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
         instance, *rest = args
-        instance_cls = type(instance)
 
         # if instance_cls is super:
         #     owner = instance.__self_class__.__mro__[instance.__self_class__.__mro__.index(instance.__thisclass__) + 1]
@@ -233,55 +173,25 @@ class Method(ta.Generic[P, R]):
         #     func = self.build_dispatch_func(att_disp)
         #     return func.__get__(instance, instance.__thisclass__)(*rest, **kwargs)
 
-        try:
-            func = self._dispatch_func_cache[weakref.ref(instance_cls)]
-        except KeyError:
-            func = self.get_dispatch_func(instance_cls)
-        return func.__get__(instance)(*rest, **kwargs)  # noqa
+        return self.__get__(instance)(*rest, **kwargs)
 
 
 ##
 
 
-@ta.overload
-def method(
-        func: ta.Callable[P, R],
-        /,
-        *,
-        installable: bool = False,
-        requires_override: bool = False,
-) -> Method[P, R]:  # noqa
-    ...
-
-
-@ta.overload
 def method(
-        func: None = None,
-        /,
         *,
         installable: bool = False,
         requires_override: bool = False,
+        instance_cache: bool = False,
 ) -> ta.Callable[[ta.Callable[P, R]], Method[P, R]]:  # noqa
-    ...
-
-
-def method(
-        func=None,
-        /,
-        *,
-        installable=False,
-        requires_override=False,
-):
-    kw = dict(
+    return functools.partial(
+        Method,  # type: ignore[arg-type]
         installable=installable,
         requires_override=requires_override,
+        instance_cache=instance_cache,
     )
 
-    if func is None:
-        return functools.partial(Method, **kw)
-
-    return Method(func, **kw)
-
 
 #
 
@@ -305,7 +215,7 @@ def install_method(
         if on is None:
             cls = owner
         else:
-            cls = check.issubclass(on, owner)
+            cls = check.issubclass(on, owner)  # noqa
 
         check.arg(not hasattr(cls, a))
         setattr(cls, a, fn)

omlish/dom/rendering.py

@@ -100,7 +100,7 @@ class Renderer:
 
     #
 
-    @dispatch.method
+    @dispatch.method(instance_cache=True)
     def render(self, o: ta.Any) -> None:
         raise TypeError(o)
 

omlish/formats/dotenv.py

@@ -584,7 +584,7 @@ def dotenv_values(
     For example, `foo=bar` results in `{"foo": "bar"}` whereas `foo` alone results in
     `{"foo": None}`
 
-    Parameters:
+    Args:
         path: Absolute or relative path to the .env file.
         stream: `StringIO` object with .env content, used if `path` is `None`.
         verbose: Whether to output a warning if the .env file is missing.

omlish/formats/json/stream/__init__.py

@@ -1,3 +1,16 @@
+"""
+A generator powered, configurable, mostly fully streaming JSON parser.
+
+Regarding the 'streamyness' of the subsystems:
+ - Lexing only buffers for string and number literals.
+ - Parsing maintains only a stack that scales by nesting depth.
+ - Building values will obviously hold everything under the topmost object it's building until it's finished.
+
+It's reasonably optimized, but performance is not a primary or even secondary goal: its goal is flexibility. If speed
+matters use a native library.
+"""
+
+
 from .building import (  # noqa
     JsonValueBuilder,
 )

omlish/funcs/guard.py

@@ -0,0 +1,225 @@
+import abc
+import functools
+import operator
+import typing as ta
+
+from .. import check
+from .. import collections as col
+from .. import lang
+
+
+T = ta.TypeVar('T')
+T_co = ta.TypeVar('T_co', covariant=True)
+U = ta.TypeVar('U')
+P = ta.ParamSpec('P')
+
+
+##
+
+
+class GuardFn(ta.Protocol[P, T_co]):
+    def __get__(self, instance, owner=None): ...
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T_co] | None: ...
+
+
+##
+
+
+@ta.final
+class DumbGuardFn(ta.Generic[P, T]):
+    def __init__(self, fn: ta.Callable[P, T]) -> None:
+        self._fn = fn
+
+    def __get__(self, instance, owner=None):
+        return DumbGuardFn(self._fn.__get__(instance, owner))  # noqa
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T]:
+        return functools.partial(self._fn, *args, **kwargs)
+
+
+dumb = DumbGuardFn
+
+
+##
+
+
+class AmbiguousGuardFnError(Exception):
+    pass
+
+
+@ta.final
+class MultiGuardFn(ta.Generic[P, T]):
+    def __init__(
+            self,
+            *children: GuardFn[P, T],
+            default: GuardFn[P, T] | None = None,
+            strict: bool = False,
+    ) -> None:
+        self._children, self._default, self._strict = children, default, strict
+
+    lang.attr_ops(lambda self: (
+        self._children,
+        self._default,
+        self._strict,
+    )).install(locals())
+
+    def __get__(self, instance, owner=None):
+        return MultiGuardFn(*map(operator.methodcaller('__get__', instance, owner), self._children), default=self._default.__get__(instance, owner) if self._default is not None else None, strict=self._strict)  # noqa
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T] | None:
+        matches = []
+        for c in self._children:
+            if (m := c(*args, **kwargs)) is not None:
+                if not self._strict:
+                    return m
+                matches.append(m)
+        if not matches:
+            if (dfl := self._default) is not None:
+                return dfl(*args, **kwargs)
+            else:
+                return None
+        elif len(matches) > 1:
+            raise AmbiguousGuardFnError
+        else:
+            return matches[0]
+
+
+multi = MultiGuardFn
+
+
+##
+
+
+class _BaseGuardFnMethod(lang.Abstract, ta.Generic[P, T]):
+    def __init__(
+            self,
+            *,
+            strict: bool = False,
+            requires_override: bool = False,
+            instance_cache: bool = False,
+            default: GuardFn[P, T] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._strict = strict
+        self._instance_cache = instance_cache
+        self._default = default
+
+        self._registry: col.AttrRegistry[ta.Callable, None] = col.AttrRegistry(
+            requires_override=requires_override,
+        )
+
+        self._cache: col.AttrRegistryCache[ta.Callable, None, MultiGuardFn] = col.AttrRegistryCache(
+            self._registry,
+            self._prepare,
+        )
+
+    _owner: type | None = None
+    _name: str | None = None
+
+    def __set_name__(self, owner, name):
+        if self._owner is None:
+            self._owner = owner
+        if self._name is None:
+            self._name = name
+
+    def register(self, fn: U) -> U:
+        check.callable(fn)
+        self._registry.register(ta.cast(ta.Callable, fn), None)
+        return fn
+
+    def _prepare(self, instance_cls: type, collected: ta.Mapping[str, tuple[ta.Callable, None]]) -> MultiGuardFn:
+        return MultiGuardFn(
+            *[getattr(instance_cls, a) for a in collected],
+            default=self._default,
+            strict=self._strict,
+        )
+
+    @abc.abstractmethod
+    def _bind(self, instance, owner):
+        raise NotImplementedError
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+
+        if self._instance_cache:
+            try:
+                return instance.__dict__[self._name]
+            except KeyError:
+                pass
+
+        bound = self._bind(instance, owner)
+
+        if self._instance_cache:
+            instance.__dict__[self._name] = bound
+
+        return bound
+
+    def _call(self, *args, **kwargs):
+        instance, *rest = args
+        return self.__get__(instance)(*rest, **kwargs)
+
+#
+
+
+@ta.final
+class GuardFnMethod(_BaseGuardFnMethod[P, T]):
+    def _bind(self, instance, owner):
+        return self._cache.get(type(instance)).__get__(instance, owner)  # noqa
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> ta.Callable[[], T] | None:
+        return self._call(*args, **kwargs)
+
+
+def method(
+        *,
+        strict: bool = False,
+        requires_override: bool = False,
+        instance_cache: bool = False,
+        default: bool = False,
+) -> ta.Callable[[ta.Callable[P, T]], GuardFnMethod[P, T]]:  # noqa
+    def inner(fn):
+        return GuardFnMethod(
+            strict=strict,
+            requires_override=requires_override,
+            instance_cache=instance_cache,
+            default=fn if default else None,
+        )
+
+    return inner
+
+
+#
+
+
+@ta.final
+class ImmediateGuardFnMethod(_BaseGuardFnMethod[P, T]):
+    def _bind(self, instance, owner):
+        gf = self._cache.get(type(instance)).__get__(instance, owner)  # noqa
+
+        def inner(*args, **kwargs):
+            return gf(*args, **kwargs)()  # Note: cannot be None due to non-optional default
+
+        return inner
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        return self._call(*args, **kwargs)
+
+
+def immediate_method(
+        *,
+        strict: bool = False,
+        requires_override: bool = False,
+        instance_cache: bool = False,
+) -> ta.Callable[[ta.Callable[P, T]], ImmediateGuardFnMethod[P, T]]:  # noqa
+    def inner(fn):
+        return ImmediateGuardFnMethod(
+            strict=strict,
+            requires_override=requires_override,
+            instance_cache=instance_cache,
+            default=(lambda *args, **kwargs: lambda: fn(*args, **kwargs)),
+        )
+
+    return inner

omlish/graphs/dot/rendering.py

@@ -29,7 +29,7 @@ class Renderer:
 
         self._out = out
 
-    @dispatch.method
+    @dispatch.method(instance_cache=True)
     def render(self, item: Item) -> None:
         raise TypeError(item)
 

omlish/http/all.py

@@ -4,9 +4,18 @@ from .. import lang as _lang
 with _lang.auto_proxy_init(globals()):
     ##
 
+    from .clients.asyncs import (  # noqa
+        AsyncStreamHttpResponse,
+
+        async_close_http_client_response,
+        async_closing_http_client_response,
+        async_read_http_client_response,
+
+        AsyncHttpClient,
+    )
+
     from .clients.base import (  # noqa
         DEFAULT_ENCODING,
-
         is_success_status,
 
         HttpRequest,
@@ -14,34 +23,63 @@ with _lang.auto_proxy_init(globals()):
         BaseHttpResponse,
         HttpResponse,
 
+        HttpClientContext,
+
         HttpClientError,
         HttpStatusError,
+
+        BaseHttpClient,
     )
 
     from .clients.default import (  # noqa
         client,
+        manage_client,
 
         request,
+
+        async_client,
+        manage_async_client,
+
+        async_request,
     )
 
     from .clients.httpx import (  # noqa
         HttpxHttpClient,
+
+        HttpxAsyncHttpClient,
+    )
+
+    from .clients.middleware import (  # noqa
+        HttpClientMiddleware,
+        AbstractMiddlewareHttpClient,
+
+        MiddlewareHttpClient,
+        MiddlewareAsyncHttpClient,
+
+        TooManyRedirectsHttpClientError,
+        RedirectHandlingHttpClientMiddleware,
     )
 
     from .clients.sync import (  # noqa
         StreamHttpResponse,
 
-        close_response,
-        closing_response,
-        read_response,
+        close_http_client_response,
+        closing_http_client_response,
+        read_http_client_response,
 
         HttpClient,
     )
 
+    from .clients.syncasync import (  # noqa
+        SyncAsyncHttpClient,
+    )
+
     from .clients.urllib import (  # noqa
         UrllibHttpClient,
     )
 
+    from . import asgi  # noqa
+
     from . import consts  # noqa
 
     from .cookies import (  # noqa
@@ -80,3 +118,5 @@ with _lang.auto_proxy_init(globals()):
         MultipartEncoder,
         MultipartField,
     )
+
+    from . import wsgi  # noqa