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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev70'
-__revision__ = '8d6f6c3ead70cde56b9d8040a05d9f91f6dd90ff'
+__version__ = '0.0.0.dev71'
+__revision__ = '293695b11eeed255848dcf6beee9c4b4383d5c91'
 
 
 #
@@ -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/http/__init__.py

@@ -1,5 +1,16 @@
 from . import consts  # noqa
 
+from .client 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/client.py

@@ -0,0 +1,142 @@
+"""
+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)

omlish/http/headers.py

@@ -0,0 +1,146 @@
+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[StrOrBytes, StrOrBytes],
+    ta.Mapping[StrOrBytes, ta.Sequence[StrOrBytes]],
+    ta.Mapping[StrOrBytes, StrOrBytes | ta.Sequence[StrOrBytes]],
+    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 k, v in src:
+                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)}}})'
+
+    #
+
+    @cached.property
+    def multi_dct(self) -> ta.Mapping[bytes, ta.Sequence[bytes]]:
+        return col.multi_map(self._lst)
+
+    @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._lst, 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)
+
+    @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: StrOrBytes) -> ta.Sequence[StrOrBytes]:
+        ...
+
+    @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, bytes)):
+            return self.multi_dct[self._as_bytes(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()

omlish/sql/queries/base.py

@@ -0,0 +1,21 @@
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+
+
+##
+
+
+Value: ta.TypeAlias = ta.Any
+
+
+##
+
+
+class Node(dc.Frozen, lang.Abstract, cache_hash=True):
+    pass
+
+
+class Builder(lang.Abstract):
+    pass

omlish/sql/queries/binary.py

@@ -0,0 +1,48 @@
+from ... import check
+from ... import lang
+from .base import Node
+from .exprs import CanExpr
+from .exprs import Expr
+from .exprs import ExprBuilder
+
+
+##
+
+
+class BinaryOp(Node, lang.Final):
+    name: str
+
+
+class BinaryOps(lang.Namespace):
+    ADD = BinaryOp('add')
+    SUB = BinaryOp('sub')
+
+    EQ = BinaryOp('eq')
+    NE = BinaryOp('ne')
+
+
+class Binary(Expr, lang.Final):
+    op: BinaryOp
+    l: Expr
+    r: Expr
+
+
+class BinaryBuilder(ExprBuilder):
+    def binary(self, op: BinaryOp, *es: CanExpr) -> Expr:
+        check.not_empty(es)
+        l = self.expr(es[0])
+        for r in es[1:]:
+            l = Binary(op, l, self.expr(r))
+        return l
+
+    def add(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.ADD, *es)
+
+    def sub(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.SUB, *es)
+
+    def eq(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.EQ, *es)
+
+    def ne(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.NE, *es)

omlish/sql/queries/exprs.py

@@ -0,0 +1,54 @@
+import typing as ta
+
+from ... import lang
+from .base import Node
+from .base import Value
+from .idents import Ident
+from .names import CanName
+from .names import Name
+from .names import NameBuilder
+
+
+##
+
+
+class Expr(Node, lang.Abstract):
+    pass
+
+
+class Literal(Expr, lang.Final):
+    v: Value
+
+
+class NameExpr(Expr, lang.Final):
+    n: Name
+
+
+CanLiteral: ta.TypeAlias = Literal | Value
+CanExpr: ta.TypeAlias = Expr | CanName | CanLiteral
+
+
+class ExprBuilder(NameBuilder):
+    def literal(self, o: CanLiteral) -> Literal:
+        if isinstance(o, Literal):
+            return o
+        elif isinstance(o, Node):
+            raise TypeError(o)
+        else:
+            return Literal(o)
+
+    @ta.final
+    def l(self, o: CanLiteral) -> Literal:  # noqa
+        return self.literal(o)
+
+    def expr(self, o: CanExpr) -> Expr:
+        if isinstance(o, Expr):
+            return o
+        elif isinstance(o, (Name, Ident)):
+            return NameExpr(self.name(o))
+        else:
+            return self.literal(o)
+
+    @ta.final
+    def e(self, o: CanExpr) -> Expr:
+        return self.expr(o)

omlish/sql/queries/idents.py

@@ -0,0 +1,29 @@
+import typing as ta
+
+from ... import lang
+from .base import Builder
+from .base import Node
+
+
+##
+
+
+class Ident(Node, lang.Final):
+    s: str
+
+
+CanIdent: ta.TypeAlias = Ident | str
+
+
+class IdentBuilder(Builder):
+    def ident(self, o: CanIdent) -> Ident:
+        if isinstance(o, Ident):
+            return o
+        elif isinstance(o, str):
+            return Ident(o)
+        else:
+            raise TypeError(o)
+
+    @ta.final
+    def i(self, o: CanIdent) -> Ident:
+        return self.ident(o)