omlish 0.0.0.dev71__tar.gz → 0.0.0.dev72__tar.gz

{omlish-0.0.0.dev71/omlish.egg-info → omlish-0.0.0.dev72}/PKG-INFO

@@ -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 → omlish-0.0.0.dev72}/omlish/__about__.py

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

{omlish-0.0.0.dev71 → omlish-0.0.0.dev72}/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-0.0.0.dev71 → omlish-0.0.0.dev72}/omlish/http/__init__.py

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

omlish-0.0.0.dev72/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-0.0.0.dev71 → omlish-0.0.0.dev72}/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-0.0.0.dev71 → omlish-0.0.0.dev72}/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 → omlish-0.0.0.dev72/omlish.egg-info}/PKG-INFO

@@ -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 → omlish-0.0.0.dev72}/omlish.egg-info/SOURCES.txt

@@ -212,7 +212,7 @@ omlish/graphs/dot/rendering.py
 omlish/graphs/dot/utils.py
 omlish/http/__init__.py
 omlish/http/asgi.py
-omlish/http/client.py
+omlish/http/clients.py
 omlish/http/collections.py
 omlish/http/consts.py
 omlish/http/cookies.py

{omlish-0.0.0.dev71 → omlish-0.0.0.dev72}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '~=3.12'
-version = '0.0.0.dev71'
+version = '0.0.0.dev72'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',

omlish-0.0.0.dev71/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)