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

omlish/http/clients/base.py

@@ -1,18 +1,20 @@
+# ruff: noqa: UP006 UP007 UP045
+# @omlish-lite
 """
 TODO:
+ - ?? lite ?? whole point is an async client in lite code
  - stream
   - chunk size - httpx interface is awful, punch through?
  - httpx catch
  - return non-200 HttpResponses
  - async
 """
-import abc
-import contextlib
+import dataclasses as dc
 import typing as ta
 
-from ... import cached
-from ... import dataclasses as dc
-from ... import lang
+from ...lite.abstract import Abstract
+from ...lite.attrops import AttrOps
+from ...lite.cached import cached_property
 from ..headers import CanHttpHeaders
 from ..headers import HttpHeaders
 
@@ -33,17 +35,28 @@ def is_success_status(status: int) -> bool:
 ##
 
 
+@ta.final
 @dc.dataclass(frozen=True)
-class HttpRequest(lang.Final):
+class HttpRequest:
     url: str
-    method: str | None = None  # noqa
+    method: ta.Optional[str] = None  # noqa
 
-    _: dc.KW_ONLY
+    # _: dc.KW_ONLY
 
-    headers: CanHttpHeaders | None = dc.xfield(None, repr=dc.truthy_repr)
-    data: bytes | str | None = dc.xfield(None, repr_fn=lambda v: '...' if v is not None else None)
+    headers: ta.Optional[CanHttpHeaders] = None
+    data: ta.Union[bytes, str, None] = None
 
-    timeout_s: float | None = None
+    timeout_s: ta.Optional[float] = None
+
+    #
+
+    __repr__ = AttrOps['HttpRequest'](lambda o: (
+        o.url,
+        o.method,
+        (o.headers, dict(repr_fn=AttrOps.truthy_repr)),
+        (o.data, dict(repr_fn=lambda v: '...' if v is not None else None)),
+        (o.timeout_s, dict(repr_fn=AttrOps.opt_repr)),
+    )).repr
 
     #
 
@@ -55,151 +68,79 @@ class HttpRequest(lang.Final):
             return 'POST'
         return 'GET'
 
-    @cached.property
-    def headers_(self) -> HttpHeaders | None:
+    @cached_property
+    def headers_(self) -> ta.Optional[HttpHeaders]:
         return HttpHeaders(self.headers) if self.headers is not None else None
 
 
 #
 
 
-@dc.dataclass(frozen=True, kw_only=True)
-class BaseHttpResponse(lang.Abstract):
-    status: int
-
-    headers: HttpHeaders | None = dc.xfield(None, repr=dc.truthy_repr)
-
+@dc.dataclass(frozen=True)  # kw_only=True
+class BaseHttpResponse(Abstract):
     request: HttpRequest
-    underlying: ta.Any = dc.field(default=None, repr=False)
-
-    @property
-    def is_success(self) -> bool:
-        return is_success_status(self.status)
-
-
-@dc.dataclass(frozen=True, kw_only=True)
-class HttpResponse(BaseHttpResponse, lang.Final):
-    data: bytes | None = dc.xfield(None, repr_fn=lambda v: '...' if v is not None else None)
-
-
-@dc.dataclass(frozen=True, kw_only=True)
-class StreamHttpResponse(BaseHttpResponse, lang.Final):
-    class Stream(ta.Protocol):
-        def read(self, /, n: int = -1) -> bytes: ...
-
-    stream: Stream
 
-    _closer: ta.Callable[[], None] | None = dc.field(default=None, repr=False)
-
-    def __enter__(self) -> ta.Self:
-        return self
+    status: int
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
+    headers: ta.Optional[HttpHeaders] = None
 
-    def close(self) -> None:
-        if (c := self._closer) is not None:
-            c()
+    underlying: ta.Any = None
 
+    #
 
-def close_response(resp: BaseHttpResponse) -> None:
-    if isinstance(resp, HttpResponse):
-        pass
+    __repr__ = AttrOps['BaseHttpResponse'](lambda o: (
+        o.status,
+        (o.headers, dict(repr_fn=AttrOps.truthy_repr)),
+        o.request,
+    )).repr
 
