omlish 0.0.0.dev86__tar.gz → 0.0.0.dev88__tar.gz

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

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

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

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

{omlish-0.0.0.dev86 → omlish-0.0.0.dev88}/omlish/formats/json/cli/cli.py

@@ -168,10 +168,9 @@ def _main() -> None:
                 else:
                     renderer = StreamJsonRenderer(
                         out,
-                        StreamJsonRenderer.Options(
-                            **kw,
-                            style=term_color if args.color else None,
-                        ),
+                        style=term_color if args.color else None,
+                        delimiter='\n',
+                        **kw,
                     )
                     build = None
 
@@ -198,7 +197,8 @@ def _main() -> None:
                     if not buf:
                         break
 
-                out.write('\n')
+                if renderer is not None:
+                    out.write('\n')
 
         else:
             with io.TextIOWrapper(in_file) as tw:

{omlish-0.0.0.dev86 → omlish-0.0.0.dev88}/omlish/formats/json/render.py

@@ -1,5 +1,4 @@
 import abc
-import dataclasses as dc
 import enum
 import io
 import json
@@ -20,35 +19,32 @@ class AbstractJsonRenderer(lang.Abstract, ta.Generic[I]):
         VALUE = enum.auto()
         KEY = enum.auto()
 
-    @dc.dataclass(frozen=True, kw_only=True)
-    class Options:
-        indent: int | str | None = None
-        separators: tuple[str, str] | None = None
-        sort_keys: bool = False
-        style: ta.Callable[[ta.Any, 'AbstractJsonRenderer.State'], tuple[str, str]] | None = None
-
     def __init__(
             self,
             out: JsonRendererOut,
-            opts: Options = Options(),
+            *,
+            indent: int | str | None = None,
+            separators: tuple[str, str] | None = None,
+            sort_keys: bool = False,
+            style: ta.Callable[[ta.Any, State], tuple[str, str]] | None = None,
     ) -> None:
         super().__init__()
 
         self._out = out
-        self._opts = opts
+        self._sort_keys = sort_keys
+        self._style = style
 
-        separators = opts.separators
-        if isinstance(opts.indent, (str, int)):
-            self._indent = (' ' * opts.indent) if isinstance(opts.indent, int) else opts.indent
+        if isinstance(indent, (str, int)):
+            self._indent = (' ' * indent) if isinstance(indent, int) else indent
             self._endl = '\n'
             if separators is None:
                 separators = (',', ': ')
-        elif opts.indent is None:
+        elif indent is None:
             self._indent = self._endl = ''
             if separators is None:
                 separators = (', ', ': ')
         else:
-            raise TypeError(opts.indent)
+            raise TypeError(indent)
         self._comma, self._colon = separators
 
         self._level = 0
@@ -76,7 +72,7 @@ class AbstractJsonRenderer(lang.Abstract, ta.Generic[I]):
     @classmethod
     def render_str(cls, i: I, **kwargs: ta.Any) -> str:
         out = io.StringIO()
-        cls(out, cls.Options(**kwargs)).render(i)
+        cls(out, **kwargs).render(i)
         return out.getvalue()
 
 
@@ -86,8 +82,8 @@ class JsonRenderer(AbstractJsonRenderer[ta.Any]):
             o: ta.Any,
             state: AbstractJsonRenderer.State = AbstractJsonRenderer.State.VALUE,
     ) -> None:
-        if self._opts.style is not None:
-            pre, post = self._opts.style(o, state)
+        if self._style is not None:
+            pre, post = self._style(o, state)
             self._write(pre)
         else:
             post = None
@@ -102,7 +98,7 @@ class JsonRenderer(AbstractJsonRenderer[ta.Any]):
             self._write('{')
             self._level += 1
             items = list(o.items())
-            if self._opts.sort_keys:
+            if self._sort_keys:
                 items.sort(key=lambda t: t[0])
             for i, (k, v) in enumerate(items):
                 if i:

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

@@ -94,7 +94,7 @@ CONST_TOKENS: ta.Mapping[str, tuple[TokenKind, str | float | None]] = {
 ##
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass()
 class JsonLexError(Exception):
     message: str
 

{omlish-0.0.0.dev86 → omlish-0.0.0.dev88}/omlish/formats/json/stream/render.py

@@ -3,7 +3,6 @@ import typing as ta
 
 from ..render import AbstractJsonRenderer
 from ..render import JsonRendererOut
-from .build import JsonObjectBuilder
 from .parse import BeginArray
 from .parse import BeginObject
 from .parse import EndArray
@@ -19,23 +18,28 @@ class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]
     def __init__(
             self,
             out: JsonRendererOut,
-            opts: AbstractJsonRenderer.Options = AbstractJsonRenderer.Options(),
+            *,
+            delimiter: str = '',
+            sort_keys: bool = False,
+            **kwargs: ta.Any,
     ) -> None:
-        if opts.sort_keys:
+        if sort_keys:
             raise TypeError('Not yet implemented')
 
-        super().__init__(out, opts)
+        self._delimiter = delimiter
+
+        super().__init__(out, **kwargs)
 
         self._stack: list[tuple[ta.Literal['OBJECT', 'ARRAY'], int]] = []
-        self._builder: JsonObjectBuilder | None = None
+        self._need_delimit = False
 
     def _render_value(
             self,
             o: ta.Any,
             state: AbstractJsonRenderer.State = AbstractJsonRenderer.State.VALUE,
     ) -> None:
-        if self._opts.style is not None:
-            pre, post = self._opts.style(o, state)
+        if self._style is not None:
+            pre, post = self._style(o, state)
             self._write(pre)
         else:
             post = None
@@ -53,6 +57,10 @@ class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]
             self._write(post)
 
     def _render(self, e: JsonStreamParserEvent) -> None:
+        if self._need_delimit:
+            self._write(self._delimiter)
+            self._need_delimit = False
+
         if e != EndArray and self._stack and (tt := self._stack[-1])[0] == 'ARRAY':
             if tt[1]:
                 self._write(self._comma)
@@ -64,6 +72,8 @@ class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]
 
         if e is None or isinstance(e, (str, int, float, bool)):
             self._render_value(e)
+            if not self._stack:
+                self._need_delimit = True
 
         #
 
@@ -92,6 +102,8 @@ class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]
             if tt[1]:
                 self._write_indent()
             self._write('}')
+            if not self._stack:
+                self._need_delimit = True
 
         #
 
@@ -108,6 +120,8 @@ class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]
             if tt[1]:
                 self._write_indent()
             self._write(']')
+            if not self._stack:
+                self._need_delimit = True
 
         #
 

{omlish-0.0.0.dev86 → omlish-0.0.0.dev88}/omlish/sql/_abc.py

@@ -1,20 +1,20 @@
 import typing as ta
 
 
-DBAPITypeCode: ta.TypeAlias = ta.Any | None
-
-DBAPIColumnDescription: ta.TypeAlias = tuple[
-    str,
-    DBAPITypeCode,
-    int | None,
-    int | None,
-    int | None,
-    int | None,
-    bool | None,
+DbapiTypeCode: ta.TypeAlias = ta.Any | None
+
+DbapiColumnDescription: ta.TypeAlias = tuple[
+    str,  # name
+    DbapiTypeCode,  # type_code
+    int | None,  # display_size
+    int | None,  # internal_size
+    int | None,  # precision
+    int | None,  # scale
+    bool | None,  # null_ok
 ]
 
 
-class DBAPIConnection(ta.Protocol):
+class DbapiConnection(ta.Protocol):
     def close(self) -> object: ...
 
     def commit(self) -> object: ...
@@ -22,12 +22,12 @@ class DBAPIConnection(ta.Protocol):
     # optional:
     # def rollback(self) -> ta.Any: ...
 
-    def cursor(self) -> 'DBAPICursor': ...
+    def cursor(self) -> 'DbapiCursor': ...
 
 
-class DBAPICursor(ta.Protocol):
+class DbapiCursor(ta.Protocol):
     @property
-    def description(self) -> ta.Sequence[DBAPIColumnDescription] | None: ...
+    def description(self) -> ta.Sequence[DbapiColumnDescription] | None: ...
 
     @property
     def rowcount(self) -> int: ...
@@ -60,6 +60,6 @@ class DBAPICursor(ta.Protocol):
 
     arraysize: int
 
-    def setinputsizes(self, sizes: ta.Sequence[DBAPITypeCode | int | None]) -> object: ...
+    def setinputsizes(self, sizes: ta.Sequence[DbapiTypeCode | int | None]) -> object: ...
 
     def setoutputsize(self, size: int, column: int = ...) -> object: ...

omlish-0.0.0.dev88/omlish/sql/dbapi.py

@@ -0,0 +1,150 @@
+"""
+https://peps.python.org/pep-0249/
+
+==
+
+apilevel = '2.0'
+
+threadsafety:
+ 0 - Threads may not share the module.
+ 1 - Threads may share the module, but not connections.
+ 2 - Threads may share the module and connections.
+ 3 - Threads may share the module, connections and cursors.
+
+paramstyle:
+ qmark - Question mark style, e.g. ...WHERE name=?
+ numeric - Numeric, positional style, e.g. ...WHERE name=:1
+ named - Named style, e.g. ...WHERE name=:name
+ format - ANSI C printf format codes, e.g. ...WHERE name=%s
+ pyformat - Python extended format codes, e.g. ...WHERE name=%(name)s
+
+Exception
+| Warning
+| Error
+ | InterfaceError
+ | DatabaseError
+  | DataError
+  | OperationalError
+  | IntegrityError
+  | InternalError
+  | ProgrammingError
+  | NotSupportedError
+
+Date(year, month, day)
+Time(hour, minute, second)
+Timestamp(year, month, day, hour, minute, second)
+DateFromTicks(ticks)
+TimeFromTicks(ticks)
+TimestampFromTicks(ticks)
+Binary(string)
+
+STRING type
+BINARY type
+NUMBER type
+DATETIME type
+ROWID type
+"""
+import dataclasses as dc
+import enum
+
+from .. import lang
+from .params import ParamStyle
+
+
+class DbapiDialect(enum.Enum):
+    SQLITE = 'sqlite'
+    MYSQL = 'mysql'
+    POSTGRES = 'postgres'
+    SNOWFLAKE = 'snowflake'
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class DbapiDriver:
+    name: str
+    dialect: DbapiDialect
+    param_style: ParamStyle
+
+    package_name: str | None = None
+    module_name: str | None = None
+
+
+class DbapiDrivers(lang.Namespace):
+
+    ##
+    # sqlite
+
+    SQLITE3 = DbapiDriver(
+        name='sqlite3',
+        dialect=DbapiDialect.SQLITE,
+        param_style=ParamStyle.QMARK,
+    )
+
+    SQLEAN = DbapiDriver(
+        name='sqlean',
+        dialect=DbapiDialect.SQLITE,
+        param_style=ParamStyle.QMARK,
+        package_name='sqlean.py',
+    )
+
+    DUCKDB = DbapiDriver(
+        name='duckdb',
+        dialect=DbapiDialect.SQLITE,
+        param_style=ParamStyle.QMARK,
+    )
+
+    ##
+    # mysql
+
+    PYMYSQL = DbapiDriver(
+        name='pymysql',
+        dialect=DbapiDialect.MYSQL,
+        param_style=ParamStyle.PYFORMAT,
+    )
+
+    MYSQL = DbapiDriver(
+        name='mysql',
+        dialect=DbapiDialect.MYSQL,
+        param_style=ParamStyle.PYFORMAT,
+        package_name='mysql-connector-python',
+        module_name='mysql.connector',
+    )
+
+    MYSQLCLIENT = DbapiDriver(
+        name='mysqlclient',
+        dialect=DbapiDialect.MYSQL,
+        param_style=ParamStyle.FORMAT,
+        package_name='mysqlclient',
+        module_name='MySQLdb',
+    )
+
+    ##
+    # postgres
+
+    PG8000 = DbapiDriver(
+        name='pg8000',
+        dialect=DbapiDialect.POSTGRES,
+        param_style=ParamStyle.FORMAT,
+    )
+
+    PSYCOPG2 = DbapiDriver(
+        name='psycopg2',
+        dialect=DbapiDialect.POSTGRES,
+        param_style=ParamStyle.PYFORMAT,
+    )
+
+    PSYCOPG = DbapiDriver(
+        name='psycopg',
+        dialect=DbapiDialect.POSTGRES,
+        param_style=ParamStyle.PYFORMAT,
+    )
+
+    ##
+    # snowflake
+
+    SNOWFLAKE = DbapiDriver(
+        name='snowflake',
+        dialect=DbapiDialect.SNOWFLAKE,
+        param_style=ParamStyle.PYFORMAT,
+        package_name='snowflake-connector-python',
+        module_name='snowflake.connector',
+    )

omlish-0.0.0.dev88/omlish/sql/params.py

@@ -0,0 +1,159 @@
+import abc
+import enum
+import typing as ta
+
+from .. import check
+from .. import lang
+
+
+##
+
+
+ParamKey: ta.TypeAlias = str | int
+
+
+class ParamsPreparer(lang.Abstract):
+    @abc.abstractmethod
+    def add(self, k: ParamKey) -> str:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def prepare(self) -> lang.Args:
+        raise NotImplementedError
+
+
+class LinearParamsPreparer(ParamsPreparer):
+    def __init__(self, placeholder: str) -> None:
+        super().__init__()
+        self._placeholder = placeholder
+        self._args: list[ParamKey] = []
+
+    def add(self, k: ParamKey) -> str:
+        self._args.append(k)
+        return self._placeholder
+
+    def prepare(self) -> lang.Args:
+        return lang.Args(*self._args)
+
+
+class NumericParamsPreparer(ParamsPreparer):
+    def __init__(self) -> None:
+        super().__init__()
+        self._args: list[ParamKey] = []
+        self._str_by_key: dict[ParamKey, str] = {}
+        self._pos_by_name: dict[str, int] = {}
+        self._pos_by_id: dict[int, int] = {}
+
+    def add(self, k: ParamKey) -> str:
+        try:
+            return self._str_by_key[k]
+        except KeyError:
+            pass
+
+        pos = len(self._args)
+        if isinstance(k, str):
+            check.not_in(k, self._pos_by_name)
+            self._pos_by_name[k] = pos
+        elif isinstance(k, int):
+            check.not_in(k, self._pos_by_id)
+            self._pos_by_id[k] = pos
+        else:
+            raise TypeError(f'Invalid key type: {type(k)}')
+
+        self._args.append(k)
+        ret = self._str_by_key[k] = f':{pos + 1}'
+        return ret
+
+    def prepare(self) -> lang.Args:
+        return lang.Args(*self._args)
+
+
+class NamedParamsPreparer(ParamsPreparer):
+    def __init__(
+            self,
+            render: ta.Callable[[str], str],
+            *,
+            anon: ta.Callable[[int], str] | None = None,
+    ) -> None:
+        super().__init__()
+        self._render = render
+        self._anon = anon if anon is not None else self.underscore_anon
+        self._kwargs: dict[str, ParamKey] = {}
+        self._str_by_key: dict[ParamKey, str] = {}
+        self._kwargs_by_name: dict[str, str] = {}
+        self._kwargs_by_id: dict[int, str] = {}
+
+    @staticmethod
+    def render_named(kwarg: str) -> str:
+        return f':{kwarg}'
+
+    @staticmethod
+    def render_pyformat(kwarg: str) -> str:
+        return f'%({kwarg})s'
+
+    @staticmethod
+    def underscore_anon(n: int) -> str:
+        return f'_{n}'
+
+    def add(self, k: ParamKey) -> str:
+        try:
+            return self._str_by_key[k]
+        except KeyError:
+            pass
+
+        kwarg: str
+        if isinstance(k, str):
+            check.not_in(k, self._kwargs_by_name)
+            kwarg = k  # TODO: collisions
+            self._kwargs_by_name[k] = kwarg
+        elif isinstance(k, int):
+            check.not_in(k, self._kwargs_by_id)
+            kwarg = self._anon(len(self._kwargs_by_id))  # TODO: collisions
+            self._kwargs_by_id[k] = kwarg
+        else:
+            raise TypeError(f'Invalid key type: {type(k)}')
+
+        self._kwargs[kwarg] = k
+        ret = self._str_by_key[k] = self._render(kwarg)
+        return ret
+
+    def prepare(self) -> lang.Args:
+        return lang.Args(**self._kwargs)
+
+
+##
+
+
+class ParamStyle(enum.Enum):
+    QMARK = 'qmark'  # Question mark style, e.g. ...WHERE name=?
+    FORMAT = 'format'  # ANSI C printf format codes, e.g. ...WHERE name=%s
+
+    NUMERIC = 'numeric'  # Numeric, positional style, e.g. ...WHERE name=:1
+
+    NAMED = 'named'  # Named style, e.g. ...WHERE name=:name
+    PYFORMAT = 'pyformat'  # Python extended format codes, e.g. ...WHERE name=%(name)s
+
+
+def make_params_preparer(style: ParamStyle) -> ParamsPreparer:
+    if style is ParamStyle.QMARK:
+        return LinearParamsPreparer('?')
+    elif style is ParamStyle.FORMAT:
+        return LinearParamsPreparer('%s')
+    elif style is ParamStyle.NUMERIC:
+        return NumericParamsPreparer()
+    elif style is ParamStyle.NAMED:
+        return NamedParamsPreparer(NamedParamsPreparer.render_named)
+    elif style is ParamStyle.PYFORMAT:
+        return NamedParamsPreparer(NamedParamsPreparer.render_pyformat)
+    else:
+        raise ValueError(style)
+
+
+##
+
+
+def substitute_params(args: lang.Args, values: ta.Mapping[ParamKey, ta.Any]) -> lang.Args:
+    return lang.Args(
+        *[values[a] for a in args.args],
+        **{k: values[v] for k, v in args.kwargs.items()},
+    )

{omlish-0.0.0.dev86 → omlish-0.0.0.dev88}/omlish/sql/queries/inserts.py

@@ -18,11 +18,11 @@ from .stmts import Stmt
 
 
 class Values(dc.Frozen, lang.Final):
-    vs: ta.Sequence[Expr]
+    vs: ta.Sequence[Expr] = dc.xfield(coerce=tuple)
 
 
 class Insert(Stmt, lang.Final):
-    columns: ta.Sequence[Ident]
+    columns: ta.Sequence[Ident] = dc.xfield(coerce=tuple)
     into: Relation
     data: Values | Select
 

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

@@ -1,3 +1,7 @@
+"""
+FIXME:
+ - refuse to marshal anon params
+"""
 import enum
 import typing as ta
 

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

@@ -15,17 +15,21 @@ def needs_parens(self, e: Expr) -> bool:
     else:
         raise TypeError(e)
 """
+import dataclasses as dc
 import io
 import typing as ta
 
 from ... import dispatch
 from ... import lang
+from ..params import ParamStyle
+from ..params import make_params_preparer
 from .base import Node
 from .binary import Binary
 from .binary import BinaryOp
 from .binary import BinaryOps
 from .exprs import Literal
 from .exprs import NameExpr
+from .exprs import Param
 from .idents import Ident
 from .inserts import Insert
 from .inserts import Values
@@ -40,20 +44,40 @@ from .unary import UnaryOp
 from .unary import UnaryOps
 
 
+@dc.dataclass(frozen=True)
+class RenderedQuery(lang.Final):
+    s: str
+    args: lang.Args
+
+
 class Renderer(lang.Abstract):
-    def __init__(self, out: ta.TextIO) -> None:
+    def __init__(
+            self,
+            out: ta.TextIO,
+            *,
+            param_style: ParamStyle | None = None,
+    ) -> None:
         super().__init__()
         self._out = out
+        self._param_style = param_style if param_style is not None else self.default_param_style
+
+        self._params_preparer = make_params_preparer(self._param_style)
+
+    default_param_style: ta.ClassVar[ParamStyle] = ParamStyle.PYFORMAT
+
+    def args(self) -> lang.Args:
+        return self._params_preparer.prepare()
 
     @dispatch.method
-    def render(self, o: ta.Any) -> None:
+    def render(self, o: ta.Any) -> str:
         raise TypeError(o)
 
     @classmethod
-    def render_str(cls, o: ta.Any, *args: ta.Any, **kwargs: ta.Any) -> str:
+    def render_str(cls, o: ta.Any, *args: ta.Any, **kwargs: ta.Any) -> RenderedQuery:
         out = io.StringIO()
-        cls(out, *args, **kwargs).render(o)
-        return out.getvalue()
+        pp = cls(out, *args, **kwargs)
+        pp.render(o)
+        return RenderedQuery(out.getvalue(), pp.args())
 
 
 class StdRenderer(Renderer):
@@ -94,6 +118,10 @@ class StdRenderer(Renderer):
     def render_name_expr(self, o: NameExpr) -> None:
         self.render(o.n)
 
+    @Renderer.render.register
+    def render_param(self, o: Param) -> None:
+        self._out.write(self._params_preparer.add(o.n if o.n is not None else id(o)))
+
     # idents
 
     @Renderer.render.register
@@ -201,5 +229,5 @@ class StdRenderer(Renderer):
         self._out.write(sfx)
 
 
-def render(n: Node) -> str:
-    return StdRenderer.render_str(n)
+def render(n: Node, **kwargs: ta.Any) -> RenderedQuery:
+    return StdRenderer.render_str(n, **kwargs)

{omlish-0.0.0.dev86 → omlish-0.0.0.dev88}/omlish/sql/queries/selects.py

@@ -44,7 +44,7 @@ class SelectBuilder(ExprBuilder, RelationBuilder):
             where: CanExpr | None = None,
     ) -> Select:
         return Select(
-            [self.select_item(i) for i in items],
+            tuple(self.select_item(i) for i in items),
             from_=self.relation(from_) if from_ is not None else None,
             where=self.expr(where) if where is not None else None,
         )