omlish 0.0.0.dev268__py3-none-any.whl → 0.0.0.dev269__py3-none-any.whl

omlish/lang/classes/abstract.py

@@ -5,6 +5,9 @@ import typing as ta
 T = ta.TypeVar('T')
 
 
+##
+
+
 _DISABLE_CHECKS = False
 
 _ABSTRACT_METHODS_ATTR = '__abstractmethods__'

omlish/lang/comparison.py

@@ -1,6 +1,9 @@
 import typing as ta
 
 
+##
+
+
 def cmp(l: ta.Any, r: ta.Any) -> int:
     return int(l > r) - int(l < r)
 

omlish/lang/datetimes.py

@@ -1,6 +1,9 @@
 import datetime
 
 
+##
+
+
 def utcnow() -> datetime.datetime:
     return datetime.datetime.now(tz=datetime.UTC)
 

omlish/lang/generators.py

@@ -203,8 +203,8 @@ class GeneratorMappedIterator(ta.Generic[O, I, R]):
     Like a `map` iterator but takes a generator instead of a function. Provided generator *must* yield outputs 1:1 with
     inputs.
 
-    Generator return value will be captured on `value` property - if present generator stopped, it absent iterator
-    stopped.
+    Generator return value will be captured on `value` property - present if the generator stopped, absent if the
+    iterator stopped.
     """
 
     def __init__(self, g: ta.Generator[O, I, R], it: ta.Iterator[I]) -> None:

omlish/lang/maybes.py

@@ -6,6 +6,9 @@ T = ta.TypeVar('T')
 U = ta.TypeVar('U')
 
 
+##
+
+
 class ValueNotPresentException(BaseException):
     pass
 

omlish/lang/resolving.py

@@ -3,6 +3,9 @@ import string
 import typing as ta
 
 
+##
+
+
 class ResolvableClassNameError(NameError):
     pass
 

omlish/lang/sys.py

@@ -1,6 +1,9 @@
 import sys
 
 
+##
+
+
 REQUIRED_PYTHON_VERSION = (3, 12)
 
 

omlish/marshal/objects/dataclasses.py

@@ -66,7 +66,7 @@ def get_dataclass_field_infos(
     type_hints = ta.get_type_hints(ty)
 
     ret: list[FieldInfo] = []
-    for field in dc_rf.fields.values():
+    for field in dc_rf.instance_fields:
         if (f_naming := field.metadata.get(Naming, dc_naming)) is not None:
             um_name = translate_name(field.name, f_naming)
         else:

omlish/marshal/polymorphism/metadata.py

@@ -109,12 +109,11 @@ def polymorphism_from_subclasses(
         ty: type,
         *,
         naming: Naming | None = None,
-        strip_suffix: bool = False,
+        strip_suffix: bool | ta.Literal['auto'] = False,
 ) -> Polymorphism:
-    dct: dict[str, Impl] = {}
-
     seen: set[type] = set()
     todo: list[type] = [ty]
+    impls: set[type] = set()
     while todo:
         cur = todo.pop()
         seen.add(cur)
@@ -124,6 +123,13 @@ def polymorphism_from_subclasses(
         if lang.is_abstract_class(cur):
             continue
 
+        impls.add(cur)
+
+    if strip_suffix == 'auto':
+        strip_suffix = all(c.__name__.endswith(ty.__name__) for c in impls)
+
+    dct: dict[str, Impl] = {}
+    for cur in impls:
         name = cur.__name__
         if strip_suffix:
             name = lang.strip_suffix(name, ty.__name__)

omlish/sql/alchemy/__init__.py

@@ -1,3 +1,34 @@
+# ruff: noqa: I001
+import typing as _ta
+
+from ... import lang as _lang
+
+
+if _ta.TYPE_CHECKING:
+    from .apiadapter import (  # noqa
+        SqlalchemyApiWrapper,
+
+        SqlalchemyApiRows,
+        SqlalchemyApiConn,
+        SqlalchemyApiDb,
+        SqlalchemyApiAdapter,
+
+        api_adapt,
+    )
+
+else:
+    _lang.proxy_init(globals(), '.apiadapter', [
+        'SqlalchemyApiWrapper',
+
+        'SqlalchemyApiRows',
+        'SqlalchemyApiConn',
+        'SqlalchemyApiDb',
+        'SqlalchemyApiAdapter',
+
+        'api_adapt',
+    ])
+
+
 from .asyncs import (  # noqa
     AsyncConnection,
     AsyncConnectionLike,

omlish/sql/alchemy/apiadapter.py

@@ -0,0 +1,121 @@
+import typing as ta
+
+import sqlalchemy as sa
+
+from ... import check
+from .. import api
+from ..api.dbapi import build_dbapi_columns
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class SqlalchemyApiWrapper(api.ContextCloser, ta.Generic[T]):
+    def __init__(
+            self,
+            u: T,
+            *,
+            auto_close: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._u = u
+        self._auto_close = auto_close
+
+    def close(self) -> None:
+        if self._auto_close and hasattr(self._u, 'close'):
+            self._u.close()
+        super().close()
+
+
+##
+
+
+class SqlalchemyApiRows(api.Rows):
+    def __init__(self, columns: api.Columns, rows: ta.Sequence[api.Row]) -> None:
+        super().__init__()
+
+        self._columns = columns
+        self._rows = rows
+
+        self._it = iter(self._rows)
+
+    @property
+    def columns(self) -> api.Columns:
+        return self._columns
+
+    def __next__(self) -> api.Row:
+        return next(self._it)
+
+
+class SqlalchemyApiConn(SqlalchemyApiWrapper[sa.engine.Connection], api.Conn):
+    @property
+    def adapter(self) -> api.Adapter:
+        raise NotImplementedError
+
+    def query(self, query: api.Query) -> api.Rows:
+        check.empty(query.args)
+        result: sa.engine.cursor.CursorResult
+        with self._u.execute(sa.text(query.text)) as result:
+            cols = build_dbapi_columns(result.cursor.description)
+            sa_rows = result.fetchall()
+            rows = [
+                api.Row(cols, tuple(sa_row))
+                for sa_row in sa_rows
+            ]
+        return SqlalchemyApiRows(cols, rows)
+
+
+class SqlalchemyApiDb(SqlalchemyApiWrapper[sa.engine.Engine], api.Db):
+    def connect(self) -> api.Conn:
+        return SqlalchemyApiConn(self._u.connect(), auto_close=True)
+
+    @property
+    def adapter(self) -> api.Adapter:
+        raise NotImplementedError
+
+
+class SqlalchemyApiAdapter(api.Adapter):
+    def scan_type(self, c: api.Column) -> type:
+        raise NotImplementedError
+
+
+##
+
+
+@ta.overload
+def api_adapt(o: sa.engine.Connection) -> SqlalchemyApiConn:
+    ...
+
+
+@ta.overload
+def api_adapt(o: api.Conn) -> api.Conn:
+    ...
+
+
+@ta.overload
+def api_adapt(o: sa.engine.Engine) -> SqlalchemyApiDb:
+    ...
+
+
+@ta.overload
+def api_adapt(o: api.Db) -> api.Db:
+    ...
+
+
+def api_adapt(o):
+    if isinstance(o, sa.engine.Connection):
+        return SqlalchemyApiConn(o)
+    elif isinstance(o, api.Conn):
+        return o
+
+    elif isinstance(o, sa.engine.Engine):
+        return SqlalchemyApiDb(o)
+    elif isinstance(o, api.Db):
+        return o
+
+    else:
+        raise TypeError(o)

omlish/sql/api/__init__.py

@@ -0,0 +1,39 @@
+from .base import (  # noqa
+    Closer,
+    ContextCloser,
+
+    Querier,
+    Rows,
+    Conn,
+    Db,
+    Adapter,
+)
+
+from .columns import (  # noqa
+    Column,
+    Columns,
+)
+
+from .errors import (  # noqa
+    Error,
+
+    ColumnError,
+    DuplicateColumnNameError,
+    MismatchedColumnCountError,
+
+    QueryError,
+)
+
+from .funcs import (  # noqa
+    query,
+    exec,  # noqa
+)
+
+from .queries import (  # noqa
+    QueryMode,
+    Query,
+)
+
+from .rows import (  # noqa
+    Row,
+)

omlish/sql/api/base.py

@@ -24,6 +24,7 @@ class ContextCloser(Closer):
     def __enter__(self) -> ta.Self:
         return self
 
+    @ta.final
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 

omlish/sql/parsing/parsing.py

@@ -33,7 +33,7 @@ class _ParseVisitor(MinisqlVisitor):
     def visitExprSelectItem(self, ctx: MinisqlParser.ExprSelectItemContext):
         value = self.visit(ctx.expr())
         label = self.visit(ctx.ident()) if ctx.ident() is not None else None
-        return no.SelectItem(value, label)
+        return no.ExprSelectItem(value, label)
 
     def visitIntegerNumber(self, ctx: MinisqlParser.IntegerNumberContext):
         return no.Literal(int(ctx.INTEGER_VALUE().getText()))

omlish/sql/queries/__init__.py

@@ -1,6 +1,7 @@
 from .base import (  # noqa
     Builder,
     Node,
+    NodeComparisonTypeError,
     Value,
 )
 
@@ -18,6 +19,7 @@ from .exprs import (  # noqa
     ExprBuilder,
     Literal,
     NameExpr,
+    ParamExpr,
 )
 
 from .idents import (  # noqa
@@ -66,7 +68,9 @@ from .rendering import (  # noqa
 )
 
 from .selects import (  # noqa
+    AllSelectItem,
     CanRelation,
+    ExprSelectItem,
     Select,
     SelectBuilder,
     SelectItem,

omlish/sql/queries/base.py

@@ -1,3 +1,4 @@
+import types
 import typing as ta
 
 from ... import dataclasses as dc
@@ -13,8 +14,118 @@ Value: ta.TypeAlias = ta.Any
 ##
 
 
-class Node(dc.Frozen, lang.Abstract, cache_hash=True):
-    pass
+class NodeComparisonTypeError(TypeError):
+    def __init__(self, cls: type['Node'], *args: ta.Any) -> None:
+        super().__init__(
+            'Query node types are not comparable or hashable - this would be a common source of confusion when '
+            'constructing query filters',
+            cls,
+            *args,
+        )
+
+
+class Node(
+    dc.Frozen,
+    lang.Abstract,
+    eq=False,
+    confer=frozenset([
+        *dc.get_metaclass_params(dc.Frozen).confer,
+        'eq',
+    ]),
+):
+    @ta.final
+    def __hash__(self) -> ta.NoReturn:
+        raise NodeComparisonTypeError(type(self))
+
+    @ta.final
+    def __eq__(self, other) -> ta.NoReturn:
+        raise NodeComparisonTypeError(type(self))
+
+    @ta.final
+    def __ne__(self, other) -> ta.NoReturn:
+        raise NodeComparisonTypeError(type(self))
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class _Fields:
+        cmp_fields: ta.Sequence[str]
+        hash_fields: ta.Sequence[str]
+
+    __node_fields__: ta.ClassVar[tuple[str, ...]]
+
+    @classmethod
+    def _fields(cls) -> _Fields:
+        try:
+            return cls.__dict__['__node_fields__']
+        except KeyError:
+            pass
+
+        dc_info = dc.reflect(cls)
+        fields = Node._Fields(
+            cmp_fields=tuple(f.name for f in dc_info.instance_fields if f.compare),
+            hash_fields=tuple(f.name for f in dc_info.instance_fields if (f.compare if f.hash is None else f.hash)),
+        )
+
+        setattr(cls, '__node_fields__', fields)
+        return fields
+
+    _hash: ta.ClassVar[int]
+
+    def hash(self) -> int:
+        try:
+            return self._hash
+        except AttributeError:
+            pass
+
+        h = hash(tuple(getattr(self, f) for f in self._fields().hash_fields))
+        object.__setattr__(self, '_hash', h)
+        return h
+
+    def eq(self, other: 'Node') -> bool | types.NotImplementedType:
+        if self is other:
+            return True
+
+        def rec(l, r):
+            if l.__class__ is not r.__class__:
+                return NotImplemented
+
+            if isinstance(l, lang.BUILTIN_SCALAR_ITERABLE_TYPES):
+                return l == r
+
+            elif isinstance(l, ta.Mapping):
+                ks = set(l)
+                if set(r) != ks:
+                    return False
+                for k, lv in l.items():
+                    rv = r[k]
+                    if (ret := rec(lv, rv)) is not True:
+                        return ret
+                return True
+
+            elif isinstance(l, ta.Sequence):
+                if len(l) != len(r):
+                    return False
+                for le, re in zip(l, r):
+                    if (ret := rec(le, re)) is not True:
+                        return ret
+                return True
+
+            elif isinstance(l, Node):
+                return l.eq(r)
+
+            else:
+                return l == r
+
+        for f in self._fields().cmp_fields:
+            lf = getattr(self, f)
+            rf = getattr(other, f)
+            if (ret := rec(lf, rf)) is not True:
+                return ret
+        return True
+
+
+##
 
 
 class Builder(lang.Abstract):

omlish/sql/queries/exprs.py

@@ -2,6 +2,7 @@
 TODO:
  - case
  - cast / ::
+ - explicit null? already wrapped in non-null Literal node
 """
 import typing as ta
 
