omlish 0.0.0.dev4__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/sync.py

@@ -0,0 +1,70 @@
+"""
+TODO:
+ - sync (lol) w/ asyncs.anyio
+ - atomics
+"""
+import threading
+import typing as ta
+
+from . import lang
+
+
+T = ta.TypeVar('T')
+
+
+class Once:
+    def __init__(self) -> None:
+        super().__init__()
+        self._done = False
+        self._lock = threading.Lock()
+
+    def do(self, fn: ta.Callable[[], None]) -> bool:
+        if self._done:
+            return False
+        with self._lock:
+            if self._done:
+                return False  # type: ignore
+            try:
+                fn()
+            finally:
+                self._done = True
+            return True
+
+
+class Lazy(ta.Generic[T]):
+    def __init__(self) -> None:
+        super().__init__()
+        self._once = Once()
+        self._v: lang.Maybe[T] = lang.empty()
+
+    def peek(self) -> lang.Maybe[T]:
+        return self._v
+
+    def set(self, v: T) -> None:
+        self._v = lang.just(v)
+
+    def get(self, fn: ta.Callable[[], T]) -> T:
+        def do():
+            self._v = lang.just(fn())
+        self._once.do(do)
+        return self._v.must()
+
+
+class LazyFn(ta.Generic[T]):
+    def __init__(self, fn: ta.Callable[[], T]) -> None:
+        super().__init__()
+        self._fn = fn
+        self._once = Once()
+        self._v: lang.Maybe[T] = lang.empty()
+
+    def peek(self) -> lang.Maybe[T]:
+        return self._v
+
+    def set(self, v: T) -> None:
+        self._v = lang.just(v)
+
+    def get(self) -> T:
+        def do():
+            self._v = lang.just(self._fn())
+        self._once.do(do)
+        return self._v.must()

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
 
@@ -213,8 +213,13 @@ def main() -> None:
 
     sys.stdout.write(SGR(SGRs.RESET))
     sys.stdout.write(BG8(15) + ' ')
-    for i in [196, 160, 124, 88, 52, 16]:
+    for i in range(20):
         sys.stdout.write(BG8(i) + ' ')
+    sys.stdout.write('\n')
+    for i in range(256):
+        if i % 12 == 0:
+            sys.stdout.write('\n')
+        sys.stdout.write(BG8(i + 16) + ' ')
     sys.stdout.write(SGR(SGRs.RESET) + '\n')
 
 

omlish/testing/pytest/__init__.py

@@ -1,8 +1,14 @@
-from . import plugins  # noqa
-
 from .helpers import (  # noqa
     assert_raises_star,
+)
+
+from .marks import (  # noqa
+    drain_asyncio,
     skip_if_cant_import,
+    skip_if_nogil,
     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/helpers.py

@@ -1,28 +1,4 @@
 import contextlib
-import shutil
-import sys
-import typing as ta
-
-import pytest
-
-from ..testing import can_import
-
-
-def skip_if_cant_import(module: str, *args, **kwargs):
-    return pytest.mark.skipif(not can_import(module, *args, **kwargs), reason=f'requires import {module}')
-
-
-def skip_if_not_on_path(exe: str):
-    return pytest.mark.skipif(shutil.which(exe) is None, reason=f'requires exe on path {exe}')
-
-
-def skip_if_python_version_less_than(num: ta.Sequence[int]):
-    return pytest.mark.skipif(sys.version_info < tuple(num), reason=f'python version {tuple(sys.version_info)} < {tuple(num)}')  # noqa
-
-
-def skip_if_not_single():
-    # [resolve_collection_argument(a) for a in session.config.args]
-    raise NotImplementedError
 
 
 @contextlib.contextmanager

omlish/testing/pytest/inject/harness.py

@@ -4,10 +4,10 @@ import typing as ta
 
 import pytest
 
-from .. import plugins
 from .... import check
 from .... import inject as inj
 from .... import lang
+from .. import plugins
 
 
 T = ta.TypeVar('T')
@@ -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

@@ -0,0 +1,45 @@
+import shutil
+import sys
+import sysconfig
+import typing as ta
+
+import pytest
+
+from ... import lang  # noqa
+from ..testing import can_import
+from .plugins.managermarks import ManagerMark  # noqa
+
+
+if ta.TYPE_CHECKING:
+    from ...asyncs import asyncio as aiu
+
+else:
+    aiu = lang.proxy_import('...asyncs.asyncio', __package__)
+
+
+def skip_if_cant_import(module: str, *args, **kwargs):
+    return pytest.mark.skipif(not can_import(module, *args, **kwargs), reason=f'requires import {module}')
+
+
+def skip_if_not_on_path(exe: str):
+    return pytest.mark.skipif(shutil.which(exe) is None, reason=f'requires exe on path {exe}')
+
+
+def skip_if_python_version_less_than(num: ta.Sequence[int]):
+    return pytest.mark.skipif(sys.version_info < tuple(num), reason=f'python version {tuple(sys.version_info)} < {tuple(num)}')  # noqa
+
+
+def skip_if_not_single():
+    # FIXME
+    # [resolve_collection_argument(a) for a in session.config.args]
+    raise NotImplementedError
+
+
+def skip_if_nogil():
+    return pytest.mark.skipif(sysconfig.get_config_var('Py_GIL_DISABLED'), reason='requires gil build')
+
+
+class drain_asyncio(ManagerMark):  # noqa
+    def __call__(self, item: pytest.Function) -> ta.Iterator[None]:
+        with aiu.draining_asyncio_tasks():
+            yield

omlish/testing/pytest/plugins/__init__.py

@@ -1,11 +1,14 @@
 from . import (  # noqa
+    asyncs,
     logging,
+    managermarks,
     pydevd,
     repeat,
     skips,
     spacing,
     switches,
 )
+
 from ._registry import (  # noqa
     ALL,
     register,