omlish 0.0.0.dev468__py3-none-any.whl → 0.0.0.dev469__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev468'
-__revision__ = 'd8cf28f2e17f2f818cbc6ab6b51824700e27dd72'
+__version__ = '0.0.0.dev469'
+__revision__ = 'efea836fe350fa24e6b724d30d414b2d87ee1341'
 
 
 #

omlish/asyncs/asyncio/sync.py

@@ -0,0 +1,43 @@
+# ruff: noqa: UP045
+# @omlish-lite
+import asyncio
+import typing as ta
+
+from ...sync import SyncBufferRelay
+from ..sync import AsyncBufferRelay
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@ta.final
+class AsyncioBufferRelay(AsyncBufferRelay[T]):
+    def __init__(
+            self,
+            *,
+            event: ta.Optional[asyncio.Event] = None,
+            loop: ta.Optional[ta.Any] = None,
+    ) -> None:
+        if event is None:
+            event = asyncio.Event()
+        self._event = event
+        if loop is None:
+            loop = asyncio.get_running_loop()
+        self._loop = loop
+
+        self._relay: SyncBufferRelay[T] = SyncBufferRelay(
+            wake_fn=lambda: loop.call_soon_threadsafe(event.set),  # type: ignore[arg-type]
+        )
+
+    def push(self, *vs: T) -> None:
+        self._relay.push(*vs)
+
+    def swap(self) -> ta.Sequence[T]:
+        return self._relay.swap()
+
+    async def wait(self) -> None:
+        await self._event.wait()
+        self._event.clear()

omlish/asyncs/sync.py

@@ -0,0 +1,25 @@
+# @omlish-lite
+import abc
+import typing as ta
+
+from ..lite.abstract import Abstract
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class AsyncBufferRelay(Abstract, ta.Generic[T]):
+    @abc.abstractmethod
+    def push(self, *vs: T) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def swap(self) -> ta.Sequence[T]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def wait(self) -> None:
+        raise NotImplementedError

omlish/http/all.py

@@ -30,9 +30,13 @@ with _lang.auto_proxy_init(globals()):
 
     from .clients.default import (  # noqa
         client,
+        manage_client,
+
         request,
 
         async_client,
+        manage_async_client,
+
         async_request,
     )
 

omlish/http/clients/asyncs.py

@@ -3,13 +3,15 @@
 import abc
 import contextlib
 import dataclasses as dc
+import io
 import typing as ta
 
 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
@@ -26,21 +28,26 @@ AsyncHttpClientT = ta.TypeVar('AsyncHttpClientT', bound='AsyncHttpClient')
 @dc.dataclass(frozen=True)  # kw_only=True
 class AsyncStreamHttpResponse(BaseHttpResponse):
     class Stream(ta.Protocol):
-        def read(self, /, n: int = -1) -> ta.Awaitable[bytes]: ...
+        def read1(self, /, n: int = -1) -> ta.Awaitable[bytes]: ...
 
     @ta.final
     class _NullStream:
-        def read(self, /, n: int = -1) -> ta.Awaitable[bytes]:
+        def read1(self, /, n: int = -1) -> ta.Awaitable[bytes]:
             raise TypeError
 
     stream: Stream = _NullStream()
 
-    _closer: ta.Optional[ta.Callable[[], ta.Awaitable[None]]] = None
+    @property
+    def has_data(self) -> bool:
+        return not isinstance(self.stream, AsyncStreamHttpResponse._NullStream)
+
+    async def read_all(self) -> bytes:
+        buf = io.BytesIO()
+        while (b := await self.stream.read1()):
+            buf.write(b)
+        return buf.getvalue()
 
-    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,7 +57,7 @@ class AsyncStreamHttpResponse(BaseHttpResponse):
 
     async def close(self) -> None:
         if (c := self._closer) is not None:
-            c()
+            await c()
 
 
 #
@@ -88,10 +95,9 @@ async def async_read_response(resp: BaseHttpResponse) -> 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,
+            **({'data': await resp.read_all()} if resp.has_data else {}),
         })
 
     else:
@@ -101,7 +107,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,10 +118,12 @@ class AsyncHttpClient(Abstract):
             self,
             req: HttpRequest,
             *,
