omlish 0.0.0.dev238__tar.gz → 0.0.0.dev239__tar.gz

{omlish-0.0.0.dev238/omlish.egg-info → omlish-0.0.0.dev239}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev238
+Version: 0.0.0.dev239
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev238 → omlish-0.0.0.dev239}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev238'
-__revision__ = '0ab60b1d75e5b0b298707ba55797958e528c69b5'
+__version__ = '0.0.0.dev239'
+__revision__ = 'f241f36977bf74d1ea680d415782228917ec3669'
 
 
 #

{omlish-0.0.0.dev238 → omlish-0.0.0.dev239}/omlish/dataclasses/static.py

@@ -1,3 +1,8 @@
+"""
+TODO:
+ - metaclass, to forbid __subclasscheck__ / __instancecheck__? Clash with dc.Meta, don't want that lock-in, not
+   necessary for functionality, just a helpful misuse prevention.
+"""
 import abc
 import copy
 import dataclasses as dc
@@ -12,6 +17,14 @@ from .impl.api import dataclass
 
 
 class Static(lang.Abstract):
+    """
+    Dataclass mixin for dataclasses in which all fields have class-level defaults and are not intended for any
+    instance-level overrides - effectively making their subclasses equivalent to instances. For dataclasses which make
+    sense as singletons (such as project specs or manifests), for which dynamic instantiation is not the usecase, this
+    can enable more natural syntax. Inheritance is permitted - equivalent to a `functools.partial` or composing
+    `**kwargs`, as long as there is only ever one unambiguous underlying non-static dataclass to be instantiated.
+    """
+
     __static_dataclass_class__: ta.ClassVar[type]
     __static_dataclass_instance__: ta.ClassVar[ta.Any]
 
@@ -23,7 +36,7 @@ class Static(lang.Abstract):
                 raise TypeError(f'Static base class {cls} must not implement {a}')
 
         if cls.__init__ is not Static.__init__:
-            # This is necessary to make type-checking work (by allowing it to accept zero). This isn't strictly
+            # This is necessary to make type-checking work (by allowing it to accept zero args). This isn't strictly
             # necessary, but since it's useful to do sometimes it might as well be done everywhere to prevent clashing.
             raise TypeError(f'Static.__init__ should be first in mro of {cls}')
 
@@ -144,8 +157,8 @@ class Static(lang.Abstract):
                 )
 
         if not is_abstract:
-            # This is the only time the Statices are ever actually instantiated, and it's only to produce the
-            # kwargs passed to the underlying dataclass.
+            # This is the only time the Statics are ever actually instantiated, and it's only to produce the kwargs
+            # passed to the underlying dataclass.
             tmp_inst = cls()
             inst_kw = dc.asdict(tmp_inst)  # type: ignore[call-overload]  # noqa
             inst = sdc_cls(**inst_kw)

{omlish-0.0.0.dev238 → omlish-0.0.0.dev239}/omlish/lang/__init__.py

