omlish 0.0.0.dev73__tar.gz → 0.0.0.dev75__tar.gz

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

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

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

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev73'
-__revision__ = '1fa2fcb99d4ea871fe3f5aa5c094ae37d0b1090c'
+__version__ = '0.0.0.dev75'
+__revision__ = 'dcdc82976a464689890fe99f9aaf5fc596ddd563'
 
 
 #

{omlish-0.0.0.dev73 → omlish-0.0.0.dev75}/omlish/dataclasses/impl/fields.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - point validate / check exceptions to lambdas
+"""
 import dataclasses as dc
 import types
 import typing as ta

{omlish-0.0.0.dev73 → omlish-0.0.0.dev75}/omlish/dataclasses/impl/metaclass.py

@@ -108,7 +108,11 @@ class DataMeta(abc.ABCMeta):
 
 
 # @ta.dataclass_transform(field_specifiers=(field,))  # FIXME: ctor
-class Data(metaclass=DataMeta):
+class Data(
+    eq=False,
+    order=False,
+    metaclass=DataMeta,
+):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
@@ -125,6 +129,8 @@ class Data(metaclass=DataMeta):
 class Frozen(
     Data,
     frozen=True,
+    eq=False,
+    order=False,
     confer=frozenset([
         'frozen',
         'cache_hash',

{omlish-0.0.0.dev73 → omlish-0.0.0.dev75}/omlish/http/clients.py

@@ -1,5 +1,6 @@
 """
 TODO:
+ - httpx catch
  - check=False
  - return non-200 HttpResponses
  - async

omlish-0.0.0.dev75/omlish/http/sse.py

@@ -0,0 +1,96 @@
+"""
+TODO:
+ - end-of-line   = ( cr lf / cr / lf )
+"""
+import string
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+
+
+class SseDecoderOutput(lang.Abstract):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class SseComment(SseDecoderOutput, lang.Final):
+    data: bytes
+
+
+SseEventId: ta.TypeAlias = bytes
+
+
+@dc.dataclass(frozen=True)
+class SseEvent(SseDecoderOutput, lang.Final):
+    type: bytes
+    data: bytes
+    last_id: SseEventId = dc.xfield(b'', repr_fn=dc.truthy_repr)
+
+
+_DIGIT_BYTES = string.digits.encode('ascii')
+
+
+class SseDecoder:
+    """https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation"""
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._reset()
+        self._last_event_id = b''
+        self._reconnection_time: int | None = None
+
+    _event_type: bytes
+    _data: list[bytes]
+
+    def _reset(self) -> None:
+        self._event_type = b'message'
+        self._data = []
+
+    def _process_field(self, name: bytes, value: bytes) -> None:
+        if name == b'event':
+            self._event_type = value
+
+        elif name == b'data':
+            self._data.append(value)
+
+        elif name == b'id':
+            if 0 not in value:
+                self._last_event_id = value
+
+        elif name == b'retry':
+            if all(c in _DIGIT_BYTES for c in value):
+                self._reconnection_time = int(value)
+
+    def _dispatch_event(self) -> SseEvent:
+        data = b''.join(lang.interleave(self._data, b'\n'))
+
+        e = SseEvent(
+            type=self._event_type,
+            data=data,
+            last_id=self._last_event_id,
+        )
+
+        self._reset()
+
+        return e
+
+    def process_line(self, line: bytes) -> ta.Iterable[SseDecoderOutput]:
+        if b'\r' in line or b'\n' in line:
+            raise ValueError(line)
+
+        if not line:
+            yield self._dispatch_event()
+
+        elif line[0] == b':'[0]:
+            yield SseComment(line)
+
+        elif (c := line.find(b':')) >= 0:
+            d = c + 1
+            if len(line) > d and line[d] == b' '[0]:
+                d += 1
+            self._process_field(line[:c], line[d:])
+
+        else:
+            self._process_field(line, b'')

omlish-0.0.0.dev75/omlish/io.py