+            context: ta.Optional[HttpClientContext] = None,
             check: bool = False,
     ) -> HttpResponse:
         async with async_closing_response(await self.stream_request(
                 req,
+                context=context,
                 check=check,
         )) as resp:
             return await async_read_response(resp)
@@ -124,9 +132,13 @@ class AsyncHttpClient(Abstract):
             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:
@@ -143,5 +155,5 @@ class AsyncHttpClient(Abstract):
         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,170 @@
+# @omlish-lite
+# ruff: noqa: UP045
+import errno
+import socket
+import typing as ta
+import urllib.parse
+
+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=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()

omlish/http/clients/default.py

@@ -1,9 +1,11 @@
 import abc
+import contextlib
 import typing as ta
 
 from ... import lang
 from ..headers import CanHttpHeaders
 from .asyncs import AsyncHttpClient
+from .base import HttpClientContext
 from .base import HttpRequest
 from .base import HttpResponse
 from .sync import HttpClient
@@ -32,12 +34,13 @@ class _DefaultRequester(lang.Abstract, ta.Generic[C, R]):
 
             timeout_s: float | None = None,
 
+            context: HttpClientContext | None = None,
             check: bool = False,
             client: C | None = None,  # noqa
 
             **kwargs: ta.Any,
     ) -> R:
-        req = HttpRequest(
+        request = HttpRequest(  # noqa
             url,
             method=method,
 
@@ -50,7 +53,8 @@ class _DefaultRequester(lang.Abstract, ta.Generic[C, R]):
         )
 
         return self._do(
-            req,
+            request,
+            context=context,
             check=check,
             client=client,
         )
@@ -58,8 +62,9 @@ class _DefaultRequester(lang.Abstract, ta.Generic[C, R]):
     @abc.abstractmethod
     def _do(
             self,
-            req: HttpRequest,
+            request: HttpRequest,  # noqa
             *,
+            context: HttpClientContext | None = None,
             check: bool = False,
             client: C | None = None,  # noqa
     ) -> R:
@@ -77,30 +82,74 @@ def client() -> HttpClient:
     return _default_client()
 
 
+@contextlib.contextmanager
+def manage_client(client: HttpClient | None) -> ta.Generator[HttpClient]:  # noqa
+    if client is not None:
+        yield client
+
+    else:
+        with _default_client() as client:  # noqa
+            yield client
+
+
 #
 
 
-class _SyncDefaultRequester(_DefaultRequester[HttpClient, HttpResponse]):
+class _BaseSyncDefaultRequester(_DefaultRequester[HttpClient, R], lang.Abstract, ta.Generic[R]):
     def _do(
             self,
-            req: HttpRequest,
+            request: HttpRequest,  # noqa
             *,
+            context: HttpClientContext | None = None,
             check: bool = False,
             client: HttpClient | None = None,  # noqa
-    ) -> HttpResponse:
-        def do(cli: HttpClient) -> HttpResponse:  # noqa
-            return cli.request(
-                req,
+    ) -> R:
+        if context is None:
+            context = HttpClientContext()
 
+        if client is not None:
+            return self._do_(
+                client,
+                context,
+                request,
                 check=check,
             )
 
-        if client is not None:
-            return do(client)
-
         else:
-            with _default_client() as cli:
-                return do(cli)
+            with _default_client() as client:  # noqa
+                return self._do_(
+                    client,
+                    context,
+                    request,
+                    check=check,
+                )
+
+    @abc.abstractmethod
+    def _do_(
+            self,
+            client: HttpClient,  # noqa
+            context: HttpClientContext,
+            request: HttpRequest,  # noqa
+            *,
+            check: bool = False,  # noqa
+    ) -> R:
+        raise NotImplementedError
+
+
+class _SyncDefaultRequester(_BaseSyncDefaultRequester[HttpResponse]):
+    def _do_(
+            self,
+            client: HttpClient,  # noqa
+            context: HttpClientContext,
+            request: HttpRequest,  # noqa
+            *,
+            check: bool = False,  # noqa
+    ) -> HttpResponse:
+        return client.request(
+            request,
+            context=context,
+            check=check,
+        )
 
 
 request = _SyncDefaultRequester()
@@ -117,30 +166,74 @@ def async_client() -> AsyncHttpClient:
     return _default_async_client()
 
 
+@contextlib.asynccontextmanager
+async def manage_async_client(client: AsyncHttpClient | None) -> ta.AsyncGenerator[AsyncHttpClient]:  # noqa
+    if client is not None:
+        yield client
+
+    else:
+        async with _default_async_client() as client:  # noqa
+            yield client
+
+
 #
 
 
-class _AsyncDefaultRequester(_DefaultRequester[AsyncHttpClient, ta.Awaitable[HttpResponse]]):
+class _BaseAsyncDefaultRequester(_DefaultRequester[AsyncHttpClient, ta.Awaitable[R]], lang.Abstract, ta.Generic[R]):
     async def _do(
             self,
-            req: HttpRequest,
+            request: HttpRequest,  # noqa
             *,
+            context: HttpClientContext | None = None,
             check: bool = False,
             client: AsyncHttpClient | None = None,  # noqa
-    ) -> HttpResponse:
-        async def do(cli: AsyncHttpClient) -> HttpResponse:  # noqa
-            return await cli.request(
-                req,
+    ) -> R:
+        if context is None:
+            context = HttpClientContext()
 
+        if client is not None:
+            return await self._do_(
+                client,
+                context,
+                request,
                 check=check,
             )
 
-        if client is not None:
-            return await do(client)
-
         else:
-            async with _default_async_client() as cli:
-                return await do(cli)
+            async with _default_async_client() as client:  # noqa
+                return await self._do_(
+                    client,
+                    context,
+                    request,
+                    check=check,
+                )
+
+    @abc.abstractmethod
+    def _do_(
+            self,
+            client: AsyncHttpClient,  # noqa
+            context: HttpClientContext,
+            request: HttpRequest,  # noqa
+            *,
+            check: bool = False,  # noqa
+    ) -> ta.Awaitable[R]:
+        raise NotImplementedError
+
+
+class _AsyncDefaultRequester(_BaseAsyncDefaultRequester[HttpResponse]):
+    async def _do_(
+            self,
+            client: AsyncHttpClient,  # noqa
+            context: HttpClientContext,
+            request: HttpRequest,  # noqa
+            *,
+            check: bool = False,
+    ) -> HttpResponse:  # noqa
+        return await client.request(
+            request,
+            context=context,
+            check=check,
+        )
 
 
 async_request = _AsyncDefaultRequester()

omlish/http/clients/executor.py

@@ -0,0 +1,50 @@
+# ruff: noqa: UP043 UP045
+# @omlish-lite
+import dataclasses as dc
+import typing as ta
+
+from .asyncs import AsyncHttpClient
+from .asyncs import AsyncStreamHttpResponse
+from .base import HttpClientContext
+from .base import HttpRequest
+from .sync import HttpClient
+from .sync import StreamHttpResponse
+
+
+##
+
+
+class ExecutorAsyncHttpClient(AsyncHttpClient):
+    def __init__(
+            self,
+            run_in_executor: ta.Callable[..., ta.Awaitable],
+            client: HttpClient,
+    ) -> None:
+        super().__init__()
+
+        self._run_in_executor = run_in_executor
+        self._client = client
+
+    @dc.dataclass(frozen=True)
+    class _StreamAdapter:
+        owner: 'ExecutorAsyncHttpClient'
+        resp: StreamHttpResponse
+
+        async def read1(self, /, n: int = -1) -> bytes:
+            return await self.owner._run_in_executor(self.resp.stream.read1, n)  # noqa
+
+        async def close(self) -> None:
+            return await self.owner._run_in_executor(self.resp.close)  # noqa
+
+    async def _stream_request(self, ctx: HttpClientContext, req: HttpRequest) -> AsyncStreamHttpResponse:
+        resp: StreamHttpResponse = await self._run_in_executor(lambda: self._client.stream_request(req, context=ctx))
+        return AsyncStreamHttpResponse(
+            status=resp.status,
+            headers=resp.headers,
+            request=req,
+            underlying=resp,
+            **(dict(  # type: ignore
+                stream=(adapter := self._StreamAdapter(self, resp)),
+                _closer=adapter.close,
+            ) if resp.has_data else {}),
+        )