@@ -137,9 +137,6 @@ from .imports import (  # noqa
     can_import,
     get_real_module_name,
     import_all,
-    import_attr,
-    import_module,
-    import_module_attr,
     lazy_import,
     proxy_import,
     proxy_init,
@@ -235,6 +232,12 @@ from .typing import (  # noqa
 
 ##
 
+from ..lite.imports import (  # noqa
+    import_attr,
+    import_module,
+    import_module_attr,
+)
+
 from ..lite.timeouts import (  # noqa
     DeadlineTimeout,
     InfiniteTimeout,

{omlish-0.0.0.dev238 → omlish-0.0.0.dev239}/omlish/lang/imports.py

@@ -87,49 +87,6 @@ def proxy_import(
 ##
 
 
-def import_module(dotted_path: str) -> types.ModuleType:
-    if not dotted_path:
-        raise ImportError(dotted_path)
-    mod = __import__(dotted_path, globals(), locals(), [])
-    for name in dotted_path.split('.')[1:]:
-        try:
-            mod = getattr(mod, name)
-        except AttributeError:
-            raise AttributeError(f'Module {mod!r} has no attribute {name!r}') from None
-    return mod
-
-
-def import_module_attr(dotted_path: str) -> ta.Any:
-    module_name, _, class_name = dotted_path.rpartition('.')
-    mod = import_module(module_name)
-    try:
-        return getattr(mod, class_name)
-    except AttributeError:
-        raise AttributeError(f'Module {module_name!r} has no attr {class_name!r}') from None
-
-
-def import_attr(dotted_path: str) -> ta.Any:
-    parts = dotted_path.split('.')
-    mod: ta.Any = None
-    mod_pos = 0
-    while mod_pos < len(parts):
-        mod_name = '.'.join(parts[:mod_pos + 1])
-        try:
-            mod = importlib.import_module(mod_name)
-        except ImportError:
-            break
-        mod_pos += 1
-    if mod is None:
-        raise ImportError(dotted_path)
-    obj = mod
-    for att_pos in range(mod_pos, len(parts)):
-        obj = getattr(obj, parts[att_pos])
-    return obj
-
-
-##
-
-
 SPECIAL_IMPORTABLE: ta.AbstractSet[str] = frozenset([
     '__init__.py',
     '__main__.py',

omlish-0.0.0.dev239/omlish/lite/imports.py

@@ -0,0 +1,47 @@
+# ruff: noqa: UP006 UP007
+import types
+import typing as ta
+
+
+##
+
+
+def import_module(dotted_path: str) -> types.ModuleType:
+    if not dotted_path:
+        raise ImportError(dotted_path)
+    mod = __import__(dotted_path, globals(), locals(), [])
+    for name in dotted_path.split('.')[1:]:
+        try:
+            mod = getattr(mod, name)
+        except AttributeError:
+            raise AttributeError(f'Module {mod!r} has no attribute {name!r}') from None
+    return mod
+
+
+def import_module_attr(dotted_path: str) -> ta.Any:
+    module_name, _, class_name = dotted_path.rpartition('.')
+    mod = import_module(module_name)
+    try:
+        return getattr(mod, class_name)
+    except AttributeError:
+        raise AttributeError(f'Module {module_name!r} has no attr {class_name!r}') from None
+
+
+def import_attr(dotted_path: str) -> ta.Any:
+    importlib = __import__('importlib')
+    parts = dotted_path.split('.')
+    mod: ta.Any = None
+    mod_pos = 0
+    while mod_pos < len(parts):
+        mod_name = '.'.join(parts[:mod_pos + 1])
+        try:
+            mod = importlib.import_module(mod_name)
+        except ImportError:
+            break
+        mod_pos += 1
+    if mod is None:
+        raise ImportError(dotted_path)
+    obj = mod
+    for att_pos in range(mod_pos, len(parts)):
+        obj = getattr(obj, parts[att_pos])
+    return obj

{omlish-0.0.0.dev238 → omlish-0.0.0.dev239}/omlish/manifests/types.py

@@ -7,7 +7,7 @@ import typing as ta
 @dc.dataclass(frozen=True)
 class ManifestOrigin:
     module: str
-    attr: str
+    attr: ta.Optional[str]  # None if inline
 
     file: str
     line: int

{omlish-0.0.0.dev238 → omlish-0.0.0.dev239}/omlish/sql/abc.py

@@ -26,6 +26,13 @@ class DbapiColumnDescription_(ta.NamedTuple):  # noqa
     scale: int | None
     null_ok: bool | None
 
+    @classmethod
+    def of(cls, obj: ta.Any) -> 'DbapiColumnDescription_':
+        if isinstance(obj, cls):
+            return obj
+        else:
+            return cls(*obj[:len(cls._fields)])
+
 
 class DbapiConnection(ta.Protocol):
     def close(self) -> object: ...

omlish-0.0.0.dev239/omlish/sql/api/base.py

@@ -0,0 +1,89 @@
+"""
+TODO:
+ - sync vs async
+"""
+import abc
+import typing as ta
+
+from ... import lang
+from .columns import Column
+from .columns import Columns
+from .queries import Query
+from .rows import Row
+
+
+##
+
+
+class Closer(lang.Abstract):
+    def close(self) -> None:
+        pass
+
+
+class SelfCloser(Closer):
+    def __enter__(self) -> ta.Self:
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+##
+
+
+class Querier(SelfCloser, lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def adapter(self) -> 'Adapter':
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def query(self, query: Query) -> 'Rows':  # ta.Raises[QueryError]
+        raise NotImplementedError
+
+
+##
+
+
+class Rows(SelfCloser, lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def columns(self) -> Columns:
+        raise NotImplementedError
+
+    @ta.final
+    def __iter__(self) -> ta.Self:
+        return self
+
+    @abc.abstractmethod
+    def __next__(self) -> Row:  # ta.Raises[StopIteration]
+        raise NotImplementedError
+
+
+##
+
+
+class Conn(Querier, lang.Abstract):  # noqa
+    pass
+
+
+##
+
+
+class Db(Querier, lang.Abstract):  # noqa
+    @abc.abstractmethod
+    def connect(self) -> Conn:
+        raise NotImplementedError
+
+    def query(self, query: Query) -> Rows:
+        with self.connect() as conn:
+            return conn.query(query)
+
+
+##
+
+
+class Adapter(lang.Abstract):
+    @abc.abstractmethod
+    def scan_type(self, c: Column) -> type:
+        raise NotImplementedError

omlish-0.0.0.dev239/omlish/sql/api/columns.py

@@ -0,0 +1,90 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import lang
+from .errors import DuplicateColumnNameError
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Column(lang.Final):
+    name: str
+
+    _: dc.KW_ONLY
+
+    db_type: str | None = None
+    type: type = object
+
+
+##
+
+
+class Columns(lang.Final):
+    def __init__(self, *cs: Column) -> None:
+        super().__init__()
+
+        self._seq = cs
+
+        by_name: dict[str, Column] = {}
+        idxs_by_name: dict[str, int] = {}
+        for i, c in enumerate(cs):
+            if c.name in by_name:
+                raise DuplicateColumnNameError(c.name)
+            by_name[c.name] = c
+            idxs_by_name[c.name] = i
+
+        self._by_name = by_name
+        self._idxs_by_name = idxs_by_name
+
+    #
+
+    _EMPTY: ta.ClassVar['Columns']
+
+    @classmethod
+    def empty(cls) -> 'Columns':
+        return cls._EMPTY
+
+    #
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}<{", ".join(repr(c.name) for c in self._seq)}>'
+
+    #
+
+    def __iter__(self) -> ta.Iterator[Column]:
+        return iter(self._seq)
+
+    def __len__(self) -> int:
+        return len(self._seq)
+
+    def __contains__(self, item: str | int) -> bool:
+        if isinstance(item, str):
+            return item in self._by_name
+        elif isinstance(item, int):
+            return 0 <= item < len(self._by_name)
+        else:
+            raise TypeError(item)
+
+    def __getitem__(self, item) -> Column:
+        if isinstance(item, str):
+            return self._by_name[item]
+        elif isinstance(item, int):
+            return self._seq[item]
+        else:
+            raise TypeError(item)
+
+    def get(self, name: str) -> Column | None:
+        return self._by_name.get(name)
+
+    #
+
+    def index(self, name: str) -> int:
+        return self._idxs_by_name[name]
+
+    def get_index(self, name: str) -> int | None:
+        return self._idxs_by_name.get(name)
+
+
+Columns._EMPTY = Columns()  # noqa

omlish-0.0.0.dev239/omlish/sql/api/dbapi.py

@@ -0,0 +1,105 @@
+import typing as ta
+
+from ... import check
+from .. import abc as dbapi_abc
+from .base import Adapter
+from .base import Conn
+from .base import Db
+from .base import Rows
+from .columns import Column
+from .columns import Columns
+from .queries import Query
+from .rows import Row
+
+
+##
+
+
+def build_dbapi_columns(desc: ta.Sequence[dbapi_abc.DbapiColumnDescription] | None) -> Columns:
+    if desc is None:
+        return Columns.empty()
+
+    cols: list[Column] = []
+    for desc_col in desc:
+        dbapi_col = dbapi_abc.DbapiColumnDescription_.of(desc_col)
+
+        cols.append(Column(
+            check.non_empty_str(dbapi_col.name),
+        ))
+
+    return Columns(*cols)
+
+
+class DbapiRows(Rows):
+    def __init__(
+            self,
+            cursor: dbapi_abc.DbapiCursor,
+            columns: Columns,
+    ) -> None:
+        super().__init__()
+
+        self._cursor = cursor
+        self._columns = columns
+
+    @property
+    def columns(self) -> Columns:
+        return self._columns
+
+    def __next__(self) -> Row:
+        values = self._cursor.fetchone()
+        if values is None:
+            raise StopIteration
+        return Row(self._columns, values)
+
+
+class DbapiConn(Conn):
+    def __init__(self, conn: dbapi_abc.DbapiConnection) -> None:
+        super().__init__()
+
+        self._conn = conn
+
+    @property
+    def adapter(self) -> Adapter:
+        raise NotImplementedError
+
+    def query(self, query: Query) -> Rows:
+        cursor = self._conn.cursor()
+        try:
+            cursor.execute(query.text)
+            columns = build_dbapi_columns(cursor.description)
+            return DbapiRows(cursor, columns)
+
+        except Exception:  # noqa
+            cursor.close()
+            raise
+
+    def close(self) -> None:
+        self._conn.close()
+
+
+class DbapiDb(Db):
+    def __init__(
+            self,
+            conn_fac: ta.Callable[[], dbapi_abc.DbapiConnection],
+            *,
+            adapter: ta.Optional['DbapiAdapter'] = None,
+    ) -> None:
+        super().__init__()
+
+        self._conn_fac = conn_fac
+        if adapter is None:
+            adapter = DbapiAdapter()
+        self._adapter = adapter
+
+    def connect(self) -> Conn:
+        dbapi_conn = self._conn_fac()
+        return DbapiConn(dbapi_conn)
+
+    @property
+    def adapter(self) -> Adapter:
+        return self._adapter
+
+
+class DbapiAdapter(Adapter):
+    def scan_type(self, c: Column) -> type:
+        raise NotImplementedError

omlish-0.0.0.dev239/omlish/sql/api/errors.py

@@ -0,0 +1,24 @@
+class Error(Exception):
+    pass
+
+
+##
+
+
+class ColumnError(Error):
+    pass
+
+
+class DuplicateColumnNameError(ColumnError):
+    pass
+
+
+class MismatchedColumnCountError(ColumnError):
+    pass
+
+
+##
+
+
+class QueryError(Error):
+    pass

omlish-0.0.0.dev239/omlish/sql/api/funcs.py

@@ -0,0 +1,73 @@
+import typing as ta
+
+from .base import Querier
+from .base import Rows
+from .queries import Query
+from .queries import QueryMode
+
+
+##
+
+
+@ta.overload
+def query(
+        querier: Querier,
+        query: Query,  # noqa
+) -> Rows:
+    ...
+
+
+@ta.overload
+def query(
+        querier: Querier,
+        text: str,
+        *args: ta.Any,
+) -> Rows:
+    ...
+
+
+def query(
+        querier,
+        obj,
+        *args,
+):
+    if isinstance(obj, Query):
+        q = obj
+    else:
+        q = Query.of(obj, *args, mode=QueryMode.QUERY)
+
+    return querier.query(q)
+
+
+##
+
+
+@ta.overload
+def exec(  # noqa
+        querier: Querier,
+        query: Query,  # noqa
+) -> None:
+    ...
+
+
+@ta.overload
+def exec(  # noqa
+        querier: Querier,
+        text: str,
+        *args: ta.Any,
+) -> None:
+    ...
+
+
+def exec(  # noqa
+    querier,
+    obj,
+    *args,
+):
+    if isinstance(obj, Query):
+        q = obj
+    else:
+        q = Query.of(obj, *args, mode=QueryMode.EXEC)
+
+    with querier.query(q):
+        pass

omlish-0.0.0.dev239/omlish/sql/api/queries.py

@@ -0,0 +1,63 @@
+import dataclasses as dc
+import enum
+import typing as ta
+
+from ... import check
+from ... import lang
+
+
+##
+
+
+class QueryMode(enum.Enum):
+    QUERY = enum.auto()
+    EXEC = enum.auto()
+
+
+@dc.dataclass(frozen=True)
+class Query(lang.Final):
+    mode: QueryMode
+    text: str
+    args: ta.Sequence[ta.Any]
+
+    #
+
+    @classmethod
+    @ta.overload
+    def of(
+            cls,
+            query: 'Query',
+    ) -> 'Query':
+        ...
+
+    @classmethod
+    @ta.overload
+    def of(
+            cls,
+            text: str,
+            *args: ta.Any,
+            mode: str | QueryMode = QueryMode.QUERY,
+    ) -> 'Query':
+        ...
+
+    @classmethod  # type: ignore[misc]
+    def of(cls, obj, *args, **kwargs):
+        if isinstance(obj, Query):
+            check.arg(not args)
+            check.arg(not kwargs)
+            return obj
+
+        elif isinstance(obj, str):
+            mode = kwargs.pop('mode', QueryMode.QUERY)
+            if isinstance(mode, str):
+                mode = QueryMode[mode.upper()]
+            check.arg(not kwargs)
+
+            return cls(
+                mode=mode,
+                text=obj,
+                args=args,
+            )
+
+        else:
+            raise TypeError(obj)

omlish-0.0.0.dev239/omlish/sql/api/rows.py

@@ -0,0 +1,48 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import lang
+from .columns import Column
+from .columns import Columns
+from .errors import MismatchedColumnCountError
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Row(lang.Final, ta.Generic[T]):
+    columns: Columns
+    values: ta.Sequence[T]
+
+    def __post_init__(self) -> None:
+        if len(self.columns) != len(self.values):
+            raise MismatchedColumnCountError(self.columns, self.values)
+
+    #
+
+    def __iter__(self) -> ta.Iterator[tuple[Column, T]]:
+        return iter(zip(self.columns, self.values))
+
+    def __len__(self) -> int:
+        return len(self.values)
+
+    def __contains__(self, item: str | int) -> bool:
+        raise TypeError('Row.__contains__ is ambiguous - use .columns.__contains__ or .values.__contains__')
+
+    def __getitem__(self, item) -> T:
+        if isinstance(item, str):
+            return self.values[self.columns.index(item)]
+        elif isinstance(item, int):
+            return self.values[item]
+        else:
+            raise TypeError(item)
+
+    def get(self, name: str) -> T | None:
+        if (idx := self.columns.get_index(name)) is not None:
+            return self.values[idx]
+        else:
+            return None