omlish 0.0.0.dev71__tar.gz → 0.0.0.dev73__tar.gz

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

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

{omlish-0.0.0.dev71 → omlish-0.0.0.dev73}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev71'
-__revision__ = '293695b11eeed255848dcf6beee9c4b4383d5c91'
+__version__ = '0.0.0.dev73'
+__revision__ = '1fa2fcb99d4ea871fe3f5aa5c094ae37d0b1090c'
 
 
 #

{omlish-0.0.0.dev71 → omlish-0.0.0.dev73}/omlish/check.py

@@ -96,7 +96,7 @@ def _default_exception_factory(exc_cls: type[Exception], *args, **kwargs) -> Exc
 _EXCEPTION_FACTORY = _default_exception_factory
 
 
-class _Args:
+class _ArgsKwargs:
     def __init__(self, *args, **kwargs):
         self.args = args
         self.kwargs = kwargs
@@ -106,7 +106,7 @@ def _raise(
         exception_type: type[Exception],
         default_message: str,
         message: Message,
-        ak: _Args = _Args(),
+        ak: _ArgsKwargs = _ArgsKwargs(),
         *,
         render_fmt: str | None = None,
 ) -> ta.NoReturn:
@@ -159,7 +159,7 @@ def isinstance(v: ta.Any, spec: type[T] | tuple, msg: Message = None) -> T:  # n
             TypeError,
             'Must be instance',
             msg,
-            _Args(v, spec),
+            _ArgsKwargs(v, spec),
             render_fmt='not isinstance(%s, %s)',
         )
 
@@ -179,7 +179,7 @@ def cast(v: ta.Any, cls: type[T], msg: Message = None) -> T:  # noqa
             TypeError,
             'Must be instance',
             msg,
-            _Args(v, cls),
+            _ArgsKwargs(v, cls),
         )
 
     return v
@@ -198,7 +198,7 @@ def not_isinstance(v: T, spec: ta.Any, msg: Message = None) -> T:  # noqa
             TypeError,
             'Must not be instance',
             msg,
-            _Args(v, spec),
+            _ArgsKwargs(v, spec),
             render_fmt='isinstance(%s, %s)',
         )
 
@@ -221,7 +221,7 @@ def issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  # noq
             TypeError,
             'Must be subclass',
             msg,
-            _Args(v, spec),
+            _ArgsKwargs(v, spec),
             render_fmt='not issubclass(%s, %s)',
         )
 
@@ -234,7 +234,7 @@ def not_issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  #
             TypeError,
             'Must not be subclass',
             msg,
-            _Args(v, spec),
+            _ArgsKwargs(v, spec),
             render_fmt='issubclass(%s, %s)',
         )
 
@@ -250,7 +250,7 @@ def in_(v: T, c: ta.Container[T], msg: Message = None) -> T:
             ValueError,
             'Must be in',
             msg,
-            _Args(v, c),
+            _ArgsKwargs(v, c),
             render_fmt='%s not in %s',
         )
 
@@ -263,7 +263,7 @@ def not_in(v: T, c: ta.Container[T], msg: Message = None) -> T:
             ValueError,
             'Must not be in',
             msg,
-            _Args(v, c),
+            _ArgsKwargs(v, c),
             render_fmt='%s in %s',
         )
 
@@ -276,7 +276,7 @@ def empty(v: SizedT, msg: Message = None) -> SizedT:
             ValueError,
             'Must be empty',
             msg,
-            _Args(v),
+            _ArgsKwargs(v),
             render_fmt='%s',
         )
 
@@ -294,7 +294,7 @@ def iterempty(v: ta.Iterable[T], msg: Message = None) -> ta.Iterable[T]:
             ValueError,
             'Must be empty',
             msg,
-            _Args(v),
+            _ArgsKwargs(v),
             render_fmt='%s',
         )
 
@@ -307,7 +307,7 @@ def not_empty(v: SizedT, msg: Message = None) -> SizedT:
             ValueError,
             'Must not be empty',
             msg,
-            _Args(v),
+            _ArgsKwargs(v),
             render_fmt='%s',
         )
 
@@ -321,7 +321,7 @@ def unique(it: ta.Iterable[T], msg: Message = None) -> ta.Iterable[T]:
             ValueError,
             'Must be unique',
             msg,
-            _Args(it, dupes),
+            _ArgsKwargs(it, dupes),
         )
 
     return it
@@ -335,7 +335,7 @@ def single(obj: ta.Iterable[T], message: Message = None) -> T:
             ValueError,
             'Must be single',
             message,
-            _Args(obj),
+            _ArgsKwargs(obj),
             render_fmt='%s',
         )
 
@@ -358,7 +358,7 @@ def opt_single(obj: ta.Iterable[T], message: Message = None) -> T | None:
         ValueError,
         'Must be empty or single',
         message,
-        _Args(obj),
+        _ArgsKwargs(obj),
         render_fmt='%s',
     )
 
@@ -372,7 +372,7 @@ def none(v: ta.Any, msg: Message = None) -> None:
             ValueError,
             'Must be None',
             msg,
-            _Args(v),
+            _ArgsKwargs(v),
             render_fmt='%s',
         )
 
@@ -383,7 +383,7 @@ def not_none(v: T | None, msg: Message = None) -> T:
             ValueError,
             'Must not be None',
             msg,
-            _Args(v),
+            _ArgsKwargs(v),
             render_fmt='%s',
         )
 
@@ -399,7 +399,7 @@ def equal(v: T, o: ta.Any, msg: Message = None) -> T:
             ValueError,
             'Must be equal',
             msg,
