omlish 0.0.0.dev83__tar.gz → 0.0.0.dev85__tar.gz

{omlish-0.0.0.dev83/omlish.egg-info → omlish-0.0.0.dev85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev83
+Version: 0.0.0.dev85
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -40,7 +40,7 @@ Requires-Dist: aiomysql~=0.2; extra == "all"
 Requires-Dist: aiosqlite~=0.20; extra == "all"
 Requires-Dist: asyncpg~=0.30; extra == "all"
 Requires-Dist: apsw~=3.46; extra == "all"
-Requires-Dist: sqlean.py~=3.45; python_version < "3.13" and extra == "all"
+Requires-Dist: sqlean.py~=3.45; extra == "all"
 Requires-Dist: duckdb~=1.1; extra == "all"
 Requires-Dist: pytest~=8.0; extra == "all"
 Requires-Dist: anyio~=4.6; extra == "all"
@@ -86,7 +86,7 @@ Requires-Dist: aiomysql~=0.2; extra == "sqldrivers"
 Requires-Dist: aiosqlite~=0.20; extra == "sqldrivers"
 Requires-Dist: asyncpg~=0.30; extra == "sqldrivers"
 Requires-Dist: apsw~=3.46; extra == "sqldrivers"
-Requires-Dist: sqlean.py~=3.45; python_version < "3.13" and extra == "sqldrivers"
+Requires-Dist: sqlean.py~=3.45; extra == "sqldrivers"
 Requires-Dist: duckdb~=1.1; extra == "sqldrivers"
 Provides-Extra: testing
 Requires-Dist: pytest~=8.0; extra == "testing"

{omlish-0.0.0.dev83 → omlish-0.0.0.dev85}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev83'
-__revision__ = '25a87321f2e19f536595fa049cd2f53fb5497448'
+__version__ = '0.0.0.dev85'
+__revision__ = '24c65e4f91478fb31341b3508843574da87b8786-untracked'
 
 
 #
@@ -101,7 +101,7 @@ class Project(ProjectBase):
 
             'apsw ~= 3.46',
 
-            'sqlean.py ~= 3.45; python_version < "3.13"',
+            'sqlean.py ~= 3.45',
 
             'duckdb ~= 1.1',
         ],

{omlish-0.0.0.dev83 → omlish-0.0.0.dev85}/omlish/dataclasses/impl/fields.py

@@ -35,7 +35,7 @@ def raise_field_validation_error(
         field: str,
         fn: ta.Callable,
         value: ta.Any,
-):
+) -> ta.NoReturn:
     raise FieldValidationError(
         obj,
         field,

{omlish-0.0.0.dev83 → omlish-0.0.0.dev85}/omlish/dataclasses/impl/init.py

@@ -23,6 +23,19 @@ from .utils import set_new_attribute
 MISSING = dc.MISSING
 
 
+##
+
+
+def raise_validation_error(
+        obj: ta.Any,
+        fn: ta.Callable,
+) -> ta.NoReturn:
+    raise ValidationError(obj, fn)
+
+
+##
+
+
 class InitFields(ta.NamedTuple):
     all: ta.Sequence[dc.Field]
     ordered: ta.Sequence[dc.Field]
@@ -57,6 +70,9 @@ def init_param(f: dc.Field) -> str:
     return f'{f.name}: __dataclass_type_{f.name}__{default}'  # noqa
 
 
+##
+
+
 class InitBuilder:
 
     def __init__(
@@ -100,7 +116,7 @@ class InitBuilder:
             '__dataclass_builtins_object__': object,
             '__dataclass_builtins_isinstance__': isinstance,
             '__dataclass_builtins_TypeError__': TypeError,
-            '__dataclass_ValidationError__': ValidationError,
+            '__dataclass_raise_validation_error__': raise_validation_error,
             '__dataclass_raise_field_validation_error__': raise_field_validation_error,
         })
 
@@ -128,7 +144,7 @@ class InitBuilder:
             locals[cn] = fn
             csig = inspect.signature(fn)
             cas = ', '.join(p.name for p in csig.parameters.values())
-            body_lines.append(f'if not {cn}({cas}): raise __dataclass_ValidationError__')
+            body_lines.append(f'if not {cn}({cas}): __dataclass_raise_validation_error__({self._self_name}, {cn})')
 
         inits = self._info.merged_metadata.get(Init, [])
         mro_dct = lang.build_mro_dict(self._info.cls)

{omlish-0.0.0.dev83 → omlish-0.0.0.dev85}/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.dev85/omlish/formats/json/stream/build.py

