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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev70'
-__revision__ = '8d6f6c3ead70cde56b9d8040a05d9f91f6dd90ff'
+__version__ = '0.0.0.dev72'
+__revision__ = '4448e03bbb77cb149e46eeefb0e9e61faed2a494'
 
 
 #
@@ -37,7 +37,7 @@ class Project(ProjectBase):
 
             'greenlet ~= 3.1',
 
-            'trio ~= 0.26',
+            'trio ~= 0.27',
             'trio-asyncio ~= 0.15',
         ],
 

omlish/dataclasses/impl/internals.py

@@ -17,6 +17,7 @@ POST_INIT_NAME = dc._POST_INIT_NAME  # type: ignore  # noqa
 
 Params = dc._DataclassParams  # type: ignore  # noqa
 
+
 """
 @dc.dataclass(frozen=True)
 class Params:

omlish/dataclasses/impl/metaclass.py

@@ -1,6 +1,7 @@
 """
 TODO:
- - Enum
+ - Rewrite lol
+ - Enum - enforce Abstract or Final
 """
 import abc
 import collections
@@ -13,6 +14,7 @@ from .api import field  # noqa
 from .params import MetaclassParams
 from .params import get_metaclass_params
 from .params import get_params
+from .params import get_params_extras
 
 
 T = ta.TypeVar('T')
@@ -34,22 +36,35 @@ def confer_kwargs(
     for base in bases:
         if not dc.is_dataclass(base):
             continue
+
         if not (bmp := get_metaclass_params(base)).confer:
             continue
+
         for ck in bmp.confer:
             if ck in kwargs:
                 continue
+
             if ck in (
                     'frozen',
-                    'generic_init',
                     'kw_only',
+            ):
+                confer_kwarg(out, ck, getattr(get_params(base), ck))
+
+            elif ck in (
+                    'cache_hash',
+                    'generic_init',
                     'reorder',
             ):
-                confer_kwarg(out, ck, get_params(base).frozen)
-            elif ck == 'confer':
-                confer_kwarg(out, 'confer', bmp.confer)
+                confer_kwarg(out, ck, getattr(get_params_extras(base), ck))
+
+            elif ck in (
+                    'confer',
+            ):
+                confer_kwarg(out, ck, getattr(bmp, ck))
+
             else:
                 raise KeyError(ck)
+
     return out
 
 
@@ -112,6 +127,7 @@ class Frozen(
     frozen=True,
     confer=frozenset([
         'frozen',
+        'cache_hash',
         'confer',
     ]),
 ):
@@ -124,6 +140,7 @@ class Box(
     generic_init=True,
     confer=frozenset([
         'frozen',
+        'cache_hash',
         'generic_init',
         'confer',
     ]),

omlish/dataclasses/impl/params.py

@@ -1,5 +1,6 @@
 """
-Field:
+@dc.dataclass(frozen=True)
+class Field_:
     name: str | None = None
     type: Any = None
     default: Any | MISSING = MISSING
@@ -14,7 +15,8 @@ Field:
     _field_type: Any = None
 
 
-Params:
+@dc.dataclass(frozen=True)
+class Params_:
     init: bool = True
     repr: bool = True
     eq: bool = True

omlish/diag/_pycharm/runhack.py

@@ -1038,11 +1038,13 @@ class ExecDecider:
         if not isinstance(tgt, FileTarget):
             return None
 
-        new_file = os.path.abspath(tgt.file)
+        abs_file = os.path.abspath(tgt.file)
+        if os.path.commonpath([abs_file, self._root_dir]) != self._root_dir:
+            return None
 
         return ExecDecision(
             tgt.replace(
-                file=new_file,
+                file=abs_file,
             ),
             cwd=self._root_dir,
         )
@@ -1070,8 +1072,11 @@ class ExecDecider:
         if not (isinstance(dt, FileTarget) and dt.file.endswith('.py')):
             return None
 
-        af = os.path.abspath(dt.file)
-        rp = os.path.relpath(af, self._root_dir).split(os.path.sep)
+        abs_file = os.path.abspath(dt.file)
+        if os.path.commonpath([abs_file, self._root_dir]) != self._root_dir:
+            return None
+
+        rp = os.path.relpath(abs_file, self._root_dir).split(os.path.sep)
         mod = '.'.join([*rp[:-1], rp[-1][:-3]])
         new_dt = ModuleTarget(
             mod,

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,5 +1,16 @@
 from . import consts  # noqa
 
+from .clients import (  # noqa
+    HttpClient,
+    HttpClientError,
+    HttpRequest,
+    HttpResponse,
+    HttpxHttpClient,
+    UrllibHttpClient,
+    client,
+    request,
+)
+
 from .cookies import (  # noqa
     CookieTooBigError,
     dump_cookie,
@@ -16,6 +27,12 @@ from .encodings import (  # noqa
     latin1_encode,
 )
 
+from .headers import (  # noqa
+    CanHttpHeaders,
+    HttpHeaders,
+    headers,
+)
+
 from .json import (  # noqa
     JSON_TAGGER,
     JsonTag,

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

@@ -0,0 +1,181 @@
+import typing as ta
+
+from .. import cached
+from .. import check
+from .. import collections as col
+
+
+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]],
+]
+
+
+class HttpHeaders:
+    def __init__(self, src: CanHttpHeaders) -> None:
+        super().__init__()
+
+        if isinstance(src, HttpHeaders):
+            check.is_(src, self)
+            return
+
+        # TODO: optimized storage, 'use-whats-given'
+        lst: list[tuple[bytes, bytes]] = []
+        if isinstance(src, ta.Mapping):
+            for k, v in src.items():
+                if isinstance(v, (str, bytes)):
+                    lst.append((self._as_bytes(k), self._as_bytes(v)))
+                else:
+                    for e in v:
+                        lst.append((self._as_bytes(k), self._as_bytes(e)))
+
+        elif isinstance(src, (str, bytes)):  # type: ignore
+            raise TypeError(src)
+
+        elif isinstance(src, ta.Sequence):
+            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:
+            raise TypeError(src)
+
+        self._lst = lst
+
+    def __new__(cls, obj: CanHttpHeaders) -> 'HttpHeaders':
+        if isinstance(obj, HttpHeaders):
+            return obj
+
+        return super().__new__(cls)
+
+    #
+
+    # https://github.com/pgjones/hypercorn/commit/13f385be7277f407a9a361c958820515e16e217e
+    ENCODING: ta.ClassVar[str] = 'latin1'
+
+    @classmethod
+    def _as_bytes(cls, o: StrOrBytes) -> bytes:
+        if isinstance(o, bytes):
+            return o
+        elif isinstance(o, str):
+            return o.encode(cls.ENCODING)
+        else:
+            raise TypeError(o)
+
+    #
+
+    @cached.function
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({{{", ".join(repr(k) for k in self.single_str_dct)}}})'
+
+    #
+
+    @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.normalized)
+
+    @cached.property
+    def single_dct(self) -> ta.Mapping[bytes, bytes]:
+        return {k: v[0] for k, v in self.multi_dct.items() if len(v) == 1}
+
+    @cached.property
+    def strict_dct(self) -> ta.Mapping[bytes, bytes]:
+        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.normalized)
+
+    @cached.property
+    def multi_str_dct(self) -> ta.Mapping[str, ta.Sequence[str]]:
+        return col.multi_map(self.strs)
+
+    @cached.property
+    def single_str_dct(self) -> ta.Mapping[str, str]:
+        return {k: v[0] for k, v in self.multi_str_dct.items() if len(v) == 1}
+
+    @cached.property
+    def strict_str_dct(self) -> ta.Mapping[str, str]:
+        return col.make_map(self.strs, strict=True)
+
+    #
+
+    def __bool__(self) -> bool:
+        return bool(self._lst)
+
+    def __len__(self) -> int:
+        return len(self._lst)
+
+    def __iter__(self) -> ta.Iterator[tuple[bytes, bytes]]:
+        return iter(self._lst)
+
+    @ta.overload
+    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:
+        ...
+
+    @ta.overload
+    def __getitem__(self, item: slice) -> ta.Sequence[StrOrBytes]:
+        ...
+
+    def __getitem__(self, item):
+        if isinstance(item, (int, slice)):
+            return self._lst[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)
+
+    def keys(self) -> ta.Iterable[bytes]:
+        return self.multi_dct.keys()
+
+    def items(self) -> ta.Iterable[tuple[bytes, bytes]]:
+        return self._lst
+
+
+def headers(src: CanHttpHeaders) -> HttpHeaders:
+    return HttpHeaders(src)

omlish/sql/queries/__init__.py

@@ -0,0 +1,79 @@
+from .base import (  # noqa
+    Builder,
+    Node,
+    Value,
+)
+
+from .binary import (  # noqa
+    Binary,
+    BinaryBuilder,
+    BinaryOp,
+    BinaryOps,
+)
+
+from .exprs import (  # noqa
+    CanExpr,
+    CanLiteral,
+    Expr,
+    ExprBuilder,
+    Literal,
+    NameExpr,
+)
+
+from .idents import (  # noqa
+    CanIdent,
+    Ident,
+    IdentBuilder,
+)
+
+from .multi import (  # noqa
+    Multi,
+    MultiBuilder,
+    MultiOp,
+    MultiOps,
+)
+
+from .names import (  # noqa
+    CanName,
+    Name,
+    NameBuilder,
+)
+
+from .relations import (  # noqa
+    CanRelation,
+    CanTable,
+    Relation,
+    RelationBuilder,
+    Table,
+)
+
+from .selects import (  # noqa
+    CanRelation,
+    Select,
+    SelectBuilder,
+    SelectItem,
+)
+
+from .std import (  # noqa
+    StdBuilder,
+)
+
+from .stmts import (  # noqa
+    CanExpr,
+    ExprStmt,
+    Stmt,
+    StmtBuilder,
+)
+
+from .unary import (  # noqa
+    Unary,
+    UnaryBuilder,
+    UnaryOp,
+    UnaryOps,
+)
+
+
+##
+
+
+Q = StdBuilder()