-            _Args(v, o),
+            _ArgsKwargs(v, o),
             render_fmt='%s != %s',
         )
 
@@ -412,7 +412,7 @@ def is_(v: T, o: ta.Any, msg: Message = None) -> T:
             ValueError,
             'Must be the same',
             msg,
-            _Args(v, o),
+            _ArgsKwargs(v, o),
             render_fmt='%s is not %s',
         )
 
@@ -425,7 +425,7 @@ def is_not(v: T, o: ta.Any, msg: Message = None) -> T:
             ValueError,
             'Must not be the same',
             msg,
-            _Args(v, o),
+            _ArgsKwargs(v, o),
             render_fmt='%s is %s',
         )
 
@@ -438,7 +438,7 @@ def callable(v: T, msg: Message = None) -> T:  # noqa
             TypeError,
             'Must be callable',
             msg,
-            _Args(v),
+            _ArgsKwargs(v),
             render_fmt='%s',
         )
 
@@ -451,7 +451,7 @@ def non_empty_str(v: str | None, msg: Message = None) -> str:
             ValueError,
             'Must be non-empty str',
             msg,
-            _Args(v),
+            _ArgsKwargs(v),
             render_fmt='%s',
         )
 
@@ -464,7 +464,7 @@ def replacing(expected: ta.Any, old: ta.Any, new: T, msg: Message = None) -> T:
             ValueError,
             'Must be replacing',
             msg,
-            _Args(expected, old, new),
+            _ArgsKwargs(expected, old, new),
             render_fmt='%s -> %s -> %s',
         )
 
@@ -477,7 +477,7 @@ def replacing_none(old: ta.Any, new: T, msg: Message = None) -> T:
             ValueError,
             'Must be replacing None',
             msg,
-            _Args(old, new),
+            _ArgsKwargs(old, new),
             render_fmt='%s -> %s',
         )
 
@@ -493,7 +493,7 @@ def arg(v: bool, msg: Message = None) -> None:
             RuntimeError,
             'Argument condition not met',
             msg,
-            _Args(v),
+            _ArgsKwargs(v),
             render_fmt='%s',
         )
 
@@ -504,6 +504,6 @@ def state(v: bool, msg: Message = None) -> None:
             RuntimeError,
             'State condition not met',
             msg,
-            _Args(v),
+            _ArgsKwargs(v),
             render_fmt='%s',
         )

{omlish-0.0.0.dev71 → omlish-0.0.0.dev73}/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.dev73}/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.dev73/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 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')
+
+        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.dev73}/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.dev73}/omlish/http/headers.py

@@ -9,9 +9,21 @@ StrOrBytes: ta.TypeAlias = str | bytes
 
 CanHttpHeaders: ta.TypeAlias = ta.Union[
     'HttpHeaders',
+
+    ta.Mapping[str, str],
+    ta.Mapping[str, ta.Sequence[str]],
+    ta.Mapping[str, str | ta.Sequence[str]],
+
+    ta.Mapping[bytes, bytes],
+    ta.Mapping[bytes, ta.Sequence[bytes]],
+    ta.Mapping[bytes, 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 +50,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 +90,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 +114,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,22 +146,28 @@ 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
-    def __getitem__(self, item: int) -> StrOrBytes:
+    def __getitem__(self, item: int) -> tuple[StrOrBytes, StrOrBytes]:
         ...
 
     @ta.overload
-    def __getitem__(self, item: slice) -> ta.Sequence[StrOrBytes]:
+    def __getitem__(self, item: slice) -> ta.Sequence[tuple[StrOrBytes, StrOrBytes]]:
         ...
 
     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.dev73}/omlish/sql/queries/binary.py

@@ -1,6 +1,8 @@
+import enum
+
 from ... import check
+from ... import dataclasses as dc
 from ... import lang
-from .base import Node
 from .exprs import CanExpr
 from .exprs import Expr
 from .exprs import ExprBuilder
@@ -9,16 +11,23 @@ from .exprs import ExprBuilder
 ##
 
 
-class BinaryOp(Node, lang.Final):
+class BinaryOpKind(enum.Enum):
+    ARITH = enum.auto()
+    BIT = enum.auto()
+    CMP = enum.auto()
+
+
+class BinaryOp(dc.Frozen, lang.Final, eq=False):
     name: str
+    kind: BinaryOpKind
 
 
 class BinaryOps(lang.Namespace):
-    ADD = BinaryOp('add')
-    SUB = BinaryOp('sub')
+    ADD = BinaryOp('add', BinaryOpKind.ARITH)
+    SUB = BinaryOp('sub', BinaryOpKind.ARITH)
 
-    EQ = BinaryOp('eq')
-    NE = BinaryOp('ne')
+    EQ = BinaryOp('eq', BinaryOpKind.CMP)
+    NE = BinaryOp('ne', BinaryOpKind.CMP)
 
 
 class Binary(Expr, lang.Final):

{omlish-0.0.0.dev71 → omlish-0.0.0.dev73}/omlish/sql/queries/multi.py

@@ -3,7 +3,6 @@ import typing as ta
 from ... import check
 from ... import dataclasses as dc
 from ... import lang
-from .base import Node
 from .exprs import CanExpr
 from .exprs import Expr
 from .exprs import ExprBuilder
@@ -12,7 +11,7 @@ from .exprs import ExprBuilder
 ##
 
 
-class MultiOp(Node, lang.Final):
+class MultiOp(dc.Frozen, lang.Final, eq=False):
     name: str