@@ -13,6 +14,9 @@ from .names import CanName
 from .names import Name
 from .names import NameBuilder
 from .names import NameLike
+from .params import CanParam
+from .params import Param
+from .params import ParamBuilder
 
 
 ##
@@ -36,14 +40,21 @@ class NameExpr(Expr, lang.Final):
     n: Name
 
 
+#
+
+
+class ParamExpr(Expr, lang.Final):
+    p: Param
+
+
 ##
 
 
 CanLiteral: ta.TypeAlias = Literal | Value
-CanExpr: ta.TypeAlias = Expr | CanName | CanLiteral
+CanExpr: ta.TypeAlias = Expr | CanParam | CanName | CanLiteral
 
 
-class ExprBuilder(NameBuilder):
+class ExprBuilder(ParamBuilder, NameBuilder):
     def literal(self, o: CanLiteral) -> Literal:
         if isinstance(o, Literal):
             return o
@@ -61,6 +72,8 @@ class ExprBuilder(NameBuilder):
     def expr(self, o: CanExpr) -> Expr:
         if isinstance(o, Expr):
             return o
+        elif isinstance(o, Param):
+            return ParamExpr(o)
         elif isinstance(o, (NameLike, IdentLike)):
             return NameExpr(self.name(o))
         else:

omlish/sql/queries/inserts.py

