omlish 0.0.0.dev237__py3-none-any.whl → 0.0.0.dev239__py3-none-any.whl

omlish/lite/dataclasses.py

@@ -3,6 +3,18 @@ import dataclasses as dc
 import typing as ta
 
 
+##
+
+
+def is_immediate_dataclass(cls: type) -> bool:
+    if not isinstance(cls, type):
+        raise TypeError(cls)
+    return dc._FIELDS in cls.__dict__  # type: ignore[attr-defined]  # noqa
+
+
+##
+
+
 def dataclass_cache_hash(
         *,
         cached_hash_attr: str = '__dataclass_hash__',
@@ -33,6 +45,9 @@ def dataclass_cache_hash(
     return inner
 
 
+##
+
+
 def dataclass_maybe_post_init(sup: ta.Any) -> bool:
     if not isinstance(sup, super):
         raise TypeError(sup)
@@ -44,6 +59,9 @@ def dataclass_maybe_post_init(sup: ta.Any) -> bool:
     return True
 
 
+##
+
+
 def dataclass_repr_filtered(
         obj: ta.Any,
         fn: ta.Callable[[ta.Any, dc.Field, ta.Any], bool],

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/manifests/__init__.py

@@ -1,2 +0,0 @@
-# @omlish-lite
-from .types import Manifest  # noqa

omlish/manifests/base.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 import dataclasses as dc
 import typing as ta
 

omlish/manifests/load.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 """
 Should be kept somewhat lightweight - used in cli entrypoints.
 

omlish/manifests/static.py

@@ -0,0 +1,20 @@
+import abc
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+from .base import ModAttrManifest
+
+
+##
+
+
+class StaticModAttrManifest(dc.Static, ModAttrManifest, abc.ABC):
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        if (
+                not (lang.is_abstract_class(cls) or abc.ABC in cls.__bases__) and
+                'mod_name' not in cls.__dict__
+        ):
+            setattr(cls, 'mod_name', cls.__module__)
+
+        super().__init_subclass__(**kwargs)

omlish/manifests/types.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 import dataclasses as dc
 import typing as ta
 
@@ -6,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/metadata.py

@@ -0,0 +1,153 @@
+"""
+These attempt to punch through *all* wrappers. The the usecases involve having things like bound methods, classmethods,
+functools.partial instances, and needing to get the metadata of the underlying thing the end-user wrote.
+
+TODO:
+ - re type targets:
+  - unwrap instances of objects to their types?
+  - merge mro?
+  - are these better left up to callers? too usecase-specific to favor either way?
+"""
+import types
+import typing as ta
+
+from . import check
+from . import lang
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class ObjectMetadata(lang.Abstract):
+    pass
+
+
+class ObjectMetadataTarget(lang.Abstract):
+    pass
+
+
+##
+
+
+_VALID_OBJECT_METADATA_TARGET_TYPES: tuple[type, ...] = (
+    type,
+
+    types.FunctionType,
+    # *not* types.MethodType - must unwrap to unbound class func
+    # *not* functools.partial - must unwrap to underlying func
+
+    ObjectMetadataTarget,
+)
+
+
+class ObjectMetadataTargetTypeError(TypeError):
+    pass
+
+
+def _unwrap_object_metadata_target(obj: ta.Any) -> ta.Any:
+    tgt: ta.Any = obj
+    tgt = lang.unwrap_func(tgt)
+
+    if not isinstance(tgt, _VALID_OBJECT_METADATA_TARGET_TYPES):
+        raise ObjectMetadataTargetTypeError(tgt)
+
+    return tgt
+
+
+##
+
+
+_OBJECT_METADATA_ATTR = '__' + __name__.replace('.', '_') + '__metadata__'
+
+
+def append_object_metadata(obj: T, *mds: ObjectMetadata) -> T:
+    for md in mds:
+        check.isinstance(md, ObjectMetadata)
+
+    tgt = _unwrap_object_metadata_target(obj)
+    dct = tgt.__dict__
+
+    if isinstance(dct, types.MappingProxyType):
+        for _ in range(2):
+            try:
+                lst = dct[_OBJECT_METADATA_ATTR]
+            except KeyError:
+                setattr(tgt, _OBJECT_METADATA_ATTR, [])
+            else:
+                break
+        else:
+            raise RuntimeError
+
+    else:
+        lst = dct.setdefault(_OBJECT_METADATA_ATTR, [])
+
+    lst.extend(mds)
+    return obj
+
+
+def get_object_metadata(obj: ta.Any, *, strict: bool = False) -> ta.Sequence[ObjectMetadata]:
+    try:
+        tgt = _unwrap_object_metadata_target(obj)
+    except ObjectMetadataTargetTypeError:
+        if not strict:
+            return ()
+        raise
+
+    try:
+        dct = tgt.__dict__
+    except AttributeError:
+        return ()
+
+    return dct.get(_OBJECT_METADATA_ATTR, ())
+
+
+##
+
+
+class DecoratorObjectMetadata(ObjectMetadata, lang.Abstract):
+    _OBJECT_METADATA_TARGET_TYPES: ta.ClassVar[tuple[type, ...] | None] = None
+
+    def __init_subclass__(
+            cls,
+            *,
+            object_metadata_target_types: ta.Iterable[type] | None = None,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if object_metadata_target_types is not None:
+            tts = tuple(object_metadata_target_types)
+            for tt in tts:
+                check.issubclass(tt, _VALID_OBJECT_METADATA_TARGET_TYPES)
+            setattr(cls, '_OBJECT_METADATA_TARGET_TYPES', tts)
+
+    def __call__(self, obj: T) -> T:
+        tgt: ta.Any = obj
+        if (tts := type(self)._OBJECT_METADATA_TARGET_TYPES) is not None:  # noqa
+            tgt = _unwrap_object_metadata_target(tgt)
+            check.isinstance(tgt, tts)
+
+        append_object_metadata(tgt, self)
+        return obj
+
+
+#
+
+
+class ClassDecoratorObjectMetadata(
+    DecoratorObjectMetadata,
+    lang.Abstract,
+    object_metadata_target_types=[type],
+):
+    pass
+
+
+class FunctionDecoratorObjectMetadata(
+    DecoratorObjectMetadata,
+    lang.Abstract,
+    object_metadata_target_types=[types.FunctionType],
+):
+    pass

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/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/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/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/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/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