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

omlish/marshal/polymorphism/marshal.py

@@ -7,7 +7,7 @@ from ... import lang
 from ... import reflect as rfl
 from ..base import MarshalContext
 from ..base import Marshaler
-from ..base import MarshalerFactory
+from ..base import SimpleMarshalerFactory
 from ..values import Value
 from .metadata import FieldTypeTagging
 from .metadata import Impls
@@ -68,7 +68,7 @@ def make_polymorphism_marshaler(
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismMarshalerFactory(MarshalerFactory):
+class PolymorphismMarshalerFactory(SimpleMarshalerFactory):
     p: Polymorphism
     tt: TypeTagging = WrapperTypeTagging()
 

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/marshal/polymorphism/unions.py

@@ -8,10 +8,10 @@ from ... import reflect as rfl
 from ...funcs import match as mfs
 from ..base import MarshalContext
 from ..base import Marshaler
-from ..base import MarshalerFactory
+from ..base import SimpleMarshalerFactory
+from ..base import SimpleUnmarshalerFactory
 from ..base import UnmarshalContext
 from ..base import Unmarshaler
-from ..base import UnmarshalerFactory
 from ..values import Value
 from .marshal import make_polymorphism_marshaler
 from .metadata import Impls
@@ -69,7 +69,7 @@ class PrimitiveUnionMarshaler(Marshaler):
 
 
 @dc.dataclass(frozen=True)
-class PrimitiveUnionMarshalerFactory(MarshalerFactory):
+class PrimitiveUnionMarshalerFactory(SimpleMarshalerFactory):
     tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
 
     def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
@@ -94,7 +94,7 @@ class PrimitiveUnionUnmarshaler(Unmarshaler):
 
 
 @dc.dataclass(frozen=True)
-class PrimitiveUnionUnmarshalerFactory(UnmarshalerFactory):
+class PrimitiveUnionUnmarshalerFactory(SimpleUnmarshalerFactory):
     tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
 
     def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
@@ -140,12 +140,12 @@ class _BasePolymorphismUnionFactory(lang.Abstract):
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismUnionMarshalerFactory(_BasePolymorphismUnionFactory, MarshalerFactory):
+class PolymorphismUnionMarshalerFactory(_BasePolymorphismUnionFactory, SimpleMarshalerFactory):
     def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
         return make_polymorphism_marshaler(self.get_impls(rty), self.tt, ctx)
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismUnionUnmarshalerFactory(_BasePolymorphismUnionFactory, UnmarshalerFactory):
+class PolymorphismUnionUnmarshalerFactory(_BasePolymorphismUnionFactory, SimpleUnmarshalerFactory):
     def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
         return make_polymorphism_unmarshaler(self.get_impls(rty), self.tt, ctx)

omlish/marshal/polymorphism/unmarshal.py

@@ -6,9 +6,9 @@ import typing as ta
 from ... import check
 from ... import lang
 from ... import reflect as rfl
+from ..base import SimpleUnmarshalerFactory
 from ..base import UnmarshalContext
 from ..base import Unmarshaler
-from ..base import UnmarshalerFactory
 from ..values import Value
 from .metadata import FieldTypeTagging
 from .metadata import Impls
@@ -75,7 +75,7 @@ def make_polymorphism_unmarshaler(
 
 
 @dc.dataclass(frozen=True)
-class PolymorphismUnmarshalerFactory(UnmarshalerFactory):
+class PolymorphismUnmarshalerFactory(SimpleUnmarshalerFactory):
     p: Polymorphism
     tt: TypeTagging = WrapperTypeTagging()
 

omlish/marshal/singular/base64.py

@@ -19,6 +19,9 @@ from ..values import Value
 T = ta.TypeVar('T')
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class Base64MarshalerUnmarshaler(Marshaler, Unmarshaler, ta.Generic[T]):
     ty: type[T]

omlish/marshal/singular/enums.py

@@ -6,13 +6,16 @@ from ... import check
 from ... import reflect as rfl
 from ..base import MarshalContext
 from ..base import Marshaler
-from ..base import MarshalerFactory
+from ..base import SimpleMarshalerFactory
+from ..base import SimpleUnmarshalerFactory
 from ..base import UnmarshalContext
 from ..base import Unmarshaler
-from ..base import UnmarshalerFactory
 from ..values import Value
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class EnumMarshaler(Marshaler):
     ty: type[enum.Enum]
@@ -21,7 +24,7 @@ class EnumMarshaler(Marshaler):
         return o.name
 
 
-class EnumMarshalerFactory(MarshalerFactory):
+class EnumMarshalerFactory(SimpleMarshalerFactory):
     def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
         return isinstance(rty, type) and issubclass(rty, enum.Enum)
 
@@ -39,7 +42,7 @@ class EnumUnmarshaler(Unmarshaler):
         return self.ty[check.isinstance(v, str)]
 
 
-class EnumUnmarshalerFactory(UnmarshalerFactory):
+class EnumUnmarshalerFactory(SimpleUnmarshalerFactory):
     def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
         return isinstance(rty, type) and issubclass(rty, enum.Enum)
 

omlish/marshal/singular/numbers.py

@@ -12,6 +12,9 @@ from ..base import Unmarshaler
 from ..values import Value
 
 
+##
+
+
 class ComplexMarshalerUnmarshaler(Marshaler, Unmarshaler):
     def marshal(self, ctx: MarshalContext, o: complex) -> Value:
         return [o.real, o.imag]

omlish/marshal/singular/uuids.py

@@ -11,6 +11,9 @@ from ..base import Unmarshaler
 from ..values import Value
 
 
+##
+
+
 PATTERN = re.compile(r'([0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12})|([0-9A-Fa-f]{32})')
 
 

omlish/marshal/standard.py

@@ -1,5 +1,6 @@
-from ..funcs import match as mfs
 from .base import MarshalerFactory
+from .base import MultiMarshalerFactory
+from .base import MultiUnmarshalerFactory
 from .base import RecursiveMarshalerFactory
 from .base import RecursiveUnmarshalerFactory
 from .base import TypeCacheMarshalerFactory
@@ -65,7 +66,7 @@ STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
 def new_standard_marshaler_factory() -> MarshalerFactory:
     return TypeCacheMarshalerFactory(
         RecursiveMarshalerFactory(
-            mfs.MultiMatchFn(
+            MultiMarshalerFactory(
                 list(STANDARD_MARSHALER_FACTORIES),
             ),
         ),
@@ -98,8 +99,29 @@ STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
 def new_standard_unmarshaler_factory() -> UnmarshalerFactory:
     return TypeCacheUnmarshalerFactory(
         RecursiveUnmarshalerFactory(
-            mfs.MultiMatchFn(
+            MultiUnmarshalerFactory(
                 list(STANDARD_UNMARSHALER_FACTORIES),
             ),
         ),
     )
+
+
+##
+
+
+def install_standard_factories(
+        *factories: MarshalerFactory | UnmarshalerFactory,
+) -> None:
+    for f in factories:
+        k = False
+
+        if isinstance(f, MarshalerFactory):
+            STANDARD_MARSHALER_FACTORIES[0:0] = [f]
+            k = True
+
+        if isinstance(f, UnmarshalerFactory):
+            STANDARD_UNMARSHALER_FACTORIES[0:0] = [f]
+            k = True
+
+        if not k:
+            raise TypeError(f)

omlish/marshal/trivial/any.py

@@ -10,6 +10,9 @@ from ..base import Unmarshaler
 from ..values import Value
 
 
+##
+
+
 class AnyMarshalerUnmarshaler(Marshaler, Unmarshaler):
     def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
         return ctx.make(type(o)).marshal(ctx, o)

omlish/marshal/trivial/forbidden.py

@@ -5,6 +5,8 @@ from ... import reflect as rfl
 from ...funcs import match as mfs
 from ..base import MarshalContext
 from ..base import Marshaler
+from ..base import SimpleMarshalerFactory
+from ..base import SimpleUnmarshalerFactory
 from ..base import UnmarshalContext
 from ..base import Unmarshaler
 from ..exceptions import ForbiddenTypeError
@@ -14,6 +16,9 @@ C = ta.TypeVar('C')
 R = ta.TypeVar('R')
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class ForbiddenTypeFactory(mfs.MatchFn[[C, rfl.Type], R]):
     rtys: ta.AbstractSet[rfl.Type]
@@ -26,10 +31,16 @@ class ForbiddenTypeFactory(mfs.MatchFn[[C, rfl.Type], R]):
 
 
 @dc.dataclass(frozen=True)
-class ForbiddenTypeMarshalerFactory(ForbiddenTypeFactory[MarshalContext, Marshaler]):
+class ForbiddenTypeMarshalerFactory(
+    ForbiddenTypeFactory[MarshalContext, Marshaler],
+    SimpleMarshalerFactory,
+):
     pass
 
 
 @dc.dataclass(frozen=True)
-class ForbiddenTypeUnmarshalerFactory(ForbiddenTypeFactory[UnmarshalContext, Unmarshaler]):
+class ForbiddenTypeUnmarshalerFactory(
+    ForbiddenTypeFactory[UnmarshalContext, Unmarshaler],
+    SimpleUnmarshalerFactory,
+):
     pass

omlish/marshal/trivial/nop.py

@@ -7,6 +7,9 @@ from ..base import Unmarshaler
 from ..values import Value
 
 
+##
+
+
 class NopMarshalerUnmarshaler(Marshaler, Unmarshaler):
     def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
         return o  # noqa

omlish/secrets/marshal.py

@@ -52,16 +52,14 @@ def marshal_secret_field(f: dc.Field) -> dc.Field:
 
 @lang.static_init
 def _install_standard_marshalling() -> None:
-    msh.STANDARD_MARSHALER_FACTORIES[0:0] = [
+    msh.install_standard_factories(
         msh.ForbiddenTypeMarshalerFactory({Secret}),
+        msh.ForbiddenTypeUnmarshalerFactory({Secret}),
+
         msh.TypeMapMarshalerFactory({
             rfl.type_(SecretRefOrStr): StrOrSecretRefMarshalerUnmarshaler(),
         }),
-    ]
-
-    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [
-        msh.ForbiddenTypeUnmarshalerFactory({Secret}),
         msh.TypeMapUnmarshalerFactory({
             rfl.type_(SecretRefOrStr): StrOrSecretRefMarshalerUnmarshaler(),
         }),
-    ]
+    )

omlish/specs/jsonrpc/marshal.py

@@ -49,11 +49,10 @@ class NotSpecifiedUnionUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
 
 @lang.static_init
 def _install_standard_marshalling() -> None:
-    msh.STANDARD_MARSHALER_FACTORIES[0:0] = [
+    msh.install_standard_factories(
         msh.ForbiddenTypeMarshalerFactory({_NOT_SPECIFIED_RTY}),
-        NotSpecifiedUnionMarshalerFactory(),
-    ]
-    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [
         msh.ForbiddenTypeUnmarshalerFactory({_NOT_SPECIFIED_RTY}),
+
+        NotSpecifiedUnionMarshalerFactory(),
         NotSpecifiedUnionUnmarshalerFactory(),
-    ]
+    )

omlish/specs/openapi/marshal.py

@@ -59,5 +59,7 @@ class _ReferenceUnionUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
 
 @lang.static_init
 def _install_standard_marshalling() -> None:
-    msh.STANDARD_MARSHALER_FACTORIES[0:0] = [_ReferenceUnionMarshalerFactory()]
-    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [_ReferenceUnionUnmarshalerFactory()]
+    msh.install_standard_factories(
+        _ReferenceUnionMarshalerFactory(),
+        _ReferenceUnionUnmarshalerFactory(),
+    )

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,