@@ -2,6 +2,7 @@ import typing as ta
 
 from ... import dataclasses as dc
 from ... import lang
+from .base import Node
 from .exprs import CanExpr
 from .exprs import Expr
 from .exprs import ExprBuilder
@@ -17,7 +18,7 @@ from .stmts import Stmt
 ##
 
 
-class Values(dc.Frozen, lang.Final):
+class Values(Node, lang.Final):
     vs: ta.Sequence[Expr] = dc.xfield(coerce=tuple)
 
 

omlish/sql/queries/marshal.py

@@ -20,6 +20,7 @@ from .multi import MultiKind
 from .relations import JoinKind
 from .relations import Relation
 from .selects import Select
+from .selects import SelectItem
 from .stmts import Stmt
 from .unary import UnaryOp
 from .unary import UnaryOps
@@ -78,9 +79,14 @@ def _install_standard_marshalling() -> None:
         Expr,
         Node,
         Relation,
+        SelectItem,
         Stmt,
     ]:
-        p = msh.polymorphism_from_subclasses(cls, naming=msh.Naming.SNAKE)
+        p = msh.polymorphism_from_subclasses(
+            cls,
+            naming=msh.Naming.SNAKE,
+            strip_suffix='auto',
+        )
         msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.PolymorphismMarshalerFactory(p)]
         msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.PolymorphismUnmarshalerFactory(p)]
 