@@ -0,0 +1,109 @@
+import typing as ta
+
+from .lex import SCALAR_VALUE_TYPES
+from .parse import BeginArray
+from .parse import BeginObject
+from .parse import EndArray
+from .parse import EndObject
+from .parse import JsonStreamObject
+from .parse import JsonStreamParserEvent
+from .parse import Key
+
+
+##
+
+
+class JsonObjectBuilder:
+    def __init__(
+            self,
+            *,
+            yield_object_lists: bool = False,
+    ) -> None:
+        self._stack: list[JsonStreamObject | list | Key] = []
+        self._yield_object_lists = yield_object_lists
+
+    class StateError(Exception):
+        pass
+
+    def __enter__(self) -> ta.Self:
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is None:
+            self.close()
+
+    def close(self) -> None:
+        if self._stack:
+            raise self.StateError
+
+    def _emit_value(self, v):
+        if not (stk := self._stack):
+            return (v,)
+
+        tv = stk[-1]
+        if isinstance(tv, Key):
+            stk.pop()
+            if not stk:
+                raise self.StateError
+
+            tv2 = stk[-1]
+            if not isinstance(tv2, JsonStreamObject):
+                raise self.StateError
+
+            tv2.append((tv.key, v))
+            return ()
+
+        elif isinstance(tv, list):
+            tv.append(v)
+            return ()
+
+        else:
+            raise self.StateError
+
+    def __call__(self, e: JsonStreamParserEvent) -> ta.Any:
+        stk = self._stack
+
+        #
+
+        if isinstance(e, SCALAR_VALUE_TYPES):
+            return self._emit_value(e)
+
+        #
+
+        elif e is BeginObject:
+            stk.append(JsonStreamObject())
+            return ()
+
+        elif isinstance(e, Key):
+            if not stk or not isinstance(stk[-1], JsonStreamObject):
+                raise self.StateError
+
+            stk.append(e)
+            return ()
+
+        elif e is EndObject:
+            tv: ta.Any
+            if not stk or not isinstance(tv := stk.pop(), JsonStreamObject):
+                raise self.StateError
+
+            if not self._yield_object_lists:
+                tv = dict(tv)
+
+            return self._emit_value(tv)
+
+        #
+
+        elif e is BeginArray:
+            stk.append([])
+            return ()
+
+        elif e is EndArray:
+            if not stk or not isinstance(tv := stk.pop(), list):
+                raise self.StateError
+
+            return self._emit_value(tv)
+
+        #
+
+        else:
+            raise TypeError(e)

{omlish-0.0.0.dev83 → omlish-0.0.0.dev85}/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.dev83 → omlish-0.0.0.dev85}/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.dev83 → omlish-0.0.0.dev85}/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.dev83 → omlish-0.0.0.dev85}/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.dev83 → omlish-0.0.0.dev85}/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.dev85/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.dev83 → omlish-0.0.0.dev85}/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.dev83 → omlish-0.0.0.dev85}/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.dev83 → omlish-0.0.0.dev85}/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.dev83 → omlish-0.0.0.dev85/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev83
+Version: 0.0.0.dev85
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -40,7 +40,7 @@ Requires-Dist: aiomysql~=0.2; extra == "all"
 Requires-Dist: aiosqlite~=0.20; extra == "all"
 Requires-Dist: asyncpg~=0.30; extra == "all"
 Requires-Dist: apsw~=3.46; extra == "all"
-Requires-Dist: sqlean.py~=3.45; python_version < "3.13" and extra == "all"
+Requires-Dist: sqlean.py~=3.45; extra == "all"
 Requires-Dist: duckdb~=1.1; extra == "all"
 Requires-Dist: pytest~=8.0; extra == "all"
 Requires-Dist: anyio~=4.6; extra == "all"
@@ -86,7 +86,7 @@ Requires-Dist: aiomysql~=0.2; extra == "sqldrivers"
 Requires-Dist: aiosqlite~=0.20; extra == "sqldrivers"
 Requires-Dist: asyncpg~=0.30; extra == "sqldrivers"
 Requires-Dist: apsw~=3.46; extra == "sqldrivers"
-Requires-Dist: sqlean.py~=3.45; python_version < "3.13" and extra == "sqldrivers"
+Requires-Dist: sqlean.py~=3.45; extra == "sqldrivers"
 Requires-Dist: duckdb~=1.1; extra == "sqldrivers"
 Provides-Extra: testing
 Requires-Dist: pytest~=8.0; extra == "testing"

{omlish-0.0.0.dev83 → omlish-0.0.0.dev85}/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