@@ -0,0 +1,142 @@
+import dataclasses as dc
+import io
+import typing as ta
+
+from . import check
+
+
+@dc.dataclass(frozen=True)
+class DelimitingBufferError(Exception):
+    buffer: 'DelimitingBuffer'
+
+
+class ClosedDelimitingBufferError(DelimitingBufferError):
+    pass
+
+
+class FullDelimitingBufferError(DelimitingBufferError):
+    pass
+
+
+class IncompleteDelimitingBufferError(DelimitingBufferError):
+    pass
+
+
+class DelimitingBuffer:
+    """
+    https://github.com/python-trio/trio/issues/796 :|
+    """
+
+    DEFAULT_DELIMITERS: bytes = b'\n'
+
+    def __init__(
+            self,
+            delimiters: ta.Iterable[int] = DEFAULT_DELIMITERS,
+            *,
+            keep_ends: bool = False,
+            max_size: int | None = None,
+            on_full: ta.Literal['raise', 'yield'] = 'raise',
+            on_incomplete: ta.Literal['raise', 'yield'] = 'yield',
+    ) -> None:
+        super().__init__()
+
+        self._delimiters = frozenset(check.isinstance(d, int) for d in delimiters)
+        self._keep_ends = keep_ends
+        self._max_size = max_size
+        self._on_full = on_full
+        self._on_incomplete = on_incomplete
+
+        self._buf: io.BytesIO | None = io.BytesIO()
+
+    @property
+    def is_closed(self) -> bool:
+        return self._buf is None
+
+    def tell(self) -> int:
+        if (buf := self._buf) is None:
+            raise ClosedDelimitingBufferError(self)
+        return buf.tell()
+
+    def peek(self) -> bytes:
+        if (buf := self._buf) is None:
+            raise ClosedDelimitingBufferError(self)
+        return buf.getvalue()
+
+    def _find_delim(self, data: bytes | bytearray, i: int) -> int | None:
+        r = None  # type: int | None
+        for d in self._delimiters:
+            if (p := data.find(d, i)) >= 0:
+                if r is None or p < r:
+                    r = p
+        return r
+
+    def _append_and_reset(self, chunk: bytes) -> bytes:
+        buf = check.not_none(self._buf)
+        if not buf.tell():
+            return chunk
+
+        buf.write(chunk)
+        ret = buf.getvalue()
+        buf.seek(0)
+        return ret
+
+    def feed(self, data: bytes | bytearray) -> ta.Generator[bytes, None, None]:
+        if (buf := self._buf) is None:
+            raise ClosedDelimitingBufferError(self)
+
+        if not data:
+            self._buf = None
+
+            if buf.tell():
+                if self._on_incomplete == 'raise':
+                    raise IncompleteDelimitingBufferError(self)
+
+                elif self._on_incomplete == 'yield':
+                    yield buf.getvalue()
+
+                else:
+                    raise ValueError(f'Unknown on_incomplete value: {self._on_incomplete!r}')
+
+            return
+
+        l = len(data)
+        i = 0
+        while i < l:
+            if (p := self._find_delim(data, i)) is None:
+                break
+
+            n = p + 1
+            if self._keep_ends:
+                p = n
+
+            yield self._append_and_reset(data[i:p])
+
+            i = n
+
+        if i >= l:
+            return
+
+        if self._max_size is None:
+            buf.write(data[i:])
+            return
+
+        while i < l:
+            remaining_data_len = l - i
+            remaining_buf_capacity = self._max_size - buf.tell()
+
+            if remaining_data_len < remaining_buf_capacity:
+                buf.write(data[i:])
+                return
+
+            if self._on_full == 'raise':
+                raise FullDelimitingBufferError(self)
+
+            elif self._on_full == 'yield':
+                p = i + remaining_buf_capacity
+
+                yield self._append_and_reset(data[i:p])
+
+                i = p
+
+            else:
+                raise ValueError(f'Unknown on_full value: {self._on_full!r}')

{omlish-0.0.0.dev73 → omlish-0.0.0.dev75}/omlish/lang/__init__.py

@@ -140,6 +140,7 @@ from .iterables import (  # noqa
     flatmap,
     flatten,
     ilen,
+    interleave,
     itergen,
     peek,
     prodrange,

{omlish-0.0.0.dev73 → omlish-0.0.0.dev75}/omlish/lang/iterables.py

@@ -37,6 +37,13 @@ def peek(vs: ta.Iterable[T]) -> tuple[T, ta.Iterator[T]]:
     return v, itertools.chain(iter((v,)), it)
 
 
+def interleave(vs: ta.Iterable[T], d: T) -> ta.Iterable[T]:
+    for i, v in enumerate(vs):
+        if i:
+            yield d
+        yield v
+
+
 Rangeable: ta.TypeAlias = ta.Union[  # noqa
     int,
     tuple[int],

{omlish-0.0.0.dev73 → omlish-0.0.0.dev75}/omlish/marshal/enums.py

@@ -28,7 +28,7 @@ class EnumMarshalerFactory(MarshalerFactory):
     def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
         ty = check.isinstance(rty, type)
         check.state(issubclass(ty, enum.Enum))
-        return EnumMarshaler(ty)
+        return EnumMarshaler(ty)  # noqa
 
 
 @dc.dataclass(frozen=True)

{omlish-0.0.0.dev73 → omlish-0.0.0.dev75}/omlish/sql/queries/__init__.py

@@ -11,6 +11,10 @@ from .binary import (  # noqa
     BinaryOps,
 )
 
+from .building import (  # noqa
+    StdBuilder,
+)
+
 from .exprs import (  # noqa
     CanExpr,
     CanLiteral,
@@ -18,6 +22,7 @@ from .exprs import (  # noqa
     ExprBuilder,
     Literal,
     NameExpr,
+    Param,
 )
 
 from .idents import (  # noqa
@@ -29,8 +34,7 @@ from .idents import (  # noqa
 from .multi import (  # noqa
     Multi,
     MultiBuilder,
-    MultiOp,
-    MultiOps,
+    MultiKind,
 )
 
 from .names import (  # noqa
@@ -39,6 +43,10 @@ from .names import (  # noqa
     NameBuilder,
 )
 
+from .ops import (  # noqa
+    OpKind,
+)
+
 from .relations import (  # noqa
     CanRelation,
     CanTable,
@@ -47,6 +55,12 @@ from .relations import (  # noqa
     Table,
 )
 
+from .rendering import (  # noqa
+    Renderer,
+    StdRenderer,
+    render,
+)
+
 from .selects import (  # noqa
     CanRelation,
     Select,
@@ -54,10 +68,6 @@ from .selects import (  # noqa
     SelectItem,
 )
 
-from .std import (  # noqa
-    StdBuilder,
-)
-
 from .stmts import (  # noqa
     CanExpr,
     ExprStmt,
@@ -77,3 +87,11 @@ from .unary import (  # noqa
 
 
 Q = StdBuilder()
+
+
+##
+
+
+from ...lang.imports import _register_conditional_import  # noqa
+
+_register_conditional_import('...marshal', '.marshal', __package__)

omlish-0.0.0.dev75/omlish/sql/queries/binary.py

@@ -0,0 +1,95 @@
+"""
+TODO:
+ - in_
+ - like
+  - no this is a dedicated node, escape / negation in grammar
+"""
+from ... import check
+from ... import dataclasses as dc
+from ... import lang
+from .exprs import CanExpr
+from .exprs import Expr
+from .exprs import ExprBuilder
+from .ops import OpKind
+
+
+##
+
+
+class BinaryOp(dc.Frozen, lang.Final, eq=False):
+    name: str
+    kind: OpKind
+
+
+class BinaryOps(lang.Namespace):
+    EQ = BinaryOp('eq', OpKind.CMP)
+    NE = BinaryOp('ne', OpKind.CMP)
+    LT = BinaryOp('lt', OpKind.CMP)
+    LE = BinaryOp('le', OpKind.CMP)
+    GT = BinaryOp('gt', OpKind.CMP)
+    GE = BinaryOp('ge', OpKind.CMP)
+
+    ADD = BinaryOp('add', OpKind.ARITH)
+    SUB = BinaryOp('sub', OpKind.ARITH)
+    MUL = BinaryOp('mul', OpKind.ARITH)
+    DIV = BinaryOp('div', OpKind.ARITH)
+    MOD = BinaryOp('mod', OpKind.ARITH)
+
+    CONCAT = BinaryOp('concat', OpKind.STR)
+
+
+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 eq(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.EQ, *es)
+
+    def ne(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.NE, *es)
+
+    def lt(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.LT, *es)
+
+    def le(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.LE, *es)
+
+    def gt(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.GT, *es)
+
+    def ge(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.GE, *es)
+
+    #
+
+    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 mul(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.MUL, *es)
+
+    def div(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.DIV, *es)
+
+    def mod(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.MOD, *es)
+
+    #
+
+    def concat(self, *es: CanExpr) -> Expr:
+        return self.binary(BinaryOps.CONCAT, *es)

{omlish-0.0.0.dev73 → omlish-0.0.0.dev75}/omlish/sql/queries/exprs.py

@@ -1,3 +1,8 @@
+"""
+TODO:
+ - case
+ - cast / ::
+"""
 import typing as ta
 
 from ... import lang
@@ -24,6 +29,24 @@ class NameExpr(Expr, lang.Final):
     n: Name
 
 
+class Param(Expr, lang.Final):
+    n: str | None = None
+
+    def __repr__(self) -> str:
+        if self.n is not None:
+            return f'{self.__class__.__name__}({self.n!r})'
+        else:
+            return f'{self.__class__.__name__}(@{hex(id(self))[2:]})'
+
+    def __eq__(self, other):
+        if not isinstance(other, Param):
+            return False
+        if self.n is None and other.n is None:
+            return self is other
+        else:
+            return self.n == other.n
+
+
 CanLiteral: ta.TypeAlias = Literal | Value
 CanExpr: ta.TypeAlias = Expr | CanName | CanLiteral
 
@@ -41,6 +64,8 @@ class ExprBuilder(NameBuilder):
     def l(self, o: CanLiteral) -> Literal:  # noqa
         return self.literal(o)
 
+    #
+
     def expr(self, o: CanExpr) -> Expr:
         if isinstance(o, Expr):
             return o
@@ -52,3 +77,12 @@ class ExprBuilder(NameBuilder):
     @ta.final
     def e(self, o: CanExpr) -> Expr:
         return self.expr(o)
+
+    #
+
+    def param(self, n: str | None = None) -> Param:
+        return Param(n)
+
+    @ta.final
+    def p(self, n: str | None = None) -> Param:
+        return self.param(n)

omlish-0.0.0.dev75/omlish/sql/queries/marshal.py

@@ -0,0 +1,74 @@
+import enum
+import typing as ta
+
+from ... import cached
+from ... import check
+from ... import collections as col
+from ... import dataclasses as dc
+from ... import lang
+from ... import marshal as msh
+from .base import Node
+from .binary import BinaryOp
+from .binary import BinaryOps
+from .exprs import Expr
+from .multi import MultiKind
+from .relations import Relation
+from .stmts import Stmt
+from .unary import UnaryOp
+from .unary import UnaryOps
+
+
+@dc.dataclass(frozen=True)
+class OpMarshalerUnmarshaler(msh.Marshaler, msh.Unmarshaler):
+    ty: type
+    ns: type[lang.Namespace]
+
+    @cached.property
+    @dc.init
+    def by_name(self) -> ta.Mapping[str, ta.Any]:
+        return col.make_map(((o.name, o) for _, o in self.ns), strict=True)
+
+    def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
+        return check.isinstance(o, self.ty).name  # type: ignore  # noqa
+
+    def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
+        return self.by_name[check.isinstance(v, str)]
+
+
+@dc.dataclass(frozen=True)
+class LowerEnumMarshaler(msh.Marshaler, msh.Unmarshaler):
+    ty: type[enum.Enum]
+
+    @cached.property
+    @dc.init
+    def by_name(self) -> ta.Mapping[str, ta.Any]:
+        return col.make_map(((o.name.lower(), o) for o in self.ty), strict=True)
+
+    def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
+        return o.name.lower()
+
+    def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
+        return self.by_name[check.isinstance(v, str).lower()]
+
+
+@lang.static_init
+def _install_standard_marshalling() -> None:
+    for ty, ns in [
+        (BinaryOp, BinaryOps),
+        (UnaryOp, UnaryOps),
+    ]:
+        msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.TypeMapMarshalerFactory({ty: OpMarshalerUnmarshaler(ty, ns)})]
+        msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.TypeMapUnmarshalerFactory({ty: OpMarshalerUnmarshaler(ty, ns)})]
+
+    msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.TypeMapMarshalerFactory({MultiKind: LowerEnumMarshaler(MultiKind)})]
+    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.TypeMapUnmarshalerFactory({MultiKind: LowerEnumMarshaler(MultiKind)})]  # noqa
+
+    for cls in [
+        Expr,
+        Node,
+        Relation,
+        Stmt,
+    ]:
+        p = msh.polymorphism_from_subclasses(cls, naming=msh.Naming.SNAKE)
+        msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.PolymorphismMarshalerFactory(p)]
+        msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.PolymorphismUnmarshalerFactory(p)]

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

@@ -1,3 +1,4 @@
+import enum
 import typing as ta
 
 from ... import check
@@ -11,30 +12,26 @@ from .exprs import ExprBuilder
 ##
 
 
-class MultiOp(dc.Frozen, lang.Final, eq=False):
-    name: str
-
-
-class MultiOps(lang.Namespace):
-    AND = MultiOp('and')
-    OR = MultiOp('or')
+class MultiKind(enum.Enum):
+    AND = enum.auto()
+    OR = enum.auto()
 
 
 class Multi(Expr, lang.Final):
-    op: MultiOp
-    es: ta.Sequence[Expr] = dc.xfield(coerce=tuple)
+    k: MultiKind
+    es: ta.Sequence[Expr] = dc.xfield(coerce=tuple, validate=lambda es: len(es) > 1)
 
 
 class MultiBuilder(ExprBuilder):
-    def multi(self, op: MultiOp, *es: CanExpr) -> Expr:
+    def multi(self, k: MultiKind, *es: CanExpr) -> Expr:
         check.not_empty(es)
         if len(es) == 1:
             return self.expr(es[0])
         else:
-            return Multi(op, [self.expr(e) for e in es])
+            return Multi(k, [self.expr(e) for e in es])
 
     def and_(self, *es: CanExpr) -> Expr:
-        return self.multi(MultiOps.AND, *es)
+        return self.multi(MultiKind.AND, *es)
 
     def or_(self, *es: CanExpr) -> Expr:
-        return self.multi(MultiOps.OR, *es)
+        return self.multi(MultiKind.OR, *es)

omlish-0.0.0.dev75/omlish/sql/queries/ops.py

@@ -0,0 +1,8 @@
+import enum
+
+
+class OpKind(enum.Enum):
+    CMP = enum.auto()
+    ARITH = enum.auto()
+    BIT = enum.auto()
+    STR = enum.auto()

{omlish-0.0.0.dev73 → omlish-0.0.0.dev75}/omlish/sql/queries/relations.py

@@ -1,3 +1,8 @@
+"""
+TODO:
+ - join
+ - subquery
+"""
 import typing as ta
 
 from ... import dataclasses as dc