omlish 0.0.0.dev5__py3-none-any.whl → 0.0.0.dev6__py3-none-any.whl

omlish/serde/yaml.py

@@ -0,0 +1,223 @@
+"""
+TODO:
+ - !! shared 'object format' node hierarchy
+  - fuse yaml and hocon - marks, *COMMENTS*, etc
+ - goal: perfect rewrites (comments, whitespace)
+  - or at least comments
+ - rename 'objects'? codecs/serde interplay still unresolved
+"""
+import datetime
+import types
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    import yaml
+    import yaml.nodes as yaml_nodes
+else:
+    yaml = lang.proxy_import('yaml')
+    yaml_nodes = lang.proxy_import('yaml.nodes')
+
+
+T = ta.TypeVar('T')
+
+
+@dc.dataclass(frozen=True)
+class NodeWrapped(lang.Final, ta.Generic[T]):
+    value: T
+    node: 'yaml_nodes.Node'
+
+    def __post_init__(self) -> None:
+        if isinstance(self.value, NodeWrapped):
+            raise TypeError(self.value)
+        if not isinstance(self.node, yaml_nodes.Node):
+            raise TypeError(self.node)
+
+
+class NodeUnwrapper:
+
+    seq_types: tuple[type, ...] = (
+        list,
+        set,
+        tuple,
+    )
+
+    def unwrap_seq(self, nw: NodeWrapped[T]) -> T:
+        return nw.value.__class__(map(self.unwrap, nw.value))  # type: ignore
+
+    map_types: tuple[type, ...] = (
+        dict,
+    )
+
+    def unwrap_map(self, nw: NodeWrapped[T]) -> T:
+        return nw.value.__class__({self.unwrap(k): self.unwrap(v) for k, v in nw.value.items()})  # type: ignore
+
+    scalar_types: tuple[type, ...] = (
+        bool,
+        bytes,
+        datetime.datetime,
+        float,
+        int,
+        str,
+        type(None),
+    )
+
+    def unwrap_scalar(self, nw: NodeWrapped[T]) -> T:
+        return nw.value
+
+    def unwrap_unknown(self, nw: NodeWrapped[T]) -> T:
+        raise TypeError(nw.value)
+
+    def unwrap(self, nw: NodeWrapped[T]) -> T:
+        check.isinstance(nw, NodeWrapped)
+        if isinstance(nw.value, self.seq_types):
+            return self.unwrap_seq(nw)
+        elif isinstance(nw.value, self.map_types):
+            return self.unwrap_map(nw)
+        elif isinstance(nw.value, self.scalar_types):
+            return self.unwrap_scalar(nw)
+        else:
+            return self.unwrap_unknown(nw)
+
+
+def unwrap(nw: NodeWrapped[T]) -> T:
+    return NodeUnwrapper().unwrap(nw)
+
+
+class NodeWrappingConstructorMixin:
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        ctors = {
+            fn.__name__: fn for fn in [
+                self.__class__.construct_yaml_omap,
+                self.__class__.construct_yaml_pairs,
+            ]
+        }
+        self.yaml_constructors = {
+            tag: ctors.get(ctor.__name__, ctor)
+            for tag, ctor in self.yaml_constructors.items()  # type: ignore  # noqa
+        }
+
+    def construct_object(self, node, deep=False):
+        value = super().construct_object(node, deep=deep)  # type: ignore
+        return NodeWrapped(value, node)
+
+    def __construct_yaml_pairs(self, node, fn):
+        omap = []  # type: ignore
+        gen = check.isinstance(fn(node), types.GeneratorType)
+        yield omap
+        uomap = next(gen)
+        lang.exhaust(gen)
+        for key, value in uomap:  # type: ignore
+            omap.append(NodeWrapped((key, value), node))
+
+    def construct_yaml_omap(self, node):
+        return self.__construct_yaml_pairs(node, super().construct_yaml_omap)  # type: ignore  # noqa
+
+    def construct_yaml_pairs(self, node):
+        return self.__construct_yaml_pairs(node, super().construct_yaml_pairs)  # type: ignore  # noqa
+
+
+class _cached_class_property:  # noqa
+    def __init__(self, fn):
+        super().__init__()
+        self._fn = fn
+        self._attr = None
+
+    def __call__(self, *args, **kwargs):
+        raise TypeError
+
+    def __set_name__(self, owner, name):
+        self._attr = '_' + name
+
+    def __get__(self, instance, owner):
+        if owner is None:
+            if instance is None:
+                raise RuntimeError
+            owner = instance.__class__
+        try:
+            return owner.__dict__[self._attr]
+        except KeyError:
+            ret = self._fn(owner)
+            setattr(owner, self._attr, ret)  # type: ignore
+            return ret
+
+
+class WrappedLoaders(lang.Namespace):
+
+    @staticmethod
+    def _wrap(cls):
+        return type('NodeWrapping$' + cls.__name__, (NodeWrappingConstructorMixin, cls), {})
+
+    Base: type['yaml.BaseLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.BaseLoader))  # type: ignore
+
+    @classmethod
+    def base(cls, *args, **kwargs) -> 'yaml.BaseLoader':
+        return cls.Base(*args, **kwargs)
+
+    Full: type['yaml.FullLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.FullLoader))  # type: ignore
+
+    @classmethod
+    def full(cls, *args, **kwargs) -> 'yaml.FullLoader':
+        return cls.Full(*args, **kwargs)
+
+    Safe: type['yaml.SafeLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.SafeLoader))  # type: ignore
+
+    @classmethod
+    def safe(cls, *args, **kwargs) -> 'yaml.SafeLoader':
+        return cls.Safe(*args, **kwargs)
+
+    Unsafe: type['yaml.UnsafeLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.UnsafeLoader))  # type: ignore
+
+    @classmethod
+    def unsafe(cls, *args, **kwargs) -> 'yaml.UnsafeLoader':
+        return cls.Unsafe(*args, **kwargs)
+
+    CBase: type['yaml.CBaseLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.CBaseLoader))  # type: ignore
+
+    @classmethod
+    def cbase(cls, *args, **kwargs) -> 'yaml.CBaseLoader':
+        return cls.CBase(*args, **kwargs)
+
+    CFull: type['yaml.CFullLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.CFullLoader))  # type: ignore
+
+    @classmethod
+    def cfull(cls, *args, **kwargs) -> 'yaml.CFullLoader':
+        return cls.CFull(*args, **kwargs)
+
+    CSafe: type['yaml.CSafeLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.CSafeLoader))  # type: ignore
+
+    @classmethod
+    def csafe(cls, *args, **kwargs) -> 'yaml.CSafeLoader':
+        return cls.CSafe(*args, **kwargs)
+
+    CUnsafe: type['yaml.CUnsafeLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.CUnsafeLoader))  # type: ignore  # noqa
+
+    @classmethod
+    def cunsafe(cls, *args, **kwargs) -> 'yaml.CUnsafeLoader':
+        return cls.CUnsafe(*args, **kwargs)
+
+
+def load(stream, Loader):  # noqa
+    with lang.disposing(Loader(stream)) as loader:
+        return loader.get_single_data()
+
+
+def load_all(stream, Loader):  # noqa
+    with lang.disposing(Loader(stream)) as loader:
+        while loader.check_data():
+            yield loader.get_data()
+
+
+def full_load(stream):  # noqa
+    return load(stream, yaml.FullLoader)
+
+
+def full_load_all(stream):  # noqa  # noqa
+    return load_all(stream, yaml.FullLoader)

omlish/sql/dbs.py

@@ -16,7 +16,7 @@ class DbType:
     default_port: int | None = None
 
 
-class DbTypes(lang.Namespace):
+class DbTypes(lang.Namespace, lang.Final):
     MYSQL = DbType(
         name='mysql',
         dialect_name='mysql',

omlish/sql/duckdb.py

@@ -0,0 +1,136 @@
+"""
+See:
+ - https://duckdb.org/docs/api/python/overview.html
+ - https://github.com/Mause/duckdb_engine/blob/0e3ea0107f81c66d50b444011d31fce22a9b902c/duckdb_engine/__init__.py
+"""
+import typing as ta
+
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql as sap
+
+from .. import lang
+
+
+if ta.TYPE_CHECKING:
+    import duckdb
+else:
+    duckdb = lang.proxy_import('duckdb')
+
+
+class ConnectionWrapper:
+    def __init__(self, c: 'duckdb.DuckDBPyConnection') -> None:
+        super().__init__()
+        self.__c = c
+        self.autocommit = None
+        self.closed = False
+
+    def cursor(self) -> 'CursorWrapper':
+        return CursorWrapper(self.__c, self)
+
+    def __getattr__(self, name: str) -> ta.Any:
+        return getattr(self.__c, name)
+
+    def close(self) -> None:
+        self.__c.close()
+        self.closed = True
+
+
+def _is_transaction_context_message(e: Exception) -> bool:
+    return e.args[0] == 'TransactionContext Error: cannot rollback - no transaction is active'
+
+
+class CursorWrapper:
+    def __init__(
+            self,
+            c: 'duckdb.DuckDBPyConnection',
+            connection_wrapper: 'ConnectionWrapper',
+    ) -> None:
+        super().__init__()
+        self.__c = c
+        self.__connection_wrapper = connection_wrapper
+
+    def executemany(
+        self,
+        statement: str,
+        parameters: ta.Sequence[ta.Mapping[str, ta.Any]] | None = None,
+        context: ta.Any | None = None,
+    ) -> None:
+        self.__c.executemany(statement, list(parameters) if parameters else [])
+
+    def execute(
+        self,
+        statement: str,
+        parameters: ta.Sequence[ta.Any] | None = None,
+        context: ta.Any | None = None,
+    ) -> None:
+        try:
+            if statement.lower() == 'commit':  # this is largely for ipython-sql
+                self.__c.commit()
+            elif parameters is None:
+                self.__c.execute(statement)
+            else:
+                self.__c.execute(statement, parameters)
+        except RuntimeError as e:
+            if e.args[0].startswith('Not implemented Error'):
+                raise NotImplementedError(*e.args) from e
+            elif _is_transaction_context_message(e):
+                return
+            else:
+                raise
+
+    @property
+    def connection(self):
+        return self.__connection_wrapper
+
+    def close(self) -> None:
+        pass
+
+    def __getattr__(self, name: str) -> ta.Any:
+        return getattr(self.__c, name)
+
+    def fetchmany(self, size: int | None = None) -> list:
+        if size is None:
+            return self.__c.fetchmany()
+        else:
+            return self.__c.fetchmany(size)
+
+
+class DuckdbDialect(sap.base.PGDialect):
+    name = 'postgres__duckdb'
+    driver = 'duckdb_engine'
+
+    supports_statement_cache = False
+
+    @classmethod
+    def import_dbapi(cls):
+        return duckdb
+
+    def connect(self, *cargs, **cparams):
+        conn = self.loaded_dbapi.connect(*cargs, **cparams)
+
+        return ConnectionWrapper(conn)
+
+    def do_rollback(self, connection) -> None:
+        try:
+            super().do_rollback(connection)
+        except duckdb.TransactionException as e:
+            if _is_transaction_context_message(e):
+                return
+            else:
+                raise
+
+    def do_begin(self, connection) -> None:
+        connection.begin()
+
+    def get_default_isolation_level(self, connection) -> ta.Any:
+        raise NotImplementedError
+
+    def _get_server_version_info(self, connection) -> tuple[int, int]:
+        connection.execute(sa.text('select version()')).fetchone()
+        return (8, 0)
+
+    def _set_backslash_escapes(self, connection):
+        pass
+
+
+sa.dialects.registry.register(DuckdbDialect.name, __name__, DuckdbDialect.__name__)

omlish/sql/sqlean.py

@@ -0,0 +1,17 @@
+import sqlalchemy as sa
+from sqlalchemy.dialects import sqlite as sal
+
+
+class SqleanDialect(sal.dialect):  # type: ignore
+    name = 'sqlite__sqlean'
+    driver = 'sqlean_engine'
+
+    supports_statement_cache = True
+
+    @classmethod
+    def import_dbapi(cls):
+        from sqlean import dbapi2
+        return dbapi2
+
+
+sa.dialects.registry.register(SqleanDialect.name, __name__, SqleanDialect.__name__)

omlish/term.py

@@ -90,7 +90,7 @@ HIDE_CURSOR = ControlSequence(lambda: CSI + '?25l', 'Hide Cursor')
 SGR = ControlSequence(lambda n: CSI + _str_val(n) + 'm', 'Select Graphic Rendition')
 
 
-class SGRs(lang.Namespace):
+class SGRs(lang.Namespace, lang.Final):
     RESET = 0
     NORMAL_COLOR_AND_INTENSITY = 22
 

omlish/testing/pytest/__init__.py

@@ -1,5 +1,3 @@
-from . import plugins  # noqa
-
 from .helpers import (  # noqa
     assert_raises_star,
 )
@@ -11,3 +9,6 @@ from .marks import (  # noqa
     skip_if_not_on_path,
     skip_if_python_version_less_than,
 )
+
+# Imported for convenience in things that import this but not lang.
+from ...lang import breakpoint_on_exception  # noqa

omlish/testing/pytest/inject/harness.py

@@ -24,7 +24,7 @@ class PytestScope(enum.Enum):
     FUNCTION = enum.auto()
 
 
-class Scopes(lang.Namespace):
+class Scopes(lang.Namespace, lang.Final):
     Session = inj.SeededScope(PytestScope.SESSION)
     Package = inj.SeededScope(PytestScope.PACKAGE)
     Module = inj.SeededScope(PytestScope.MODULE)
@@ -50,7 +50,7 @@ class Harness:
         super().__init__()
         self._orig_es = es
         self._es = inj.as_elements(
-            inj.as_binding(self),
+            inj.bind(self),
             *[
                 inj.as_elements(
                     inj.bind_scope(ss),
@@ -169,7 +169,7 @@ def bind(
         pts = scope if isinstance(scope, PytestScope) else PytestScope[check.isinstance(scope, str).upper()]
         check.isinstance(cls, type)
         register(inj.as_elements(
-            inj.in_(cls, _SCOPES_BY_PYTEST_SCOPE[pts]),
+            inj.bind(cls, in_=_SCOPES_BY_PYTEST_SCOPE[pts]),
         ))
         return cls
     return inner

omlish/testing/pytest/marks.py

@@ -11,9 +11,10 @@ from .plugins.managermarks import ManagerMark  # noqa
 
 
 if ta.TYPE_CHECKING:
-    import asyncio
+    from ...asyncs import asyncio as aiu
+
 else:
-    asyncio = lang.proxy_import('asyncio')
+    aiu = lang.proxy_import('...asyncs.asyncio', __package__)
 
 
 def skip_if_cant_import(module: str, *args, **kwargs):
@@ -40,9 +41,5 @@ def skip_if_nogil():
 
 class drain_asyncio(ManagerMark):  # noqa
     def __call__(self, item: pytest.Function) -> ta.Iterator[None]:
-        loop = asyncio.get_event_loop()
-        try:
+        with aiu.draining_asyncio_tasks():
             yield
-        finally:
-            while loop._ready or loop._scheduled:  # type: ignore  # noqa
-                loop._run_once()  # type: ignore  # noqa

omlish/testing/pytest/plugins/__init__.py

@@ -1,4 +1,5 @@
 from . import (  # noqa
+    asyncs,
     logging,
     managermarks,
     pydevd,

omlish/testing/pytest/plugins/asyncs.py

@@ -0,0 +1,136 @@
+"""
+TODO:
+ - auto drain_asyncio
+
+==
+
+_pytest:
+https://github.com/pytest-dev/pytest/blob/ef9b8f9d748b6f50eab5d43e32d93008f7880899/src/_pytest/python.py#L155
+"async def function and no async plugin installed (see warnings)"
+
+pytest_trio:
+https://github.com/python-trio/pytest-trio/blob/f03160aa1dd355a12d39fa21f4aee4e1239efea3/pytest_trio/plugin.py
+ - pytest_addoption
+ - pytest_configure
+ - pytest_collection_modifyitems
+ - pytest_runtest_call @(hookwrapper=True)
+ - pytest_fixture_setup
+
+pytest_asyncio:
+https://github.com/pytest-dev/pytest-asyncio/blob/f45aa18cf3eeeb94075de16a1d797858facab863/pytest_asyncio/plugin.py
+ - pytest_addoption
+ - pytest_configure
+ - pytest_pycollect_makeitem_preprocess_async_fixtures @(specname="pytest_pycollect_makeitem", tryfirst=True)
+ - pytest_pycollect_makeitem_convert_async_functions_to_subclass @(specname="pytest_pycollect_makeitem", hookwrapper=True)
+ - pytest_generate_tests @(tryfirst=True)
+ - pytest_runtest_setup(item: pytest.Item) -> None:
+ - pytest_pyfunc_call @(tryfirst=True, hookwrapper=True)
+ - pytest_collectstart @()
+ - pytest_report_header @(tryfirst=True)
+ - pytest_fixture_setup @(hookwrapper=True)
+
+anyio.pytest_plugin:
+https://github.com/agronholm/anyio/blob/8907964926a24461840eee0925d3f355e729f15d/src/anyio/pytest_plugin.py
+ - pytest_configure
+ - pytest_pycollect_makeitem @(tryfirst=True)
+ - pytest_pyfunc_call @(tryfirst=True)
+ - pytest_fixture_setup
+
+"""  # noqa
+import functools
+import inspect
+import typing as ta
+
+import pytest
+
+from .... import lang
+from ....asyncs import trio_asyncio as trai
+from ....diag import pydevd as pdu
+from ._registry import register
+
+
+if ta.TYPE_CHECKING:
+    import trio_asyncio
+else:
+    trio_asyncio = lang.proxy_import('trio_asyncio')
+
+
+ASYNCS_MARK = 'asyncs'
+
+KNOWN_BACKENDS = (
+    'asyncio',
+    'trio',
+    'trio_asyncio',
+)
+
+PARAM_NAME = '__async_backend'
+
+
+def iscoroutinefunction(func: ta.Any) -> bool:
+    return inspect.iscoroutinefunction(func) or getattr(func, '_is_coroutine', False)
+
+
+def is_async_function(func: ta.Any) -> bool:
+    return iscoroutinefunction(func) or inspect.isasyncgenfunction(func)
+
+
+@register
+class AsyncsPlugin:
+    ASYNC_BACKENDS: ta.ClassVar[ta.Sequence[str]] = [
+        *[s for s in KNOWN_BACKENDS if lang.can_import(s)],
+    ]
+
+    def pytest_configure(self, config):
+        config.addinivalue_line('markers', f'{ASYNCS_MARK}: marks for all async backends')
+        config.addinivalue_line('markers', 'trio_asyncio: marks for trio_asyncio backend')
+
+    def pytest_generate_tests(self, metafunc):
+        if (m := metafunc.definition.get_closest_marker(ASYNCS_MARK)) is not None:
+            if m.args:
+                bes = m.args
+            else:
+                bes = self.ASYNC_BACKENDS
+        elif metafunc.definition.get_closest_marker('trio_asyncio') is not None:
+            bes = ['trio_asyncio']
+        else:
+            return
+
+        if pdu.is_present():
+            pdu.patch_for_trio_asyncio()
+
+        metafunc.fixturenames.append(PARAM_NAME)
+        metafunc.parametrize(PARAM_NAME, bes)
+
+        for c in metafunc._calls:  # noqa
+            be = c.params[PARAM_NAME]
+            if be == 'trio_asyncio':
+                c.marks.extend([
+                    pytest.mark.trio.mark,
+                    pytest.mark.trio_asyncio.mark,
+                ])
+
+            else:
+                c.marks.append(getattr(pytest.mark, be).mark)
+
+            if pdu.is_present():
+                c.marks.append(pytest.mark.drain_asyncio.mark)
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_call(self, item):
+        bes = [be for be in self.ASYNC_BACKENDS if item.get_closest_marker(be) is not None]
+        if len(bes) > 1 and set(bes) != {'trio', 'trio_asyncio'}:
+            raise Exception(f'{item.nodeid}: multiple async backends specified: {bes}')
+        elif is_async_function(item.obj) and not bes:
+            raise Exception(f'{item.nodeid}: async def function and no async plugin specified')
+
+        if 'trio_asyncio' in bes:
+            obj = item.obj
+
+            @functools.wraps(obj)
+            @trai.with_trio_asyncio_loop(wait=True)
+            async def run(*args, **kwargs):
+                await trio_asyncio.aio_as_trio(obj)(*args, **kwargs)
+
+            item.obj = run
+
+        yield

omlish/testing/pytest/plugins/pydevd.py

@@ -1,4 +1,4 @@
-from ... import pydevd as opd
+from ....diag import pydevd as opd
 from ._registry import register