omlish/sql/queries/params.py

@@ -1,14 +1,15 @@
 import typing as ta
 
+from ... import dataclasses as dc
 from ... import lang
 from .base import Builder
-from .exprs import Expr
 
 
 ##
 
 
-class Param(Expr, lang.Final):
+@dc.dataclass(frozen=True)
+class Param(lang.Final):
     n: str | None = None
 
     def __repr__(self) -> str:

omlish/sql/queries/rendering.py

@@ -29,6 +29,7 @@ from .binary import BinaryOp
 from .binary import BinaryOps
 from .exprs import Literal
 from .exprs import NameExpr
+from .exprs import ParamExpr
 from .idents import Ident
 from .inserts import Insert
 from .inserts import Values
@@ -39,8 +40,9 @@ from .params import Param
 from .relations import Join
 from .relations import JoinKind
 from .relations import Table
+from .selects import AllSelectItem
+from .selects import ExprSelectItem
 from .selects import Select
-from .selects import SelectItem
 from .unary import Unary
 from .unary import UnaryOp
 from .unary import UnaryOps
@@ -149,8 +151,8 @@ class StdRenderer(Renderer):
         return self.render(o.n)
 
     @Renderer.render.register
-    def render_param(self, o: Param) -> tp.Part:
-        return self._params_preparer.add(o.n if o.n is not None else id(o))
+    def render_param_expr(self, o: ParamExpr) -> tp.Part:
+        return self.render(o.p)
 
     # idents
 
