omlish 0.0.0.dev71__py3-none-any.whl → 0.0.0.dev72__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev71'
-__revision__ = '293695b11eeed255848dcf6beee9c4b4383d5c91'
+__version__ = '0.0.0.dev72'
+__revision__ = '4448e03bbb77cb149e46eeefb0e9e61faed2a494'
 
 
 #

omlish/formats/json/cli.py

@@ -13,6 +13,7 @@ from .render import JsonRenderer
 
 
 if ta.TYPE_CHECKING:
+    import ast
     import tomllib
 
     import yaml
@@ -21,6 +22,7 @@ if ta.TYPE_CHECKING:
     from .. import props
 
 else:
+    ast = lang.proxy_import('ast')
     tomllib = lang.proxy_import('tomllib')
 
     yaml = lang.proxy_import('yaml')
@@ -50,6 +52,7 @@ class Formats(enum.Enum):
     TOML = Format(['toml'], lambda f: tomllib.loads(f.read()))
     ENV = Format(['env', 'dotenv'], lambda f: dotenv.dotenv_values(stream=f))
     PROPS = Format(['properties', 'props'], lambda f: dict(props.Properties().load(f.read())))
+    PY = Format(['py', 'python', 'repr'], lambda f: ast.literal_eval(f.read()))
 
 
 FORMATS_BY_NAME: ta.Mapping[str, Format] = {

omlish/http/__init__.py

@@ -1,6 +1,6 @@
 from . import consts  # noqa
 
-from .client import (  # noqa
+from .clients import (  # noqa
     HttpClient,
     HttpClientError,
     HttpRequest,

omlish/http/clients.py

@@ -0,0 +1,239 @@
+"""
+TODO:
+ - check=False
+ - return non-200 HttpResponses
+ - async
+ - stream
+"""
+import abc
+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')
+
+
+##
+
+
+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 HttpResponse(lang.Final):
+    status: int
+
+    headers: HttpHeaders | None = dc.xfield(None, repr=dc.truthy_repr)
+    data: bytes | None = dc.xfield(None, repr_fn=lambda v: '...' if v is not None else None)
+
+    request: HttpRequest
+    underlying: ta.Any = dc.field(default=None, repr=False)
+
+    #
+
+    @property
+    def is_success(self) -> bool:
+        return is_success_status(self.status)
+
+
+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:
+        resp = self._request(req)
+
+        if check and not resp.is_success:
+            if isinstance(resp.underlying, Exception):
+                cause = resp.underlying
+            else:
+                cause = None
+            raise HttpStatusError(resp) from cause
+
+        return resp
+
+    @abc.abstractmethod
+    def _request(self, req: HttpRequest) -> HttpResponse:
+        raise NotImplementedError
+
+
+##
+
+
+class UrllibHttpClient(HttpClient):
+    def _request(self, req: HttpRequest) -> HttpResponse:
+        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 keys 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')
+
+        try:
+            with urllib.request.urlopen(  # noqa
+                    urllib.request.Request(  # noqa
+                        req.url,
+                        method=req.method_or_default,
+                        headers=h,
+                        data=d,
+                    ),
+                    timeout=req.timeout_s,
+            ) as resp:
+                return HttpResponse(
+                    status=resp.status,
+                    headers=HttpHeaders(resp.headers.items()),
+                    data=resp.read(),
+                    request=req,
+                    underlying=resp,
+                )
+
+        except urllib.error.HTTPError as e:
+            return HttpResponse(
+                status=e.code,
+                headers=HttpHeaders(e.headers.items()),
+                data=e.read(),
+                request=req,
+                underlying=e,
+            )
+
+        except (urllib.error.URLError, http.client.HTTPException) as e:
+            raise HttpClientError from e
+
+
+##
+
+
+class HttpxHttpClient(HttpClient):
+    def _request(self, req: HttpRequest) -> HttpResponse:
+        try:
+            response = httpx.request(
+                method=req.method_or_default,
+                url=req.url,
+                headers=req.headers_ or None,  # type: ignore
+                content=req.data,
+                timeout=req.timeout_s,
+            )
+
+            return HttpResponse(
+                status=response.status_code,
+                headers=HttpHeaders(response.headers.raw),
+                data=response.content,
+                request=req,
+                underlying=response,
+            )
+
+        except httpx.HTTPError as e:
+            raise HttpClientError from e
+
+
+##
+
+
+def client() -> HttpClient:
+    return UrllibHttpClient()
+
+
+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,
+
+        **kwargs: ta.Any,
+) -> HttpResponse:
+    req = HttpRequest(
+        url,
+        method=method,
+
+        headers=headers,
+        data=data,
+
+        timeout_s=timeout_s,
+
+        **kwargs,
+    )
+
+    with client() as cli:
+        return cli.request(
+            req,
+
+            check=check,
+        )

omlish/http/consts.py

@@ -64,5 +64,9 @@ BEARER_AUTH_HEADER_PREFIX = b'Bearer '
 BASIC_AUTH_HEADER_PREFIX = b'Basic '
 
 
+def format_bearer_auth_header(token: str | bytes) -> bytes:
+    return BEARER_AUTH_HEADER_PREFIX + (token.encode('ascii') if isinstance(token, str) else token)
+
+
 def format_basic_auth_header(username: str, password: str) -> bytes:
     return BASIC_AUTH_HEADER_PREFIX + base64.b64encode(':'.join([username, password]).encode())

omlish/http/headers.py

@@ -9,9 +9,20 @@ StrOrBytes: ta.TypeAlias = str | bytes
 
 CanHttpHeaders: ta.TypeAlias = ta.Union[
     'HttpHeaders',
+
+    ta.Mapping[str, str],
+    ta.Mapping[str, ta.Sequence[str]],
+
+    ta.Mapping[bytes, bytes],
+    ta.Mapping[bytes, ta.Sequence[bytes]],
+
     ta.Mapping[StrOrBytes, StrOrBytes],
     ta.Mapping[StrOrBytes, ta.Sequence[StrOrBytes]],
+
     ta.Mapping[StrOrBytes, StrOrBytes | ta.Sequence[StrOrBytes]],
+
+    ta.Sequence[tuple[str, str]],
+    ta.Sequence[tuple[bytes, bytes]],
     ta.Sequence[tuple[StrOrBytes, StrOrBytes]],
 ]
 
@@ -38,7 +49,11 @@ class HttpHeaders:
             raise TypeError(src)
 
         elif isinstance(src, ta.Sequence):
-            for k, v in src:
+            for t in src:
+                if isinstance(t, (str, bytes)):
+                    raise TypeError(t)
+
+                k, v = t
                 lst.append((self._as_bytes(k), self._as_bytes(v)))
 
         else:
@@ -74,9 +89,23 @@ class HttpHeaders:
 
     #
 
+    @property
+    def raw(self) -> ta.Sequence[tuple[bytes, bytes]]:
+        return self._lst
+
+    @classmethod
+    def _as_key(cls, o: StrOrBytes) -> bytes:
+        return cls._as_bytes(o).lower()
+
+    @cached.property
+    def normalized(self) -> ta.Sequence[tuple[bytes, bytes]]:
+        return [(self._as_key(k), v) for k, v in self._lst]
+
+    #
+
     @cached.property
     def multi_dct(self) -> ta.Mapping[bytes, ta.Sequence[bytes]]:
-        return col.multi_map(self._lst)
+        return col.multi_map(self.normalized)
 
     @cached.property
     def single_dct(self) -> ta.Mapping[bytes, bytes]:
@@ -84,13 +113,13 @@ class HttpHeaders:
 
     @cached.property
     def strict_dct(self) -> ta.Mapping[bytes, bytes]:
-        return col.make_map(self._lst, strict=True)
+        return col.make_map(self.normalized, strict=True)
 
     #
 
     @cached.property
     def strs(self) -> ta.Sequence[tuple[str, str]]:
-        return tuple((k.decode(self.ENCODING), v.decode(self.ENCODING)) for k, v in self._lst)
+        return tuple((k.decode(self.ENCODING), v.decode(self.ENCODING)) for k, v in self.normalized)
 
     @cached.property
     def multi_str_dct(self) -> ta.Mapping[str, ta.Sequence[str]]:
@@ -116,7 +145,11 @@ class HttpHeaders:
         return iter(self._lst)
 
     @ta.overload
-    def __getitem__(self, item: StrOrBytes) -> ta.Sequence[StrOrBytes]:
+    def __getitem__(self, item: str) -> ta.Sequence[str]:
+        ...
+
+    @ta.overload
+    def __getitem__(self, item: bytes) -> ta.Sequence[bytes]:
         ...
 
     @ta.overload
@@ -130,8 +163,10 @@ class HttpHeaders:
     def __getitem__(self, item):
         if isinstance(item, (int, slice)):
             return self._lst[item]
-        elif isinstance(item, (str, bytes)):
-            return self.multi_dct[self._as_bytes(item)]
+        elif isinstance(item, str):
+            return self.multi_str_dct[item.lower()]
+        elif isinstance(item, bytes):
+            return self.multi_dct[self._as_key(item)]
         else:
             raise TypeError(item)
 

{omlish-0.0.0.dev71.dist-info → omlish-0.0.0.dev72.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev71
+Version: 0.0.0.dev72
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev71.dist-info → omlish-0.0.0.dev72.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=TXvFdkAU0Zr2FKdo7fyvt9nr3UjCtrnAZ0diZXSAteE,1430
-omlish/__about__.py,sha256=UA4amXjbtRmwpmcjop8hOCA8ytGC55dHDjgDm1toVmM,3420
+omlish/__about__.py,sha256=Xtux9lxQlFpaTqHV9Xq7BumGnu8QP3C6l4R7wQX9F_w,3420
 omlish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/argparse.py,sha256=Dc73G8lyoQBLvXhMYUbzQUh4SJu_OTvKUXjSUxq_ang,7499
 omlish/c3.py,sha256=4vogWgwPb8TbNS2KkZxpoWbwjj7MuHG2lQG-hdtkvjI,8062
@@ -184,7 +184,7 @@ omlish/formats/props.py,sha256=JwFJbKblqzqnzXf7YKFzQSDfcAXzkKsfoYvad6FPy98,18945
 omlish/formats/yaml.py,sha256=DSJXUq9yanfxdS6ufNTyBHMtIZO57LRnJj4w9fLY1aM,6852
 omlish/formats/json/__init__.py,sha256=moSR67Qkju2eYb_qVDtaivepe44mxAnYuC8OCSbtETg,298
 omlish/formats/json/__main__.py,sha256=1wxxKZVkj_u7HCcewwMIbGuZj_Wph95yrUbm474Op9M,188
-omlish/formats/json/cli.py,sha256=4zftNijlIOnGUHYn5J1s4yRDRM1K4udBzS3Kh8R2vNc,3374
+omlish/formats/json/cli.py,sha256=pHFvYji6h_kMUyTgHCuDFofeDVY_5Em0wBqqVOJzDmI,3504
 omlish/formats/json/json.py,sha256=y8d8WWgzGZDTjzYc_xe9v4T0foXHI-UP7gjCwnHzUIA,828
 omlish/formats/json/render.py,sha256=6edhSrxXWW3nzRfokp5qaldT0_YAj-HVEan_rErf-vo,3208
 omlish/formats/json/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -200,15 +200,15 @@ omlish/graphs/dot/items.py,sha256=OWPf0-hjBgS1uyy2QgAEn4IgFHJcEg7sHVWeTx1ghZc,40
 omlish/graphs/dot/make.py,sha256=RN30gHfJPiXx5Q51kbDdhVJYf59Fr84Lz9J-mXRt9sI,360
 omlish/graphs/dot/rendering.py,sha256=2UgXvMRN4Z9cfIqLlC7Iu_8bWbwUDEL4opHHkFfSqTw,3630
 omlish/graphs/dot/utils.py,sha256=_FMwn77WfiiAfLsRTOKWm4IYbNv5kQN22YJ5psw6CWg,801
-omlish/http/__init__.py,sha256=zv9D9PPGS49W8fKpU2k12AmUL5vE-vYxStwkz_3yxZ4,624
+omlish/http/__init__.py,sha256=-ENDALr8ehHvivRD6cxIbEC94t0RHhrakf6CQRDTc8o,625
 omlish/http/asgi.py,sha256=wXhBZ21bEl32Kv9yBrRwUR_7pHEgVtHP8ZZwbasQ6-4,3307
-omlish/http/client.py,sha256=Zr5QzjTEo_iILQ0Ypkjr2RZQGPWa6q57BDqkpeT3qsQ,3587
+omlish/http/clients.py,sha256=KPWDw251eBmiYSXw7KafMP9UQHEiLiLdh9ZLPV7jydc,6002
 omlish/http/collections.py,sha256=s8w5s4Gewgxxhe2Ai0R45PgJYYifrLgTbU3VXVflHj4,260
-omlish/http/consts.py,sha256=-O0F6qiVWGGT18j8TMP7UNfHCECg1MmByx05oc7Ae9Q,1985
+omlish/http/consts.py,sha256=FTolezLknKU6WJjk_x2T3a5LEMlnZSqv7gzTq55lxcU,2147
 omlish/http/cookies.py,sha256=uuOYlHR6e2SC3GM41V0aozK10nef9tYg83Scqpn5-HM,6351
 omlish/http/dates.py,sha256=Otgp8wRxPgNGyzx8LFowu1vC4EKJYARCiAwLFncpfHM,2875
 omlish/http/encodings.py,sha256=w2WoKajpaZnQH8j-IBvk5ZFL2O2pAU_iBvZnkocaTlw,164
-omlish/http/headers.py,sha256=_1d4cdRoh9rWP8QpMCVLyo5sGEDqLInzJ7GNSlsXY5s,4045
+omlish/http/headers.py,sha256=MO5uDwbViY6Z371Hl5OwTvh2DGl76_PnWHlurNwIsOs,4895
 omlish/http/json.py,sha256=9XwAsl4966Mxrv-1ytyCqhcE6lbBJw-0_tFZzGszgHE,7440
 omlish/http/sessions.py,sha256=VZ_WS5uiQG5y7i3u8oKuQMqf8dPKUOjFm_qk_0OvI8c,4793
 omlish/http/wsgi.py,sha256=czZsVUX-l2YTlMrUjKN49wRoP4rVpS0qpeBn4O5BoMY,948
@@ -433,9 +433,9 @@ omlish/text/delimit.py,sha256=ubPXcXQmtbOVrUsNh5gH1mDq5H-n1y2R4cPL5_DQf68,4928
 omlish/text/glyphsplit.py,sha256=Ug-dPRO7x-OrNNr8g1y6DotSZ2KH0S-VcOmUobwa4B0,3296
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
-omlish-0.0.0.dev71.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev71.dist-info/METADATA,sha256=UWQoK0TuRSj5SbCN-2CeBmXPBL5rCJUeBJg_qLHv6Q0,4167
-omlish-0.0.0.dev71.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-omlish-0.0.0.dev71.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev71.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev71.dist-info/RECORD,,
+omlish-0.0.0.dev72.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev72.dist-info/METADATA,sha256=fC-RJQd1zeLsNghRMhMtxbjiAbWfSE6bbIBTkW85Rxg,4167
+omlish-0.0.0.dev72.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+omlish-0.0.0.dev72.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev72.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev72.dist-info/RECORD,,

omlish/http/client.py

@@ -1,142 +0,0 @@
-"""
-TODO:
- - return non-200 HttpResponses
- - async
- - stream
-"""
-import abc
-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')
-
-
-@dc.dataclass(frozen=True)
-class HttpRequest(lang.Final):
-    url: str
-    method: str = 'GET'  # noqa
-
-    _: dc.KW_ONLY
-
-    headers: CanHttpHeaders | None = dc.xfield(None, repr=dc.truthy_repr)
-    data: bytes | None = dc.xfield(None, repr_fn=lambda v: '...' if v is not None else None)
-
-    timeout_s: float | None = None
-
-    @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 HttpResponse(lang.Final):
-    code: int
-
-    headers: HttpHeaders | None = dc.xfield(None, repr=dc.truthy_repr)
-    data: bytes | None = dc.xfield(None, repr_fn=lambda v: '...' if v is not None else None)
-
-    request: HttpRequest
-    underlying: ta.Any = dc.field(default=None, repr=False)
-
-
-class HttpClientError(Exception):
-    pass
-
-
-class HttpClient(lang.Abstract):
-    def __enter__(self) -> ta.Self:
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        pass
-
-    @abc.abstractmethod
-    def request(self, req: HttpRequest) -> HttpResponse:
-        raise NotImplementedError
-
-
-class UrllibHttpClient(HttpClient):
-    def request(self, req: HttpRequest) -> HttpResponse:
-        try:
-            with urllib.request.urlopen(  # noqa
-                    urllib.request.Request(  # noqa
-                        req.url,
-                        method=req.method,
-                        headers=req.headers_ or {},  # type: ignore
-                        data=req.data,
-                    ),
-                    timeout=req.timeout_s,
-            ) as resp:
-                return HttpResponse(
-                    code=resp.status,
-                    headers=HttpHeaders(resp.headers.items()),
-                    data=resp.read(),
-                    request=req,
-                    underlying=resp,
-                )
-        except (urllib.error.URLError, http.client.HTTPException) as e:
-            raise HttpClientError from e
-
-
-class HttpxHttpClient(HttpClient):
-    def request(self, req: HttpRequest) -> HttpResponse:
-        try:
-            response = httpx.request(
-                method=req.method,
-                url=req.url,
-                headers=req.headers_ or None,  # type: ignore
-                content=req.data,
-                timeout=req.timeout_s,
-            )
-            return HttpResponse(
-                code=response.status_code,
-                headers=HttpHeaders(response.headers.raw),
-                data=response.content,
-                request=req,
-                underlying=response,
-            )
-        except httpx.HTTPError as e:
-            raise HttpClientError from e
-
-
-def client() -> HttpClient:
-    return UrllibHttpClient()
-
-
-def request(
-        url: str,
-        method: str = 'GET',
-        *,
-        headers: CanHttpHeaders | None = None,
-        data: bytes | None = None,
-
-        timeout_s: float | None = None,
-
-        **kwargs: ta.Any,
-) -> HttpResponse:
-    req = HttpRequest(
-        url,
-        method=method,
-
-        headers=headers,
-        data=data,
-
-        timeout_s=timeout_s,
-
-        **kwargs,
-    )
-
-    with client() as cli:
-        return cli.request(req)