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

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

@@ -1,53 +1,122 @@
-from . import consts  # noqa
-
-from .clients import (  # noqa
-    BaseHttpResponse,
-    HttpClient,
-    HttpClientError,
-    HttpRequest,
-    HttpResponse,
-    HttpxHttpClient,
-    StreamHttpResponse,
-    UrllibHttpClient,
-    client,
-    close_response,
-    closing_response,
-    read_response,
-    request,
-)
-
-from .cookies import (  # noqa
-    CookieTooBigError,
-    dump_cookie,
-    parse_cookie,
-)
-
-from .dates import (  # noqa
-    http_date,
-    parse_date,
-)
-
-from .encodings import (  # noqa
-    latin1_decode,
-    latin1_encode,
-)
-
-from .headers import (  # noqa
-    CanHttpHeaders,
-    HttpHeaders,
-    headers,
-)
-
-from .json import (  # noqa
-    JSON_TAGGER,
-    JsonTag,
-    JsonTagger,
-    json_dumps,
-    json_loads,
-)
-
-from .multipart import (  # noqa
-    MultipartData,
-    MultipartEncoder,
-    MultipartField,
-)
+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,
+
+        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_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
+        CookieTooBigError,
+        dump_cookie,
+        parse_cookie,
+    )
+
+    from .dates import (  # noqa
+        http_date,
+        parse_date,
+    )
+
+    from .encodings import (  # noqa
+        latin1_decode,
+        latin1_encode,
+    )
+
+    from .headers import (  # noqa
+        CanHttpHeaders,
+        DuplicateHttpHeaderError,
+        HttpHeaders,
+        headers,
+    )
+
+    from .json import (  # noqa
+        JSON_TAGGER,
+        JsonTag,
+        JsonTagger,
+        json_dumps,
+        json_loads,
+    )
+
+    from .multipart import (  # noqa
+        MultipartData,
+        MultipartEncoder,
+        MultipartField,
+    )
+
+    from . import wsgi  # noqa

omlish/http/asgi.py

@@ -1,14 +1,14 @@
 import abc
-import logging
 import typing as ta
 import urllib.parse
 
 from .. import check
 from .. import lang
+from ..logs import all as logs
 from . import consts
 
 
-log = logging.getLogger(__name__)
+log = logs.get_module_logger(globals())
 
 
 ##

omlish/http/clients/__init__.py

@@ -1,34 +0,0 @@
-from .base import (  # noqa
-    DEFAULT_ENCODING,
-
-    is_success_status,
-
-    HttpRequest,
-
-    BaseHttpResponse,
-    HttpResponse,
-    StreamHttpResponse,
-
-    close_response,
-    closing_response,
-    read_response,
-
-    HttpClientError,
-    HttpStatusError,
-
-    HttpClient,
-)
-
-from .default import (  # noqa
-    client,
-
-    request,
-)
-
-from .httpx import (  # noqa
-    HttpxHttpClient,
-)
-
-from .urllib import (  # noqa
-    UrllibHttpClient,
-)

omlish/http/clients/asyncs.py

@@ -0,0 +1,153 @@
+# ruff: noqa: UP043 UP045
+# @omlish-lite
+import abc
+import contextlib
+import dataclasses as dc
+import typing as ta
+
+from ...io.readers import AsyncBufferedBytesReader
+from ...lite.abstract import Abstract
+from ...lite.dataclasses import dataclass_shallow_asdict
+from .base import BaseHttpClient
+from .base import BaseHttpResponse
+from .base import BaseHttpResponseT
+from .base import HttpClientContext
+from .base import HttpRequest
+from .base import HttpResponse
+from .base import HttpStatusError
+
+
+AsyncStreamHttpResponseT = ta.TypeVar('AsyncStreamHttpResponseT', bound='AsyncStreamHttpResponse')
+AsyncHttpClientT = ta.TypeVar('AsyncHttpClientT', bound='AsyncHttpClient')
+
+
+##
+
+
+@ta.final
+@dc.dataclass(frozen=True)  # kw_only=True
+class AsyncStreamHttpResponse(BaseHttpResponse):
+    _stream: ta.Optional[AsyncBufferedBytesReader] = None
+
+    @property
+    def stream(self) -> 'AsyncBufferedBytesReader':
+        if (st := self._stream) is None:
+            raise TypeError('No data')
+        return st
+
+    @property
+    def has_data(self) -> bool:
+        return self._stream is not None
+
+    #
+
+    _closer: ta.Optional[ta.Callable[[], ta.Awaitable[None]]] = None
+
+    async def __aenter__(self: AsyncStreamHttpResponseT) -> AsyncStreamHttpResponseT:
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def close(self) -> None:
+        if (c := self._closer) is not None:
+            await c()  # noqa
+
+
+#
+
+
+async def async_close_http_client_response(resp: BaseHttpResponse) -> None:
+    if isinstance(resp, HttpResponse):
+        pass
+
+    elif isinstance(resp, AsyncStreamHttpResponse):
+        await resp.close()
+
+    else:
+        raise TypeError(resp)
+
+
+@contextlib.asynccontextmanager
+async def async_closing_http_client_response(resp: BaseHttpResponseT) -> ta.AsyncGenerator[BaseHttpResponseT, None]:
+    if isinstance(resp, HttpResponse):
+        yield resp
+        return
+
+    elif isinstance(resp, AsyncStreamHttpResponse):
+        try:
+            yield resp
+        finally:
+            await resp.close()
+
+    else:
+        raise TypeError(resp)
+
+
+async def async_read_http_client_response(resp: BaseHttpResponse) -> HttpResponse:
+    if isinstance(resp, HttpResponse):
+        return resp
+
+    elif isinstance(resp, AsyncStreamHttpResponse):
+        return HttpResponse(**{
+            **{k: v for k, v in dataclass_shallow_asdict(resp).items() if k not in ('_stream', '_closer')},
+            **({'data': await resp.stream.readall()} if resp.has_data else {}),
+        })
+
+    else:
+        raise TypeError(resp)
+
+
+##
+
+
+class AsyncHttpClient(BaseHttpClient, Abstract):
+    async def __aenter__(self: AsyncHttpClientT) -> AsyncHttpClientT:
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    async def request(
+            self,
+            req: HttpRequest,
+            *,
+            context: ta.Optional[HttpClientContext] = None,
+            check: bool = False,
+    ) -> HttpResponse:
+        async with async_closing_http_client_response(await self.stream_request(
+                req,
+                context=context,
+                check=check,
+        )) as resp:
+            return await async_read_http_client_response(resp)
+
+    async def stream_request(
+            self,
+            req: HttpRequest,
+            *,
+            context: ta.Optional[HttpClientContext] = None,
+            check: bool = False,
+    ) -> AsyncStreamHttpResponse:
+        if context is None:
+            context = HttpClientContext()
+
+        resp = await self._stream_request(context, req)
+
+        try:
+            if check and not resp.is_success:
+                if isinstance(resp.underlying, Exception):
+                    cause = resp.underlying
+                else:
+                    cause = None
+                raise HttpStatusError(await async_read_http_client_response(resp)) from cause  # noqa
+
+        except Exception:
+            await async_close_http_client_response(resp)
+            raise
+
+        return resp
+
+    @abc.abstractmethod
+    def _stream_request(self, ctx: HttpClientContext, req: HttpRequest) -> ta.Awaitable[AsyncStreamHttpResponse]:
+        raise NotImplementedError