omlish 0.0.0.dev278__py3-none-any.whl → 0.0.0.dev280__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev278'
-__revision__ = '8c2d6a9db875d1122353ed124741768f37aeaa66'
+__version__ = '0.0.0.dev280'
+__revision__ = '7ffe9145bdd2895b005e12042a6b5d4437d4e634'
 
 
 #

omlish/asyncs/anyio/subprocesses.py

@@ -0,0 +1,85 @@
+import io
+import subprocess
+import sys
+import typing as ta
+
+import anyio.abc
+
+from ... import check
+from ...lite.timeouts import Timeout
+from ...subprocesses.async_ import AbstractAsyncSubprocesses
+from ...subprocesses.run import SubprocessRun
+from ...subprocesses.run import SubprocessRunOutput
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class AnyioSubprocesses(AbstractAsyncSubprocesses):
+    async def run_(self, run: SubprocessRun) -> SubprocessRunOutput:
+        kwargs = dict(run.kwargs or {})
+
+        if run.capture_output:
+            kwargs.setdefault('stdout', subprocess.PIPE)
+            kwargs.setdefault('stderr', subprocess.PIPE)
+
+        with anyio.fail_after(Timeout.of(run.timeout).or_(None)):
+            async with await anyio.open_process(
+                    run.cmd,
+                    **kwargs,
+            ) as proc:
+                async def read_output(stream: anyio.abc.ByteReceiveStream, writer: ta.IO) -> None:
+                    while True:
+                        try:
+                            data = await stream.receive()
+                        except anyio.EndOfStream:
+                            return
+                        writer.write(data)
+
+                stdout: io.BytesIO | None = None
+                stderr: io.BytesIO | None = None
+                async with anyio.create_task_group() as tg:
+                    if proc.stdout is not None:
+                        stdout = io.BytesIO()
+                        tg.start_soon(read_output, proc.stdout, stdout)
+
+                    if proc.stderr is not None:
+                        stderr = io.BytesIO()
+                        tg.start_soon(read_output, proc.stderr, stderr)
+
+                if proc.stdin and run.input is not None:
+                    await proc.stdin.send(run.input)
+                    await proc.stdin.aclose()
+
+                await proc.wait()
+
+        if run.check and proc.returncode != 0:
+            raise subprocess.CalledProcessError(
+                ta.cast(int, proc.returncode),
+                run.cmd,
+                stdout.getvalue() if stdout is not None else None,
+                stderr.getvalue() if stderr is not None else None,
+            )
+
+        return SubprocessRunOutput(
+            proc=proc,
+
+            returncode=check.isinstance(proc.returncode, int),
+
+            stdout=stdout.getvalue() if stdout is not None else None,
+            stderr=stderr.getvalue() if stderr is not None else None,
+        )
+
+    async def check_call(self, *cmd: str, stdout: ta.Any = sys.stderr, **kwargs: ta.Any) -> None:
+        with self.prepare_and_wrap(*cmd, stdout=stdout, check=True, **kwargs) as (cmd, kwargs):  # noqa
+            await self.run(*cmd, **kwargs)
+
+    async def check_output(self, *cmd: str, **kwargs: ta.Any) -> bytes:
+        with self.prepare_and_wrap(*cmd, stdout=subprocess.PIPE, check=True, **kwargs) as (cmd, kwargs):  # noqa
+            return check.not_none((await self.run(*cmd, **kwargs)).stdout)
+
+
+anyio_subprocesses = AnyioSubprocesses()

omlish/collections/identity.py

@@ -122,6 +122,7 @@ class IdentityWeakSet(ta.MutableSet[T]):
         self._dict: weakref.WeakValueDictionary[int, T] = weakref.WeakValueDictionary()
 
     def add(self, value):
+        # FIXME: race with weakref callback?
         self._dict[id(value)] = value
 
     def discard(self, value):
@@ -131,7 +132,11 @@ class IdentityWeakSet(ta.MutableSet[T]):
             pass
 
     def __contains__(self, x):
-        return id(x) in self._dict
+        try:
+            o = self._dict[id(x)]
+        except KeyError:
+            return False
+        return x is o
 
     def __len__(self):
         return len(self._dict)

omlish/dataclasses/impl/main.py

@@ -49,7 +49,11 @@ class MainProcessor:
             raise TypeError('weakref_slot is True but slots is False')
         if not self._info.params.slots:
             return
-        self._cls = add_slots(self._cls, self._info.params.frozen, self._info.params.weakref_slot)
+        self._cls = add_slots(
+            self._cls,
+            is_frozen=self._info.params.frozen,
+            weakref_slot=self._info.params.weakref_slot,
+        )
 
     PROCESSOR_TYPES: ta.ClassVar[ta.Sequence[type[Processor]]] = [
         FieldsProcessor,

omlish/dataclasses/impl/metaclass.py

@@ -196,15 +196,6 @@ class Data(
         # Typechecking barrier
         super().__init_subclass__(**kwargs)
 
-    def __post_init__(self, *args, **kwargs) -> None:
-        try:
-            spi = super().__post_init__  # type: ignore  # noqa
-        except AttributeError:
-            if args or kwargs:
-                raise TypeError(args, kwargs) from None
-        else:
-            spi(*args, **kwargs)
-
 
 class Frozen(
     Data,

omlish/dataclasses/impl/slots.py

@@ -61,6 +61,7 @@ def _update_func_cell_for__class__(f, oldcls, newcls):
 
 def add_slots(
         cls: type,
+        *,
         is_frozen: bool,
         weakref_slot: bool,
 ) -> type:

omlish/http/clients/__init__.py

@@ -0,0 +1,34 @@
+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/base.py

@@ -0,0 +1,205 @@
+"""
+TODO:
+ - stream
+  - chunk size - httpx interface is awful, punch through?
+ - httpx catch
+ - return non-200 HttpResponses
+ - async
+"""
+import abc
+import contextlib
+import typing as ta
+
+from ... import cached
+from ... import dataclasses as dc
+from ... import lang
+from ..headers import CanHttpHeaders
+from ..headers import HttpHeaders
+
+
+BaseHttpResponseT = ta.TypeVar('BaseHttpResponseT', bound='BaseHttpResponse')
+
+
+##
+
+
+DEFAULT_ENCODING = 'utf-8'
+
+
+def is_success_status(status: int) -> bool:
+    return 200 <= status < 300
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class HttpRequest(lang.Final):
+    url: str
+    method: str | None = None  # noqa
+
+    _: 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)
+
+    timeout_s: float | None = None
+
+    #
+
+    @property
+    def method_or_default(self) -> str:
+        if self.method is not None:
+            return self.method
+        if self.data is not None:
+            return 'POST'
+        return 'GET'
+
+    @cached.property
+    def headers_(self) -> HttpHeaders | None:
+        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)
+
+    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
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self) -> None:
+        if (c := self._closer) is not None:
+            c()
+
+
+def close_response(resp: BaseHttpResponse) -> None:
+    if isinstance(resp, HttpResponse):
+        pass
+
+    elif isinstance(resp, StreamHttpResponse):
+        resp.close()
+
+    else:
+        raise TypeError(resp)
+
+
+@contextlib.contextmanager
+def closing_response(resp: BaseHttpResponseT) -> ta.Iterator[BaseHttpResponseT]:
+    if isinstance(resp, HttpResponse):
+        yield resp  # type: ignore
+        return
+
+    elif isinstance(resp, StreamHttpResponse):
+        with contextlib.closing(resp):
+            yield resp  # type: ignore
+
+    else:
+        raise TypeError(resp)
+
+
+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)
+
+
+#
+
+
+class HttpClientError(Exception):
+    @property
+    def cause(self) -> BaseException | None:
+        return self.__cause__
+
+
+@dc.dataclass(frozen=True)
+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

omlish/http/clients/default.py

@@ -0,0 +1,60 @@
+import typing as ta
+
+from ..headers import CanHttpHeaders
+from .base import HttpClient
+from .base import HttpRequest
+from .base import HttpResponse
+from .urllib import UrllibHttpClient
+
+
+##
+
+
+def _default_client() -> HttpClient:
+    return UrllibHttpClient()
+
+
+def client() -> HttpClient:
+    return _default_client()
+
+
+def request(
+        url: str,
+        method: str | None = None,
+        *,
+        headers: CanHttpHeaders | None = None,
+        data: bytes | str | None = None,
+
+        timeout_s: float | None = None,
+
+        check: bool = False,
+
+        client: HttpClient | None = None,  # noqa
+
+        **kwargs: ta.Any,
+) -> HttpResponse:
+    req = HttpRequest(
+        url,
+        method=method,
+
+        headers=headers,
+        data=data,
+
+        timeout_s=timeout_s,
+
+        **kwargs,
+    )
+
+    def do(cli: HttpClient) -> HttpResponse:
+        return cli.request(
+            req,
+
+            check=check,
+        )
+
+    if client is not None:
+        return do(client)
+
+    else:
+        with _default_client() as cli:
+            return do(cli)

omlish/http/clients/httpx.py

@@ -0,0 +1,68 @@
+import functools
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+from ..headers import HttpHeaders
+from .base import HttpClient
+from .base import HttpClientError
+from .base import HttpRequest
+from .base import StreamHttpResponse
+
+
+if ta.TYPE_CHECKING:
+    import httpx
+else:
+    httpx = lang.proxy_import('httpx')
+
+
+##
+
+
+class HttpxHttpClient(HttpClient):
+    @dc.dataclass(frozen=True)
+    class _StreamAdapter:
+        it: ta.Iterator[bytes]
+
+        def read(self, /, n: int = -1) -> bytes:
+            if n < 0:
+                return b''.join(self.it)
+            else:
+                try:
+                    return next(self.it)
+                except StopIteration:
+                    return b''
+
+    def _stream_request(self, req: HttpRequest) -> StreamHttpResponse:
+        try:
+            resp_cm = httpx.stream(
+                method=req.method_or_default,
+                url=req.url,
+                headers=req.headers_ or None,  # type: ignore
+                content=req.data,
+                timeout=req.timeout_s,
+            )
+
+        except httpx.HTTPError as e:
+            raise HttpClientError from e
+
+        resp_close = functools.partial(resp_cm.__exit__, None, None, None)
+
+        try:
+            resp = resp_cm.__enter__()
+            return StreamHttpResponse(
+                status=resp.status_code,
+                headers=HttpHeaders(resp.headers.raw),
+                request=req,
+                underlying=resp,
+                stream=self._StreamAdapter(resp.iter_bytes()),
+                _closer=resp_close,  # type: ignore
+            )
+
+        except httpx.HTTPError as e:
+            resp_close()
+            raise HttpClientError from e
+
+        except Exception:
+            resp_close()
+            raise

omlish/http/clients/urllib.py

@@ -0,0 +1,79 @@
+import http.client
+import typing as ta
+import urllib.error
+import urllib.request
+
+from ..headers import HttpHeaders
+from .base import DEFAULT_ENCODING
+from .base import HttpClient
+from .base import HttpClientError
+from .base import HttpRequest
+from .base import StreamHttpResponse
+
+
+##
+
+
+class UrllibHttpClient(HttpClient):
+    def _build_request(self, req: HttpRequest) -> urllib.request.Request:
+        d: ta.Any
+        if (d := req.data) is not None:
+            if isinstance(d, str):
+                d = d.encode(DEFAULT_ENCODING)
+
+        # urllib headers are dumb dicts [1], and keys *must* be strings or it will automatically add problematic default
+        # headers because it doesn't see string keys in its header dict [2]. frustratingly it has no problem accepting
+        # bytes values though [3].
+        # [1]: https://github.com/python/cpython/blob/232b303e4ca47892f544294bf42e31dc34f0ec72/Lib/urllib/request.py#L319-L325  # noqa
+        # [2]: https://github.com/python/cpython/blob/232b303e4ca47892f544294bf42e31dc34f0ec72/Lib/urllib/request.py#L1276-L1279  # noqa
+        # [3]: https://github.com/python/cpython/blob/232b303e4ca47892f544294bf42e31dc34f0ec72/Lib/http/client.py#L1300-L1301  # noqa
+        h: dict[str, str] = {}
+        if hs := req.headers_:
+            for k, v in hs.strict_dct.items():
+                h[k.decode('ascii')] = v.decode('ascii')
+
+        return urllib.request.Request(  # noqa
+            req.url,
+            method=req.method_or_default,
+            headers=h,
+            data=d,
+        )
+
+    def _stream_request(self, req: HttpRequest) -> StreamHttpResponse:
+        try:
+            resp = urllib.request.urlopen(  # noqa
+                self._build_request(req),
+                timeout=req.timeout_s,
+            )
+
+        except urllib.error.HTTPError as e:
+            try:
+                return StreamHttpResponse(
+                    status=e.code,
+                    headers=HttpHeaders(e.headers.items()),
+                    request=req,
+                    underlying=e,
+                    stream=e,  # noqa
+                    _closer=e.close,
+                )
+
+            except Exception:
+                e.close()
+                raise
+
+        except (urllib.error.URLError, http.client.HTTPException) as e:
+            raise HttpClientError from e
+
+        try:
+            return StreamHttpResponse(
+                status=resp.status,
+                headers=HttpHeaders(resp.headers.items()),
+                request=req,
+                underlying=resp,
+                stream=resp,
+                _closer=resp.close,
+            )
+
+        except Exception:  # noqa
+            resp.close()
+            raise

omlish/lang/cached/function.py

@@ -1,5 +1,6 @@
 """
 TODO:
+ - !! specialize nullary, explicit kwarg
  - !! reconcile A().f() with A.f(A())
   - unbound descriptor *should* still hit instance cache
  - integrate / expose with collections.cache

{omlish-0.0.0.dev278.dist-info → omlish-0.0.0.dev280.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev278
+Version: 0.0.0.dev280
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev278.dist-info → omlish-0.0.0.dev280.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=pjGUyLHaoWpPqRP3jz2u1fC1qoRc2lvrEcpU_Ax2tdg,8253
-omlish/__about__.py,sha256=Dmy-Gwt1Dg_ioGn-8nv0aWBtdA4mRgseFv3sCSvWR5g,3380
+omlish/__about__.py,sha256=tomhvMbjsT0jtVBAtPgoqWQWYTlkWH2K_sC_ndp9_lI,3380
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=rer-TPOFDU6fYq_AWio_AmA-ckZ8JDY5shIzQ_yXfzA,8414
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -102,6 +102,7 @@ omlish/asyncs/anyio/backends.py,sha256=jJIymWoiedaEJJm82gvKiJ41EWLQZ-bcyNHpbDpKK
 omlish/asyncs/anyio/futures.py,sha256=Nm1gLerZEnHk-rlsmr0UfK168IWIK6zA8EebZFtoY_E,2052
 omlish/asyncs/anyio/signals.py,sha256=ySSut5prdnoy0-5Ws5V1M4cC2ON_vY550vU10d2NHk8,893
 omlish/asyncs/anyio/streams.py,sha256=gNRAcHR0L8OtNioqKFbq0Z_apYAWKHFipZ2MUBp8Vg0,2228
+omlish/asyncs/anyio/subprocesses.py,sha256=jjMjlcwtIiy-_y-spPn3eTC5dzrqFNSAMTPaIcXH9S8,3002
 omlish/asyncs/anyio/sync.py,sha256=ZmSNhSsEkPwlXThrpefhtVTxw4GJ9F0P-yKyo5vbbSk,1574
 omlish/asyncs/anyio/utils.py,sha256=X2Rz1DGrCJ0zkt1O5cHoMRaYKTPndBj6dzLhb09mVtE,1672
 omlish/asyncs/asyncio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -149,7 +150,7 @@ omlish/collections/coerce.py,sha256=tAls15v_7p5bUN33R7Zbko87KW5toWHl9fRialCqyNY,
 omlish/collections/exceptions.py,sha256=shcS-NCnEUudF8qC_SmO2TQyjivKlS4TDjaz_faqQ0c,44
 omlish/collections/frozen.py,sha256=LMbAHYDENIQk1hvjCTvpnx66m1TalrHa4CSn8n_tsXQ,4142
 omlish/collections/hasheq.py,sha256=swOBPEnU_C0SU3VqWJX9mr0BfZLD0A-4Ke9Vahj3fE4,3669
-omlish/collections/identity.py,sha256=cIcvGORpKAWpNxEleAiPxJJsMA9RmZ7LUSKacexgCxE,3276
+omlish/collections/identity.py,sha256=xtoczgBPYzr6r2lJS-eti2kEnN8rVDvNGDCG3TA6vRo,3405
 omlish/collections/mappings.py,sha256=u0UrB550nBM_RNXQV0YnBTbRZEWrplZe9ZxcCN3H65M,2789
 omlish/collections/ordered.py,sha256=7zTbrAt12rf6i33XHkQERKar258fJacaw_WbtGEBgWo,2338
 omlish/collections/ranked.py,sha256=rg6DL36oOUiG5JQEAkGnT8b6f9mSndQlIovtt8GQj_w,2229
@@ -216,8 +217,8 @@ omlish/dataclasses/impl/frozen.py,sha256=x87DSM8FIMZ3c_BIUE8NooCkExFjPsabeqIueEP
 omlish/dataclasses/impl/hashing.py,sha256=0Gr6XIRkKy4pr-mdHblIlQCy3mBxycjMqJk3oZDw43s,3215
 omlish/dataclasses/impl/init.py,sha256=CUM8Gnx171D3NO6FN4mlrIBoTcYiDqj_tqE9_NKKicg,6409
 omlish/dataclasses/impl/internals.py,sha256=UvZYjrLT1S8ntyxJ_vRPIkPOF00K8HatGAygErgoXTU,2990
-omlish/dataclasses/impl/main.py,sha256=LyWr8IBfoL-bBfweR4OqJgi842REDw20WRYcGSYNfMg,2577
-omlish/dataclasses/impl/metaclass.py,sha256=ebxJr3j8d_wz-fc7mvhWtJ6wJgnxVV6rVOQdqZ5avKw,5262
+omlish/dataclasses/impl/main.py,sha256=bWnqEDOfITjEwkLokTvOegp88KaQXJFun3krgxt3aE0,2647
+omlish/dataclasses/impl/metaclass.py,sha256=rhcMHNJYISgMkC95Yq14aLEs48iK9Rzma5yb7-4mPIk,4965
 omlish/dataclasses/impl/metadata.py,sha256=4veWwTr-aA0KP-Y1cPEeOcXHup9EKJTYNJ0ozIxtzD4,1401
 omlish/dataclasses/impl/order.py,sha256=zWvWDkSTym8cc7vO1cLHqcBhhjOlucHOCUVJcdh4jt0,1369
 omlish/dataclasses/impl/overrides.py,sha256=g9aCzaDDKyek8-yXRvtAcu1B1nCphWDYr4InHDlgbKk,1732
@@ -227,7 +228,7 @@ omlish/dataclasses/impl/reflect.py,sha256=ndX22d9bd9m_GAajPFQdnrw98AGw75lH9_tb-k
 omlish/dataclasses/impl/replace.py,sha256=wS9GHX4fIwaPv1JBJzIewdBfXyK3X3V7_t55Da87dYo,1217
 omlish/dataclasses/impl/repr.py,sha256=hk6HwKTLA0tb698CfiO8RYAqtpHQbGCpymm_Eo-B-2Y,1876
 omlish/dataclasses/impl/simple.py,sha256=Q272TYXifB5iKtydByxyzraeQHX6aXDY0VKO1-AKBF4,1771
-omlish/dataclasses/impl/slots.py,sha256=qXRLbtFWUs_2UV1fFUdv53_6fBLKJ_8McjNiP9YQlGM,5264
+omlish/dataclasses/impl/slots.py,sha256=uiUB391b2WG9Xak8ckXeGawhpc38dZEhEp60uQgiY-w,5275
 omlish/dataclasses/impl/utils.py,sha256=aER2iL3UAtgS1BdLuEvTr9Tr2wC28wk1kiOeO-jIymw,6138
 omlish/diag/__init__.py,sha256=4S8v0myJM4Zld6_FV6cPe_nSv0aJb6kXftEit0HkiGE,1141
 omlish/diag/asts.py,sha256=MWh9XAG3m9L10FIJCyoNT2aU4Eft6tun_x9K0riq6Dk,3332
@@ -331,7 +332,6 @@ omlish/graphs/dot/utils.py,sha256=_FMwn77WfiiAfLsRTOKWm4IYbNv5kQN22YJ5psw6CWg,80
 omlish/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/http/all.py,sha256=4dSBbitsrQIadivSo2rBLg8dgdmC0efpboylGUZgKKo,829
 omlish/http/asgi.py,sha256=wXhBZ21bEl32Kv9yBrRwUR_7pHEgVtHP8ZZwbasQ6-4,3307
-omlish/http/clients.py,sha256=gbR4Fl2C1fYpcfDEg_W9De3ImRARKFkRHoQkkG1AwRs,9558
 omlish/http/consts.py,sha256=7BJ4D1MdIvqBcepkgCfBFHolgTwbOlqsOEiee_IjxOA,2289
 omlish/http/cookies.py,sha256=uuOYlHR6e2SC3GM41V0aozK10nef9tYg83Scqpn5-HM,6351
 omlish/http/dates.py,sha256=Otgp8wRxPgNGyzx8LFowu1vC4EKJYARCiAwLFncpfHM,2875
@@ -346,6 +346,11 @@ omlish/http/sessions.py,sha256=TfTJ_j-6c9PelG_RmijEwozfaVm3O7YzgtFvp8VzQqM,4799
 omlish/http/sse.py,sha256=NwJnQj-hFXAkadXKhUuHSnbXHwDVJjhzfdkkHQ-prQo,2320
 omlish/http/versions.py,sha256=wSiOXPiClVjkVgSU_VmxkoD1SUYGaoPbP0U5Aw-Ufg8,409
 omlish/http/wsgi.py,sha256=czZsVUX-l2YTlMrUjKN49wRoP4rVpS0qpeBn4O5BoMY,948
+omlish/http/clients/__init__.py,sha256=SeH3ofjQvk7VuV9OE1uJir9QMZwvEuDl7fptkKgGQUU,449
+omlish/http/clients/base.py,sha256=8dQGHJyRxH9GFefdoG6HR-VAMsr1rCOti_M27NLAdJU,4658
+omlish/http/clients/default.py,sha256=fO8So3pI2z8ateLqt9Sv50UoOJFkUZbgMdoDyWsjBNw,1070
+omlish/http/clients/httpx.py,sha256=Grl9_sG7QNIZj8HqaU7XduAsBDyfXl36RjbYQzQqal0,1787
+omlish/http/clients/urllib.py,sha256=DVKFPLQzANiZmwnlbFw5pWs5ZPLLvvgCb3UInvCSqPE,2701
 omlish/http/coro/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/http/coro/fdio.py,sha256=bd9K4EYVWbXV3e3npDPXI9DuDAruJiyDmrgFpgNcjzY,4035
 omlish/http/coro/server.py,sha256=30FTcJG8kuFeThf0HJYpTzMZN-giLTBP7wr5Wl3b9X0,18285
@@ -438,7 +443,7 @@ omlish/lang/strings.py,sha256=egdv8PxLNG40-5V93agP5j2rBUDIsahCx048zV7uEbU,4690
 omlish/lang/sys.py,sha256=b4qOPiJZQru_mbb04FNfOjYWUxlV2becZOoc-yya_rQ,411
 omlish/lang/typing.py,sha256=Zdad9Zv0sa-hIaUXPrzPidT7sDVpRcussAI7D-j-I1c,3296
 omlish/lang/cached/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/lang/cached/function.py,sha256=3AeTVfpzovMMWbnjFuT5mM7kT1dBuk7fa66FOJKikYw,9188
+omlish/lang/cached/function.py,sha256=CqxYhpl1JK7eBkha_xPQ17c946W1PgnfMNpRaIPgRGc,9229
 omlish/lang/cached/property.py,sha256=kzbao_35PlszdK_9oJBWrMmFFlVK_Xhx7YczHhTJ6cc,2764
 omlish/lang/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/lang/classes/abstract.py,sha256=n4rDlDraUKxPF0GtOWEFZ6mEzEDmP7Z8LSI6Jww_thw,3715
@@ -784,9 +789,9 @@ omlish/typedvalues/holder.py,sha256=4SwRezsmuDDEO5gENGx8kTm30pblF5UktoEAu02i-Gk,
 omlish/typedvalues/marshal.py,sha256=eWMrmuzPk3pX5AlILc5YBvuJBUHRQA_vwkxRm5aHiGs,4209
 omlish/typedvalues/reflect.py,sha256=y_7IY8_4cLVRvD3ug-_-cDaO5RtzC1rLVFzkeAPALf8,683
 omlish/typedvalues/values.py,sha256=Acyf6xSdNHxrkRXLXrFqJouk35YOveso1VqTbyPwQW4,1223
-omlish-0.0.0.dev278.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev278.dist-info/METADATA,sha256=f1crVlpqO_vjVM0zC27geFcdLVJM_mYDfGA8y0Wnqxk,4198
-omlish-0.0.0.dev278.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-omlish-0.0.0.dev278.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev278.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev278.dist-info/RECORD,,
+omlish-0.0.0.dev280.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev280.dist-info/METADATA,sha256=cB-W0A9GSdEwu5Hr5ccj4cqL_r-KCNy3JQdUC85fo3A,4198
+omlish-0.0.0.dev280.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+omlish-0.0.0.dev280.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev280.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev280.dist-info/RECORD,,

omlish/http/clients.py

@@ -1,388 +0,0 @@
-"""
-TODO:
- - stream
-  - chunk size - httpx interface is awful, punch through?
- - httpx catch
- - return non-200 HttpResponses
- - async
-"""
-import abc
-import contextlib
-import functools
-import http.client
-import typing as ta
-import urllib.error
-import urllib.request
-
-from .. import cached
-from .. import dataclasses as dc
-from .. import lang
-from .headers import CanHttpHeaders
-from .headers import HttpHeaders
-
-
-if ta.TYPE_CHECKING:
-    import httpx
-else:
-    httpx = lang.proxy_import('httpx')
-
-
-BaseHttpResponseT = ta.TypeVar('BaseHttpResponseT', bound='BaseHttpResponse')
-
-
-##
-
-
-DEFAULT_ENCODING = 'utf-8'
-
-
-def is_success_status(status: int) -> bool:
-    return 200 <= status < 300
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class HttpRequest(lang.Final):
-    url: str
-    method: str | None = None  # noqa
-
-    _: 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)
-
-    timeout_s: float | None = None
-
-    #
-
-    @property
-    def method_or_default(self) -> str:
-        if self.method is not None:
-            return self.method
-        if self.data is not None:
-            return 'POST'
-        return 'GET'
-
-    @cached.property
-    def headers_(self) -> HttpHeaders | None:
-        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)
-
-    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
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
-
-    def close(self) -> None:
-        if (c := self._closer) is not None:
-            c()
-
-
-def close_response(resp: BaseHttpResponse) -> None:
-    if isinstance(resp, HttpResponse):
-        pass
-
-    elif isinstance(resp, StreamHttpResponse):
-        resp.close()
-
-    else:
-        raise TypeError(resp)
-
-
-@contextlib.contextmanager
-def closing_response(resp: BaseHttpResponseT) -> ta.Iterator[BaseHttpResponseT]:
-    if isinstance(resp, HttpResponse):
-        yield resp  # type: ignore
-        return
-
-    elif isinstance(resp, StreamHttpResponse):
-        with contextlib.closing(resp):
-            yield resp  # type: ignore
-
-    else:
-        raise TypeError(resp)
-
-
-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)
-
-
-#
-
-
-class HttpClientError(Exception):
-    @property
-    def cause(self) -> BaseException | None:
-        return self.__cause__
-
-
-@dc.dataclass(frozen=True)
-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 UrllibHttpClient(HttpClient):
-    def _build_request(self, req: HttpRequest) -> urllib.request.Request:
-        d: ta.Any
-        if (d := req.data) is not None:
-            if isinstance(d, str):
-                d = d.encode(DEFAULT_ENCODING)
-
-        # urllib headers are dumb dicts [1], and keys *must* be strings or it will automatically add problematic default
-        # headers because it doesn't see string keys in its header dict [2]. frustratingly it has no problem accepting
-        # bytes values though [3].
-        # [1]: https://github.com/python/cpython/blob/232b303e4ca47892f544294bf42e31dc34f0ec72/Lib/urllib/request.py#L319-L325  # noqa
-        # [2]: https://github.com/python/cpython/blob/232b303e4ca47892f544294bf42e31dc34f0ec72/Lib/urllib/request.py#L1276-L1279  # noqa
-        # [3]: https://github.com/python/cpython/blob/232b303e4ca47892f544294bf42e31dc34f0ec72/Lib/http/client.py#L1300-L1301  # noqa
-        h: dict[str, str] = {}
-        if hs := req.headers_:
-            for k, v in hs.strict_dct.items():
-                h[k.decode('ascii')] = v.decode('ascii')
-
-        return urllib.request.Request(  # noqa
-            req.url,
-            method=req.method_or_default,
-            headers=h,
-            data=d,
-        )
-
-    def _stream_request(self, req: HttpRequest) -> StreamHttpResponse:
-        try:
-            resp = urllib.request.urlopen(  # noqa
-                self._build_request(req),
-                timeout=req.timeout_s,
-            )
-
-        except urllib.error.HTTPError as e:
-            try:
-                return StreamHttpResponse(
-                    status=e.code,
-                    headers=HttpHeaders(e.headers.items()),
-                    request=req,
-                    underlying=e,
-                    stream=e,
-                    _closer=e.close,
-                )
-
-            except Exception:
-                e.close()
-                raise
-
-        except (urllib.error.URLError, http.client.HTTPException) as e:
-            raise HttpClientError from e
-
-        try:
-            return StreamHttpResponse(
-                status=resp.status,
-                headers=HttpHeaders(resp.headers.items()),
-                request=req,
-                underlying=resp,
-                stream=resp,
-                _closer=resp.close,
-            )
-
-        except Exception:  # noqa
-            resp.close()
-            raise
-
-
-##
-
-
-class HttpxHttpClient(HttpClient):
-    @dc.dataclass(frozen=True)
-    class _StreamAdapter:
-        it: ta.Iterator[bytes]
-
-        def read(self, /, n: int = -1) -> bytes:
-            if n < 0:
-                return b''.join(self.it)
-            else:
-                try:
-                    return next(self.it)
-                except StopIteration:
-                    return b''
-
-    def _stream_request(self, req: HttpRequest) -> StreamHttpResponse:
-        try:
-            resp_cm = httpx.stream(
-                method=req.method_or_default,
-                url=req.url,
-                headers=req.headers_ or None,  # type: ignore
-                content=req.data,
-                timeout=req.timeout_s,
-            )
-
-        except httpx.HTTPError as e:
-            raise HttpClientError from e
-
-        resp_close = functools.partial(resp_cm.__exit__, None, None, None)
-
-        try:
-            resp = resp_cm.__enter__()
-            return StreamHttpResponse(
-                status=resp.status_code,
-                headers=HttpHeaders(resp.headers.raw),
-                request=req,
-                underlying=resp,
-                stream=self._StreamAdapter(resp.iter_bytes()),
-                _closer=resp_close,  # type: ignore
-            )
-
-        except httpx.HTTPError as e:
-            resp_close()
-            raise HttpClientError from e
-
-        except Exception:
-            resp_close()
-            raise
-
-
-##
-
-
-def _default_client() -> HttpClient:
-    return UrllibHttpClient()
-
-
-def client() -> HttpClient:
-    return _default_client()
-
-
-def request(
-        url: str,
-        method: str | None = None,
-        *,
-        headers: CanHttpHeaders | None = None,
-        data: bytes | str | None = None,
-
-        timeout_s: float | None = None,
-
-        check: bool = False,
-
-        client: HttpClient | None = None,  # noqa
-
-        **kwargs: ta.Any,
-) -> HttpResponse:
-    req = HttpRequest(
-        url,
-        method=method,
-
-        headers=headers,
-        data=data,
-
-        timeout_s=timeout_s,
-
-        **kwargs,
-    )
-
-    def do(cli: HttpClient) -> HttpResponse:
-        return cli.request(
-            req,
-
-            check=check,
-        )
-
-    if client is not None:
-        return do(client)
-
-    else:
-        with _default_client() as cli:
-            return do(cli)