@@ -201,6 +203,12 @@ class StdRenderer(Renderer):
             out.append(self.render(i))
         return tp.Concat(out)
 
+    # params
+
+    @Renderer.render.register
+    def render_param(self, o: Param) -> tp.Part:
+        return self._params_preparer.add(o.n if o.n is not None else id(o))
+
     # relations
 
     @Renderer.render.register
@@ -235,7 +243,11 @@ class StdRenderer(Renderer):
     # selects
 
     @Renderer.render.register
-    def render_select_item(self, o: SelectItem) -> tp.Part:
+    def render_all_select_item(self, o: AllSelectItem) -> tp.Part:
+        return '*'
+
+    @Renderer.render.register
+    def render_expr_select_item(self, o: ExprSelectItem) -> tp.Part:
         return [
             self.render(o.v),
             *(['as', self.render(o.a)] if o.a is not None else []),

omlish/sql/queries/selects.py

@@ -16,11 +16,22 @@ from .stmts import Stmt
 ##
 
 
-class SelectItem(Node, lang.Final):
+class SelectItem(Node, lang.Abstract):
+    pass
+
+
+class AllSelectItem(SelectItem, lang.Final):
+    pass
+
+
+class ExprSelectItem(SelectItem, lang.Final):
     v: Expr
     a: Ident | None = dc.xfield(None, repr_fn=dc.opt_repr)
 
 
+##
+
+
 class Select(Stmt, lang.Final):
     items: ta.Sequence[SelectItem] = dc.xfield(coerce=tuple)
     from_: Relation | None = dc.xfield(None, repr_fn=dc.opt_repr)
@@ -31,11 +42,15 @@ CanSelectItem: ta.TypeAlias = SelectItem | CanExpr
 
 
 class SelectBuilder(RelationBuilder, ExprBuilder):
+    @property
+    def star(self) -> AllSelectItem:
+        return AllSelectItem()
+
     def select_item(self, o: CanSelectItem) -> SelectItem:
         if isinstance(o, SelectItem):
             return o
         else:
-            return SelectItem(self.expr(o))
+            return ExprSelectItem(self.expr(o))
 
     def select(
             self,

{omlish-0.0.0.dev268.dist-info → omlish-0.0.0.dev269.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev268
+Version: 0.0.0.dev269
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause