omlish 0.0.0.dev447__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

@@ -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

omlish/http/clients/asyncs.py

@@ -5,11 +5,13 @@ 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_maybe_post_init
 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
@@ -25,22 +27,21 @@ AsyncHttpClientT = ta.TypeVar('AsyncHttpClientT', bound='AsyncHttpClient')
 @ta.final
 @dc.dataclass(frozen=True)  # kw_only=True
 class AsyncStreamHttpResponse(BaseHttpResponse):
-    class Stream(ta.Protocol):
-        def read(self, /, n: int = -1) -> ta.Awaitable[bytes]: ...
+    _stream: ta.Optional[AsyncBufferedBytesReader] = None
 
-    @ta.final
-    class _NullStream:
-        def read(self, /, n: int = -1) -> ta.Awaitable[bytes]:
-            raise TypeError
+    @property
+    def stream(self) -> 'AsyncBufferedBytesReader':
+        if (st := self._stream) is None:
+            raise TypeError('No data')
+        return st
 
-    stream: Stream = _NullStream()
+    @property
+    def has_data(self) -> bool:
+        return self._stream is not None
 
-    _closer: ta.Optional[ta.Callable[[], ta.Awaitable[None]]] = None
+    #
 
-    def __post_init__(self) -> None:
-        dataclass_maybe_post_init(super())
-        if isinstance(self.stream, AsyncStreamHttpResponse._NullStream):
-            raise TypeError(self.stream)
+    _closer: ta.Optional[ta.Callable[[], ta.Awaitable[None]]] = None
 
     async def __aenter__(self: AsyncStreamHttpResponseT) -> AsyncStreamHttpResponseT:
         return self
@@ -50,13 +51,13 @@ class AsyncStreamHttpResponse(BaseHttpResponse):
 
     async def close(self) -> None:
         if (c := self._closer) is not None:
-            c()
+            await c()  # noqa
 
 
 #
 
 
-async def async_close_response(resp: BaseHttpResponse) -> None:
+async def async_close_http_client_response(resp: BaseHttpResponse) -> None:
     if isinstance(resp, HttpResponse):
         pass
 
@@ -68,7 +69,7 @@ async def async_close_response(resp: BaseHttpResponse) -> None:
 
 
 @contextlib.asynccontextmanager
-async def async_closing_response(resp: BaseHttpResponseT) -> ta.AsyncGenerator[BaseHttpResponseT, None]:
+async def async_closing_http_client_response(resp: BaseHttpResponseT) -> ta.AsyncGenerator[BaseHttpResponseT, None]:
     if isinstance(resp, HttpResponse):
         yield resp
         return
@@ -83,15 +84,14 @@ async def async_closing_response(resp: BaseHttpResponseT) -> ta.AsyncGenerator[B
         raise TypeError(resp)
 
 
-async def async_read_response(resp: BaseHttpResponse) -> HttpResponse:
+async def async_read_http_client_response(resp: BaseHttpResponse) -> HttpResponse:
     if isinstance(resp, HttpResponse):
         return resp
 
     elif isinstance(resp, AsyncStreamHttpResponse):
-        data = await resp.stream.read()
         return HttpResponse(**{
-            **{k: v for k, v in dataclass_shallow_asdict(resp).items() if k not in ('stream', '_closer')},
-            'data': data,
+            **{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:
@@ -101,7 +101,7 @@ async def async_read_response(resp: BaseHttpResponse) -> HttpResponse:
 ##
 
 
-class AsyncHttpClient(Abstract):
+class AsyncHttpClient(BaseHttpClient, Abstract):
     async def __aenter__(self: AsyncHttpClientT) -> AsyncHttpClientT:
         return self
 
@@ -112,21 +112,27 @@ class AsyncHttpClient(Abstract):
             self,
             req: HttpRequest,
             *,
+            context: ta.Optional[HttpClientContext] = None,
             check: bool = False,
     ) -> HttpResponse:
-        async with async_closing_response(await self.stream_request(
+        async with async_closing_http_client_response(await self.stream_request(
                 req,
+                context=context,
                 check=check,
         )) as resp:
-            return await async_read_response(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:
-        resp = await self._stream_request(req)
+        if context is None:
+            context = HttpClientContext()
+
+        resp = await self._stream_request(context, req)
 
         try:
             if check and not resp.is_success:
@@ -134,14 +140,14 @@ class AsyncHttpClient(Abstract):
                     cause = resp.underlying
                 else:
                     cause = None
-                raise HttpStatusError(await async_read_response(resp)) from cause  # noqa
+                raise HttpStatusError(await async_read_http_client_response(resp)) from cause  # noqa
 
         except Exception:
-            await async_close_response(resp)
+            await async_close_http_client_response(resp)
             raise
 
         return resp
 
     @abc.abstractmethod
-    def _stream_request(self, req: HttpRequest) -> ta.Awaitable[AsyncStreamHttpResponse]:
+    def _stream_request(self, ctx: HttpClientContext, req: HttpRequest) -> ta.Awaitable[AsyncStreamHttpResponse]:
         raise NotImplementedError

omlish/http/clients/base.py

@@ -119,12 +119,28 @@ class HttpResponse(BaseHttpResponse):
 ##
 
 
+@ta.final
+class HttpClientContext:
+    def __init__(self) -> None:
+        self._dct: dict = {}
+
+
+##
+
+
 class HttpClientError(Exception):
     @property
     def cause(self) -> ta.Optional[BaseException]:
         return self.__cause__
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass()
 class HttpStatusError(HttpClientError):
     response: HttpResponse
+
+
+##
+
+
+class BaseHttpClient(Abstract):
+    pass

omlish/http/clients/coro/sync.py

@@ -0,0 +1,171 @@
+# @omlish-lite
+# ruff: noqa: UP045
+import errno
+import socket
+import typing as ta
+import urllib.parse
+
+from ....io.buffers import ReadableListBuffer
+from ....lite.check import check
+from ...coro.client.connection import CoroHttpClientConnection
+from ...coro.client.response import CoroHttpClientResponse
+from ...coro.io import CoroHttpIo
+from ...headers import HttpHeaders
+from ...urls import unparse_url_request_path
+from ..base import HttpClientContext
+from ..base import HttpClientError
+from ..base import HttpRequest
+from ..sync import HttpClient
+from ..sync import StreamHttpResponse
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class CoroHttpClient(HttpClient):
+    class _Connection:
+        def __init__(self, req: HttpRequest) -> None:
+            super().__init__()
+
+            self._req = req
+            self._ups = urllib.parse.urlparse(req.url)
+
+            self._ssl = self._ups.scheme == 'https'
+
+        _cc: ta.Optional[CoroHttpClientConnection] = None
+        _resp: ta.Optional[CoroHttpClientResponse] = None
+
+        _sock: ta.Optional[socket.socket] = None
+        _sock_file: ta.Optional[ta.BinaryIO] = None
+
+        _ssl_context: ta.Any = None
+
+        #
+
+        def _create_https_context(self, http_version: int) -> ta.Any:
+            # https://github.com/python/cpython/blob/a7160912274003672dc116d918260c0a81551c21/Lib/http/client.py#L809
+            import ssl
+
+            # Function also used by urllib.request to be able to set the check_hostname attribute on a context object.
+            context = ssl.create_default_context()
+
+            # Send ALPN extension to indicate HTTP/1.1 protocol.
+            if http_version == 11:
+                context.set_alpn_protocols(['http/1.1'])
+
+            # Enable PHA for TLS 1.3 connections if available.
+            if context.post_handshake_auth is not None:
+                context.post_handshake_auth = True
+
+            return context
+
+        #
+
+        def setup(self) -> StreamHttpResponse:
+            check.none(self._sock)
+            check.none(self._ssl_context)
+
+            self._cc = cc = CoroHttpClientConnection(
+                check.not_none(self._ups.hostname),
+                default_port=CoroHttpClientConnection.HTTPS_PORT if self._ssl else CoroHttpClientConnection.HTTP_PORT,
+            )
+
+            if self._ssl:
+                self._ssl_context = self._create_https_context(self._cc.http_version)
+
+            try:
+                self._run_coro(cc.connect())
+
+                self._run_coro(cc.request(
+                    self._req.method or 'GET',
+                    unparse_url_request_path(self._ups) or '/',
+                    self._req.data,
+                    hh.single_str_dct if (hh := self._req.headers_) is not None else {},
+                ))
+
+                self._resp = resp = self._run_coro(cc.get_response())
+
+                return StreamHttpResponse(
+                    status=resp._state.status,  # noqa
+                    headers=HttpHeaders(resp._state.headers.items()),  # noqa
+                    request=self._req,
+                    underlying=self,
+                    _stream=ReadableListBuffer().new_buffered_reader(self),
+                    _closer=self.close,
+                )
+
+            except Exception:
+                self.close()
+                raise
+
+        def _run_coro(self, g: ta.Generator[ta.Any, ta.Any, T]) -> T:
+            i = None
+
+            while True:
+                try:
+                    o = g.send(i)
+                except StopIteration as e:
+                    return e.value
+
+                try:
+                    i = self._handle_io(o)
+                except OSError as e:
+                    raise HttpClientError from e
+
+        def _handle_io(self, o: CoroHttpIo.Io) -> ta.Any:
+            if isinstance(o, CoroHttpIo.ConnectIo):
+                check.none(self._sock)
+                self._sock = socket.create_connection(*o.args, **(o.kwargs or {}))
+
+                if self._ssl_context is not None:
+                    self._sock = self._ssl_context.wrap_socket(
+                        self._sock,
+                        server_hostname=check.not_none(o.server_hostname),
+                    )
+
+                # Might fail in OSs that don't implement TCP_NODELAY
+                try:
+                    self._sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+                except OSError as e:
+                    if e.errno != errno.ENOPROTOOPT:
+                        raise
+
+                self._sock_file = self._sock.makefile('rb')
+
+                return None
+
+            elif isinstance(o, CoroHttpIo.CloseIo):
+                check.not_none(self._sock).close()
+                return None
+
+            elif isinstance(o, CoroHttpIo.WriteIo):
+                check.not_none(self._sock).sendall(o.data)
+                return None
+
+            elif isinstance(o, CoroHttpIo.ReadIo):
+                if (sz := o.sz) is not None:
+                    return check.not_none(self._sock_file).read(sz)
+                else:
+                    return check.not_none(self._sock_file).read()
+
+            elif isinstance(o, CoroHttpIo.ReadLineIo):
+                return check.not_none(self._sock_file).readline(o.sz)
+
+            else:
+                raise TypeError(o)
+
+        def read1(self, n: int = -1, /) -> bytes:
+            return self._run_coro(check.not_none(self._resp).read(n if n >= 0 else None))
+
+        def close(self) -> None:
+            if self._resp is not None:
+                self._resp.close()
+            if self._sock is not None:
+                self._sock.close()
+
+    def _stream_request(self, ctx: HttpClientContext, req: HttpRequest) -> StreamHttpResponse:
+        conn = CoroHttpClient._Connection(req)
+        return conn.setup()