-    elif isinstance(resp, StreamHttpResponse):
-        resp.close()
+    #
 
-    else:
-        raise TypeError(resp)
+    @property
+    def is_success(self) -> bool:
+        return is_success_status(self.status)
 
 
-@contextlib.contextmanager
-def closing_response(resp: BaseHttpResponseT) -> ta.Iterator[BaseHttpResponseT]:
-    if isinstance(resp, HttpResponse):
-        yield resp
-        return
+@ta.final
+@dc.dataclass(frozen=True)  # kw_only=True
+class HttpResponse(BaseHttpResponse):
+    data: ta.Optional[bytes] = None
 
-    elif isinstance(resp, StreamHttpResponse):
-        with contextlib.closing(resp):
-            yield resp
+    #
 
-    else:
-        raise TypeError(resp)
+    __repr__ = AttrOps['HttpResponse'](lambda o: (
+        o.status,
+        (o.headers, dict(repr_fn=AttrOps.truthy_repr)),
+        (o.data, dict(repr_fn=lambda v: '...' if v is not None else None)),
+        o.request,
+    )).repr
 
 
-def read_response(resp: BaseHttpResponse) -> HttpResponse:
-    if isinstance(resp, HttpResponse):
-        return resp
+##
 
-    elif isinstance(resp, StreamHttpResponse):
-        data = resp.stream.read()
-        return HttpResponse(**{
-            **{k: v for k, v in dc.shallow_asdict(resp).items() if k not in ('stream', '_closer')},
-            'data': data,
-        })
 
-    else:
-        raise TypeError(resp)
+@ta.final
+class HttpClientContext:
+    def __init__(self) -> None:
+        self._dct: dict = {}
 
 
-#
+##
 
 
 class HttpClientError(Exception):
     @property
-    def cause(self) -> BaseException | None:
+    def cause(self) -> ta.Optional[BaseException]:
         return self.__cause__
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass()
 class HttpStatusError(HttpClientError):
     response: HttpResponse
 
 
-#
+##
 
 
-class HttpClient(lang.Abstract):
-    def __enter__(self) -> ta.Self:
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        pass
-
-    def request(
-            self,
-            req: HttpRequest,
-            *,
-            check: bool = False,
-    ) -> HttpResponse:
-        with closing_response(self.stream_request(
-            req,
-            check=check,
-        )) as resp:
-            return read_response(resp)
-
-    def stream_request(
-            self,
-            req: HttpRequest,
-            *,
-            check: bool = False,
-    ) -> StreamHttpResponse:
-        resp = self._stream_request(req)
-
-        try:
-            if check and not resp.is_success:
-                if isinstance(resp.underlying, Exception):
-                    cause = resp.underlying
-                else:
-                    cause = None
-                raise HttpStatusError(read_response(resp)) from cause  # noqa
-
-        except Exception:
-            close_response(resp)
-            raise
-
-        return resp
-
-    @abc.abstractmethod
-    def _stream_request(self, req: HttpRequest) -> StreamHttpResponse:
-        raise NotImplementedError
+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()

omlish/http/clients/default.py

@@ -1,60 +1,239 @@
+import abc
+import contextlib
 import typing as ta
 
+from ... import lang
 from ..headers import CanHttpHeaders
-from .base import HttpClient
+from .asyncs import AsyncHttpClient
+from .base import HttpClientContext
 from .base import HttpRequest
 from .base import HttpResponse
-from .urllib import UrllibHttpClient
+from .sync import HttpClient
+
+
+with lang.auto_proxy_import(globals()):
+    from . import httpx as _httpx
+    from . import urllib as _urllib
+
+
+C = ta.TypeVar('C')
+R = ta.TypeVar('R')
+
+
+##
+
+
+class _DefaultRequester(lang.Abstract, ta.Generic[C, R]):
+    def __call__(
+            self,
+            url: str,
+            method: str | None = None,
+            *,
+            headers: CanHttpHeaders | None = None,
+            data: bytes | str | None = None,
+
+            timeout_s: float | None = None,
+
+            context: HttpClientContext | None = None,
+            check: bool = False,
+            client: C | None = None,  # noqa
+
+            **kwargs: ta.Any,
+    ) -> R:
+        request = HttpRequest(  # noqa
+            url,
+            method=method,
+
+            headers=headers,
+            data=data,
+
+            timeout_s=timeout_s,
+
+            **kwargs,
+        )
+
+        return self._do(
+            request,
+            context=context,
+            check=check,
+            client=client,
+        )
+
+    @abc.abstractmethod
+    def _do(
+            self,
+            request: HttpRequest,  # noqa
+            *,
+            context: HttpClientContext | None = None,
+            check: bool = False,
+            client: C | None = None,  # noqa
+    ) -> R:
+        raise NotImplementedError
 
 
 ##
 
 
 def _default_client() -> HttpClient:
-    return UrllibHttpClient()
+    return _urllib.UrllibHttpClient()
 
 
 def client() -> HttpClient:
     return _default_client()
 
 
-def request(
-        url: str,
-        method: str | None = None,
-        *,
-        headers: CanHttpHeaders | None = None,
-        data: bytes | str | None = None,
+@contextlib.contextmanager
+def manage_client(client: HttpClient | None = None) -> ta.Generator[HttpClient]:  # noqa
+    if client is not None:
+        yield client
+
+    else:
+        with _default_client() as client:  # noqa
+            yield client
+
+
+#
+
+
+class _BaseSyncDefaultRequester(_DefaultRequester[HttpClient, R], lang.Abstract, ta.Generic[R]):
+    def _do(
+            self,
+            request: HttpRequest,  # noqa
+            *,
+            context: HttpClientContext | None = None,
+            check: bool = False,
+            client: HttpClient | None = None,  # noqa
+    ) -> R:
+        if context is None:
+            context = HttpClientContext()
+
+        if client is not None:
+            return self._do_(
+                client,
+                context,
+                request,
+                check=check,
+            )
+
+        else:
+            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()
 
-        timeout_s: float | None = None,
 
-        check: bool = False,
+##
 
-        client: HttpClient | None = None,  # noqa
 
-        **kwargs: ta.Any,
-) -> HttpResponse:
-    req = HttpRequest(
-        url,
-        method=method,
+def _default_async_client() -> AsyncHttpClient:
+    return _httpx.HttpxAsyncHttpClient()
 
-        headers=headers,
-        data=data,
 
-        timeout_s=timeout_s,
+def async_client() -> AsyncHttpClient:
+    return _default_async_client()
 
-        **kwargs,
-    )
 
-    def do(cli: HttpClient) -> HttpResponse:
-        return cli.request(
-            req,
+@contextlib.asynccontextmanager
+async def manage_async_client(client: AsyncHttpClient | None = None) -> ta.AsyncGenerator[AsyncHttpClient]:  # noqa
+    if client is not None:
+        yield client
 
+    else:
+        async with _default_async_client() as client:  # noqa
+            yield client
+
+
+#
+
+
+class _BaseAsyncDefaultRequester(_DefaultRequester[AsyncHttpClient, ta.Awaitable[R]], lang.Abstract, ta.Generic[R]):
+    async def _do(
+            self,
+            request: HttpRequest,  # noqa
+            *,
+            context: HttpClientContext | None = None,
+            check: bool = False,
+            client: AsyncHttpClient | None = None,  # noqa
+    ) -> R:
+        if context is None:
+            context = HttpClientContext()
+
+        if client is not None:
+            return await self._do_(
+                client,
+                context,
+                request,
+                check=check,
+            )
+
+        else:
+            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,
         )
 
-    if client is not None:
-        return do(client)
 
-    else:
-        with _default_client() as cli:
-            return do(cli)
+async_request = _AsyncDefaultRequester()