omlish 0.0.0.dev84__tar.gz → 0.0.0.dev86__tar.gz

{omlish-0.0.0.dev84/omlish.egg-info → omlish-0.0.0.dev86}/PKG-INFO

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

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev84'
-__revision__ = 'b3347da7d48862b90c274893e4f9bfa477fecc70'
+__version__ = '0.0.0.dev86'
+__revision__ = '39be25efaa0206ceb3478be1878e14671f5940f1'
 
 
 #

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/omlish/formats/json/backends/default.py

@@ -1,10 +1,13 @@
 from .base import Backend
+from .orjson import ORJSON_BACKEND
 from .std import STD_BACKEND
 from .ujson import UJSON_BACKEND
 
 
 DEFAULT_BACKED: Backend
-if UJSON_BACKEND is not None:
+if ORJSON_BACKEND is not None:
+    DEFAULT_BACKED = ORJSON_BACKEND
+elif UJSON_BACKEND is not None:
     DEFAULT_BACKED = UJSON_BACKEND
 else:
     DEFAULT_BACKED = STD_BACKEND

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/omlish/formats/json/stream/lex.py

@@ -52,14 +52,18 @@ SCALAR_VALUE_TYPES: tuple[type, ...] = tuple(
 ##
 
 
+class Position(ta.NamedTuple):
+    ofs: int
+    line: int
+    col: int
+
+
 class Token(ta.NamedTuple):
     kind: TokenKind
     value: ScalarValue
     raw: str | None
 
-    ofs: int
-    line: int
-    col: int
+    pos: Position
 
     def __iter__(self):
         raise TypeError
@@ -94,9 +98,7 @@ CONST_TOKENS: ta.Mapping[str, tuple[TokenKind, str | float | None]] = {
 class JsonLexError(Exception):
     message: str
 
-    ofs: int
-    line: int
-    col: int
+    pos: Position
 
 
 class JsonStreamLexer(GenMachine[str, Token]):
@@ -108,13 +110,21 @@ class JsonStreamLexer(GenMachine[str, Token]):
         self._include_raw = include_raw
 
         self._ofs = 0
-        self._line = 0
+        self._line = 1
         self._col = 0
 
         self._buf = io.StringIO()
 
         super().__init__(self._do_main())
 
+    @property
+    def pos(self) -> Position:
+        return Position(
+            self._ofs,
+            self._line,
+            self._col,
+        )
+
     def _char_in(self, c: str) -> str:
         if c and len(c) != 1:
             raise ValueError(c)
@@ -134,14 +144,13 @@ class JsonStreamLexer(GenMachine[str, Token]):
             kind: TokenKind,
             value: ScalarValue,
             raw: str,
+            pos: Position,
     ) -> ta.Sequence[Token]:
         tok = Token(
             kind,
             value,
             raw if self._include_raw else None,
-            self._ofs,
-            self._line,
-            self._col,
+            pos,
         )
         return (tok,)
 
@@ -152,7 +161,7 @@ class JsonStreamLexer(GenMachine[str, Token]):
         return raw
 
     def _raise(self, msg: str) -> ta.NoReturn:
-        raise JsonLexError(msg, self._ofs, self._line, self._col)
+        raise JsonLexError(msg, self.pos)
 
     def _do_main(self):
         while True:
@@ -165,7 +174,7 @@ class JsonStreamLexer(GenMachine[str, Token]):
                 continue
 
             if c in CONTROL_TOKENS:
-                yield self._make_tok(CONTROL_TOKENS[c], c, c)
+                yield self._make_tok(CONTROL_TOKENS[c], c, c, self.pos)
                 continue
 
             if c == '"':
@@ -180,8 +189,11 @@ class JsonStreamLexer(GenMachine[str, Token]):
             self._raise(f'Unexpected character: {c}')
 
     def _do_string(self):
+        check.state(self._buf.tell() == 0)
         self._buf.write('"')
 
+        pos = self.pos
+
         last = None
         while True:
             try:
@@ -199,13 +211,16 @@ class JsonStreamLexer(GenMachine[str, Token]):
 
         raw = self._flip_buf()
         sv = json.loads(raw)
-        yield self._make_tok('STRING', sv, raw)
+        yield self._make_tok('STRING', sv, raw, pos)
 
         return self._do_main()
 
     def _do_number(self, c: str):
+        check.state(self._buf.tell() == 0)
         self._buf.write(c)
 
+        pos = self.pos
+
         while True:
             try:
                 c = self._char_in((yield None))  # noqa
@@ -240,7 +255,7 @@ class JsonStreamLexer(GenMachine[str, Token]):
                 self._raise(f'Invalid number format: {raw}')
 
             tk, tv = CONST_TOKENS[raw]
-            yield self._make_tok(tk, tv, raw)
+            yield self._make_tok(tk, tv, raw, pos)
 
             return self._do_main()
 
@@ -250,7 +265,7 @@ class JsonStreamLexer(GenMachine[str, Token]):
             nv = float(raw)
         else:
             nv = int(raw)
-        yield self._make_tok('NUMBER', nv, raw)
+        yield self._make_tok('NUMBER', nv, raw, pos)
 
         #
 
@@ -258,7 +273,7 @@ class JsonStreamLexer(GenMachine[str, Token]):
             return None
 
         if c in CONTROL_TOKENS:
-            yield self._make_tok(CONTROL_TOKENS[c], c, c)
+            yield self._make_tok(CONTROL_TOKENS[c], c, c, pos)
 
         elif not c.isspace():
             self._raise(f'Unexpected character after number: {c}')
@@ -266,6 +281,7 @@ class JsonStreamLexer(GenMachine[str, Token]):
         return self._do_main()
 
     def _do_const(self, c: str):
+        pos = self.pos
         raw = c
         while True:
             try:
@@ -280,6 +296,6 @@ class JsonStreamLexer(GenMachine[str, Token]):
                 self._raise(f'Invalid literal: {raw}')
 
         tk, tv = CONST_TOKENS[raw]
-        yield self._make_tok(tk, tv, raw)
+        yield self._make_tok(tk, tv, raw, pos)
 
         return self._do_main()

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/omlish/formats/xml.py

@@ -21,13 +21,13 @@ else:
 @dc.dataclass(frozen=True)
 class SimpleElement:
     tag: str
-    attributes: ta.Mapping[str, str] | None = dc.xfield(default=None, repr_fn=dc.truthy_repr)
+    attrs: ta.Mapping[str, str] | None = dc.xfield(default=None, repr_fn=dc.truthy_repr)
     body: ta.Sequence[ta.Union['SimpleElement', str]] | None = dc.xfield(default=None, repr_fn=dc.truthy_repr)
 
     def as_dict(self) -> dict[str, ta.Any]:
         dct: dict[str, ta.Any] = {'tag': self.tag}
-        if self.attributes:
-            dct['attributes'] = self.attributes
+        if self.attrs:
+            dct['attrs'] = self.attrs
         if self.body:
             dct['body'] = [
                 c.as_dict() if isinstance(c, SimpleElement) else c

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/omlish/http/sse.py

@@ -1,6 +1,9 @@
 """
 TODO:
  - end-of-line   = ( cr lf / cr / lf )
+
+See:
+ - https://github.com/florimondmanca/httpx-sse/blob/master/src/httpx_sse/_decoders.py
 """
 import string
 import typing as ta

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/omlish/marshal/__init__.py

@@ -77,9 +77,12 @@ from .objects import (  # noqa
 
 from .polymorphism import (  # noqa
     Impl,
+    Impls,
     Polymorphism,
     PolymorphismMarshalerFactory,
     PolymorphismUnmarshalerFactory,
+    make_polymorphism_marshaler,
+    make_polymorphism_unmarshaler,
     polymorphism_from_subclasses,
 )
 
@@ -101,6 +104,8 @@ from .standard import (  # noqa
 
 from .unions import (  # noqa
     PRIMITIVE_UNION_TYPES,
+    PolymorphismUnionMarshalerFactory,
+    PolymorphismUnionUnmarshalerFactory,
     PrimitiveUnionMarshaler,
     PrimitiveUnionMarshalerFactory,
     PrimitiveUnionUnmarshaler,

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/omlish/marshal/polymorphism.py

@@ -50,21 +50,19 @@ class Impl:
     alts: ta.AbstractSet[str] = frozenset()
 
 
-class Polymorphism:
+class Impls(ta.Sequence[Impl]):
     def __init__(
             self,
-            ty: type,
-            impls: ta.Iterable[Impl],
+            lst: ta.Iterable[Impl],
     ) -> None:
         super().__init__()
-        self._ty = ty
-        self._impls = list(impls)
+        self._lst = list(lst)
 
         by_ty: dict[type, Impl] = {}
         by_tag: dict[str, Impl] = {}
-        for i in self._impls:
-            if not issubclass(i.ty, ty) or i.ty in by_ty:
-                raise TypeError(i.ty, ty)
+        for i in self._lst:
+            if i.ty in by_ty:
+                raise TypeError(i.ty)
             if i.tag in by_tag:
                 raise NameError(i.tag)
             for a in i.alts:
@@ -77,13 +75,20 @@ class Polymorphism:
         self._by_ty = by_ty
         self._by_tag = by_tag
 
-    @property
-    def ty(self) -> type:
-        return self._ty
+    def __iter__(self) -> ta.Iterator[Impl]:
+        return iter(self._lst)
 
-    @property
-    def impls(self) -> ta.Sequence[Impl]:
-        return self._impls
+    def __len__(self) -> int:
+        return len(self._lst)
+
+    @ta.overload
+    def __getitem__(self, index: int) -> Impl: ...
+
+    @ta.overload
+    def __getitem__(self, index: slice) -> ta.Sequence[Impl]: ...
+
+    def __getitem__(self, index):
+        return self._lst[index]
 
     @property
     def by_ty(self) -> ta.Mapping[type, Impl]:
@@ -94,6 +99,29 @@ class Polymorphism:
         return self._by_tag
 
 
+class Polymorphism:
+    def __init__(
+            self,
+            ty: type,
+            impls: ta.Iterable[Impl],
+    ) -> None:
+        super().__init__()
+        self._ty = ty
+        self._impls = Impls(impls)
+
+        for i in self._impls:
+            if not issubclass(i.ty, ty):
+                raise TypeError(i.ty, ty)
+
+    @property
+    def ty(self) -> type:
+        return self._ty
+
+    @property
+    def impls(self) -> Impls:
+        return self._impls
+
+
 def polymorphism_from_subclasses(
         ty: type,
         *,
@@ -151,6 +179,23 @@ class FieldPolymorphismMarshaler(Marshaler):
         return {self.tf: tag, **m.marshal(ctx, o)}  # type: ignore
 
 
+def make_polymorphism_marshaler(
+        impls: Impls,
+        tt: TypeTagging,
+        ctx: MarshalContext,
+) -> Marshaler:
+    m = {
+        i.ty: (i.tag, ctx.make(i.ty))
+        for i in impls
+    }
+    if isinstance(tt, WrapperTypeTagging):
+        return WrapperPolymorphismMarshaler(m)
+    elif isinstance(tt, FieldTypeTagging):
+        return FieldPolymorphismMarshaler(m, tt.field)
+    else:
+        raise TypeError(tt)
+
+
 @dc.dataclass(frozen=True)
 class PolymorphismMarshalerFactory(MarshalerFactory):
     p: Polymorphism
@@ -161,16 +206,7 @@ class PolymorphismMarshalerFactory(MarshalerFactory):
 
     def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
         check.is_(rty, self.p.ty)
-        m = {
-            i.ty: (i.tag, ctx.make(i.ty))
-            for i in self.p.impls
-        }
-        if isinstance(self.tt, WrapperTypeTagging):
-            return WrapperPolymorphismMarshaler(m)
-        elif isinstance(self.tt, FieldTypeTagging):
-            return FieldPolymorphismMarshaler(m, self.tt.field)
-        else:
-            raise TypeError(self.tt)
+        return make_polymorphism_marshaler(self.p.impls, self.tt, ctx)
 
 
 ##
@@ -199,6 +235,25 @@ class FieldPolymorphismUnmarshaler(Unmarshaler):
         return u.unmarshal(ctx, ma)
 
 
+def make_polymorphism_unmarshaler(
+        impls: Impls,
+        tt: TypeTagging,
+        ctx: UnmarshalContext,
+) -> Unmarshaler:
+    m = {
+        t: u
+        for i in impls
+        for u in [ctx.make(i.ty)]
+        for t in [i.tag, *i.alts]
+    }
+    if isinstance(tt, WrapperTypeTagging):
+        return WrapperPolymorphismUnmarshaler(m)
+    elif isinstance(tt, FieldTypeTagging):
+        return FieldPolymorphismUnmarshaler(m, tt.field)
+    else:
+        raise TypeError(tt)
+
+
 @dc.dataclass(frozen=True)
 class PolymorphismUnmarshalerFactory(UnmarshalerFactory):
     p: Polymorphism
@@ -209,15 +264,4 @@ class PolymorphismUnmarshalerFactory(UnmarshalerFactory):
 
     def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
         check.is_(rty, self.p.ty)
-        m = {
-            t: u
-            for i in self.p.impls
-            for u in [ctx.make(i.ty)]
-            for t in [i.tag, *i.alts]
-        }
-        if isinstance(self.tt, WrapperTypeTagging):
-            return WrapperPolymorphismUnmarshaler(m)
-        elif isinstance(self.tt, FieldTypeTagging):
-            return FieldPolymorphismUnmarshaler(m, self.tt.field)
-        else:
-            raise TypeError(self.tt)
+        return make_polymorphism_unmarshaler(self.p.impls, self.tt, ctx)

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/omlish/marshal/unions.py

@@ -1,7 +1,8 @@
-import dataclasses as dc
 import typing as ta
 
+from .. import cached
 from .. import check
+from .. import dataclasses as dc
 from .. import matchfns as mfs
 from .. import reflect as rfl
 from .base import MarshalContext
@@ -10,6 +11,11 @@ from .base import MarshalerFactory
 from .base import UnmarshalContext
 from .base import Unmarshaler
 from .base import UnmarshalerFactory
+from .polymorphism import Impls
+from .polymorphism import TypeTagging
+from .polymorphism import WrapperTypeTagging
+from .polymorphism import make_polymorphism_marshaler
+from .polymorphism import make_polymorphism_unmarshaler
 from .values import Value
 
 
@@ -103,3 +109,40 @@ class PrimitiveUnionUnmarshalerFactory(UnmarshalerFactory):
 
 PRIMITIVE_UNION_MARSHALER_FACTORY = PrimitiveUnionMarshalerFactory()
 PRIMITIVE_UNION_UNMARSHALER_FACTORY = PrimitiveUnionUnmarshalerFactory()
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class PolymorphismUnionMarshalerFactory(MarshalerFactory):
+    impls: Impls
+    tt: TypeTagging = WrapperTypeTagging()
+
+    @cached.property
+    @dc.init
+    def rty(self) -> rfl.Union:
+        return rfl.type_(ta.Union[*tuple(i.ty for i in self.impls)])  # type: ignore
+
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Union) and rty == self.rty
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        return make_polymorphism_marshaler(self.impls, self.tt, ctx)
+
+
+@dc.dataclass(frozen=True)
+class PolymorphismUnionUnmarshalerFactory(UnmarshalerFactory):
+    impls: Impls
+    tt: TypeTagging = WrapperTypeTagging()
+
+    @cached.property
+    @dc.init
+    def rty(self) -> rfl.Union:
+        return rfl.type_(ta.Union[*tuple(i.ty for i in self.impls)])  # type: ignore
+
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Union) and rty == self.rty
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        return make_polymorphism_unmarshaler(self.impls, self.tt, ctx)

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/omlish/sql/queries/building.py

@@ -2,6 +2,7 @@ from .base import Builder
 from .binary import BinaryBuilder
 from .exprs import ExprBuilder
 from .idents import IdentBuilder
+from .inserts import InsertBuilder
 from .multi import MultiBuilder
 from .names import NameBuilder
 from .relations import RelationBuilder
@@ -11,6 +12,7 @@ from .unary import UnaryBuilder
 
 
 class StdBuilder(
+    InsertBuilder,
     SelectBuilder,
     StmtBuilder,
 

omlish-0.0.0.dev86/omlish/sql/queries/inserts.py

@@ -0,0 +1,50 @@
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+from .exprs import CanExpr
+from .exprs import Expr
+from .exprs import ExprBuilder
+from .idents import CanIdent
+from .idents import Ident
+from .relations import CanRelation
+from .relations import Relation
+from .relations import RelationBuilder
+from .selects import Select
+from .stmts import Stmt
+
+
+##
+
+
+class Values(dc.Frozen, lang.Final):
+    vs: ta.Sequence[Expr]
+
+
+class Insert(Stmt, lang.Final):
+    columns: ta.Sequence[Ident]
+    into: Relation
+    data: Values | Select
+
+
+CanValues: ta.TypeAlias = Values | ta.Sequence[CanExpr]
+
+
+class InsertBuilder(ExprBuilder, RelationBuilder):
+    def values(self, vs: CanValues) -> Values:
+        if isinstance(vs, Values):
+            return vs
+        else:
+            return Values(tuple(self.expr(v) for v in vs))
+
+    def insert(
+            self,
+            columns: ta.Sequence[CanIdent],
+            into: CanRelation,
+            data: Select | Values | ta.Sequence[CanExpr],
+    ) -> Insert:
+        return Insert(
+            columns=tuple(self.ident(c) for c in columns),
+            into=self.relation(into),
+            data=data if isinstance(data, Select) else self.values(data),
+        )

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/omlish/sql/queries/marshal.py

@@ -11,8 +11,10 @@ from .base import Node
 from .binary import BinaryOp
 from .binary import BinaryOps
 from .exprs import Expr
+from .inserts import Values
 from .multi import MultiKind
 from .relations import Relation
+from .selects import Select
 from .stmts import Stmt
 from .unary import UnaryOp
 from .unary import UnaryOps
@@ -72,3 +74,10 @@ def _install_standard_marshalling() -> None:
         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)]
+
+    insert_data_impls = msh.Impls([
+        msh.Impl(Values, 'values'),
+        msh.Impl(Select, 'select'),
+    ])
+    msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.PolymorphismUnionMarshalerFactory(insert_data_impls)]
+    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.PolymorphismUnionUnmarshalerFactory(insert_data_impls)]

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/omlish/sql/queries/multi.py

@@ -28,7 +28,7 @@ class MultiBuilder(ExprBuilder):
         if len(es) == 1:
             return self.expr(es[0])
         else:
-            return Multi(k, [self.expr(e) for e in es])
+            return Multi(k, tuple(self.expr(e) for e in es))
 
     def and_(self, *es: CanExpr) -> Expr:
         return self.multi(MultiKind.AND, *es)

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/omlish/sql/queries/rendering.py

@@ -27,6 +27,8 @@ from .binary import BinaryOps
 from .exprs import Literal
 from .exprs import NameExpr
 from .idents import Ident
+from .inserts import Insert
+from .inserts import Values
 from .multi import Multi
 from .multi import MultiKind
 from .names import Name
@@ -98,6 +100,29 @@ class StdRenderer(Renderer):
     def render_ident(self, o: Ident) -> None:
         self._out.write(f'"{o.s}"')
 
+    # inserts
+
+    @Renderer.render.register
+    def render_values(self, o: Values) -> None:
+        self._out.write('values (')
+        for i, v in enumerate(o.vs):
+            if i:
+                self._out.write(', ')
+            self.render(v)
+        self._out.write(')')
+
+    @Renderer.render.register
+    def render_insert(self, o: Insert) -> None:
+        self._out.write('insert into ')
+        self.render(o.into)
+        self._out.write(' (')
+        for i, c in enumerate(o.columns):
+            if i:
+                self._out.write(', ')
+            self.render(c)
+        self._out.write(') ')
+        self.render(o.data)
+
     # multis
 
     MULTI_KIND_TO_STR: ta.ClassVar[ta.Mapping[MultiKind, str]] = {

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86/omlish.egg-info}/PKG-INFO

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

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/omlish.egg-info/SOURCES.txt

@@ -421,6 +421,7 @@ omlish/sql/queries/binary.py
 omlish/sql/queries/building.py
 omlish/sql/queries/exprs.py
 omlish/sql/queries/idents.py
+omlish/sql/queries/inserts.py
 omlish/sql/queries/marshal.py
 omlish/sql/queries/multi.py
 omlish/sql/queries/names.py

{omlish-0.0.0.dev84 → omlish-0.0.0.dev86}/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.dev84'
+version = '0.0.0.dev86'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',