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

omlish/reflect.py

@@ -1,5 +1,6 @@
 """
 TODO:
+ - callables..
  - uniform collection isinstance - items() for mappings, iter() for other
  - also check instance type in isinstance not just items lol
  - ta.Generic in mro causing trouble - omit? no longer 1:1
@@ -7,12 +8,13 @@ TODO:
   - cache __hash__ in Generic/Union
 """
 import collections.abc
-import typing as ta
 import types
+import typing as ta
 
 from . import c3
 from . import lang
 
+
 if ta.TYPE_CHECKING:
     from .collections import cache
 else:
@@ -25,6 +27,7 @@ _NONE_TYPE_FROZENSET: frozenset['Type'] = frozenset([_NoneType])
 
 
 _GenericAlias = ta._GenericAlias  # type: ignore  # noqa
+# _CallableGenericAlias = ta._CallableGenericAlias  # type: ignore  # noqa
 _SpecialGenericAlias = ta._SpecialGenericAlias  # type: ignore  # noqa
 _UnionGenericAlias = ta._UnionGenericAlias   # type: ignore  # noqa
 
@@ -155,7 +158,10 @@ def type_(obj: ta.Any) -> Type:
     if isinstance(obj, ta.NewType):  # noqa
         return NewType(oty)
 
-    if oty is _GenericAlias or oty is ta.GenericAlias:  # type: ignore  # noqa
+    if (
+            oty is _GenericAlias or
+            oty is ta.GenericAlias  # type: ignore  # noqa
+    ):
         origin = ta.get_origin(obj)
         args = ta.get_args(obj)
         if origin is ta.Generic:

omlish/sql/__init__.py

@@ -0,0 +1,9 @@
+from .asyncs import (  # noqa
+    AsyncConnection,
+    AsyncConnectionLike,
+    AsyncEngine,
+    AsyncEngineLike,
+    AsyncTransaction,
+    AsyncTransactionLike,
+    async_adapt,
+)

omlish/sql/asyncs.py

@@ -0,0 +1,148 @@
+"""
+TODO:
+ - Maysync impls?
+ - base Protocol so adapters and real sa impls can be used interchangeably (if in asyncio ctx)?
+"""
+import contextlib
+import typing as ta
+
+import sqlalchemy as sa
+import sqlalchemy.ext.asyncio as saa
+
+from .. import asyncs as au
+
+
+T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
+
+
+AsyncEngineLike = ta.Union[saa.AsyncEngine, 'AsyncEngine']
+AsyncConnectionLike = ta.Union[saa.AsyncConnection, 'AsyncConnection']
+AsyncTransactionLike = ta.Union[saa.AsyncTransaction, 'AsyncTransaction']
+
+
+class AsyncTransaction:
+    def __init__(self, underlying: saa.AsyncTransaction) -> None:
+        super().__init__()
+        self._underlying = underlying
+
+    @property
+    def underlying(self) -> saa.AsyncTransaction:
+        return self._underlying
+
+    ##
+
+    @au.mark_asyncio
+    async def close(self) -> None:
+        await au.from_asyncio(self._underlying.close)()
+
+    @au.mark_asyncio
+    async def rollback(self) -> None:
+        await au.from_asyncio(self._underlying.rollback)()
+
+    @au.mark_asyncio
+    async def commit(self) -> None:
+        await au.from_asyncio(self._underlying.commit)()
+
+
+class AsyncConnection:
+    def __init__(self, underlying: saa.AsyncConnection) -> None:
+        super().__init__()
+        self._underlying = underlying
+
+    @property
+    def underlying(self) -> saa.AsyncConnection:
+        return self._underlying
+
+    ##
+
+    @contextlib.asynccontextmanager
+    @au.mark_asyncio
+    async def begin(self) -> ta.AsyncIterator[AsyncTransaction]:
+        async with au.from_asyncio_context(self._underlying.begin()) as u:
+            yield AsyncTransaction(u)
+
+    @au.mark_asyncio
+    async def execute(
+            self,
+            statement: ta.Any,
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> sa.CursorResult[ta.Any]:
+        return await au.from_asyncio(self._underlying.execute)(statement, *args, **kwargs)
+
+    @au.mark_asyncio
+    async def run_sync(
+            self,
+            fn: ta.Callable[ta.Concatenate[sa.Connection, P], T],
+            *args: P.args,
+            **kwargs: P.kwargs,
+    ) -> T:
+        return await au.from_asyncio(self._underlying.run_sync)(fn, *args, **kwargs)
+
+
+class AsyncEngine:
+    def __init__(self, underlying: saa.AsyncEngine) -> None:
+        super().__init__()
+        self._underlying = underlying
+
+    @property
+    def underlying(self) -> saa.AsyncEngine:
+        return self._underlying
+
+    ##
+
+    @contextlib.asynccontextmanager
+    @au.mark_asyncio
+    async def connect(self) -> ta.AsyncIterator[AsyncConnection]:
+        async with au.from_asyncio_context(self._underlying.connect()) as u:
+            yield AsyncConnection(u)
+
+    @au.mark_asyncio
+    async def dispose(self, close: bool = True) -> None:
+        await au.from_asyncio(self._underlying.dispose)(close)
+
+
+##
+
+
+@ta.overload
+def async_adapt(obj: AsyncEngine) -> AsyncEngine:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: AsyncConnection) -> AsyncConnection:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: AsyncTransaction) -> AsyncTransaction:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: saa.AsyncEngine) -> AsyncEngine:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: saa.AsyncConnection) -> AsyncConnection:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: saa.AsyncTransaction) -> AsyncTransaction:
+    ...
+
+
+def async_adapt(obj: ta.Any) -> ta.Any:
+    if isinstance(obj, (AsyncEngine, AsyncConnection, AsyncTransaction)):
+        return obj
+    if isinstance(obj, saa.AsyncTransaction):
+        return AsyncTransaction(obj)
+    if isinstance(obj, saa.AsyncConnection):
+        return AsyncConnection(obj)
+    if isinstance(obj, saa.AsyncEngine):
+        return AsyncEngine(obj)
+    raise TypeError(obj)

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

@@ -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/pydevd.py

@@ -87,6 +87,8 @@ def silence_subprocess_check() -> None:
 
 @lang.cached_function
 def patch_for_trio_asyncio() -> None:
+    """Fix for `trio a callable object was expected by call_soon(), got Task`"""
+
     try:
         import pydevd_nest_asyncio  # noqa
     except ImportError:

omlish/testing/pytest/__init__.py

@@ -2,7 +2,12 @@ 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,
 )

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')

omlish/testing/pytest/marks.py

@@ -0,0 +1,48 @@
+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:
+    import asyncio
+else:
+    asyncio = lang.proxy_import('asyncio')
+
+
+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]:
+        loop = asyncio.get_event_loop()
+        try:
+            yield
+        finally:
+            while loop._ready or loop._scheduled:  # type: ignore  # noqa
+                loop._run_once()  # type: ignore  # noqa

omlish/testing/pytest/plugins/__init__.py

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

omlish/testing/pytest/plugins/managermarks.py

@@ -0,0 +1,60 @@
+import abc
+import contextlib
+import typing as ta
+
+import pytest
+
+from .... import lang
+from ._registry import register
+
+
+class ManagerMark(lang.Abstract):
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+
+    @abc.abstractmethod
+    def __call__(self, item: pytest.Function) -> ta.Iterator[None]:
+        raise NotImplementedError
+
+
+def _deep_subclasses(cls):
+    ret = set()
+
+    def rec(cur):
+        for nxt in cur.__subclasses__():
+            if nxt not in ret:
+                ret.add(nxt)
+                rec(nxt)
+
+    rec(cls)
+    return ret
+
+
+@register
+class ManagerMarksPlugin:
+
+    @lang.cached_function
+    def mark_classes(self) -> ta.Mapping[str, type[ManagerMark]]:
+        return {
+            cls.__name__: cls
+            for cls in _deep_subclasses(ManagerMark)
+            if not lang.is_abstract_class(cls)
+        }
+
+    def pytest_configure(self, config):
+        for n in self.mark_classes():
+            config.addinivalue_line(
+                'markers',
+                f'{n}: mark to manage {n}',
+            )
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_call(self, item):
+        with contextlib.ExitStack() as es:
+            for n, cls in self.mark_classes().items():
+                if (m := item.get_closest_marker(n)) is None:
+                    continue
+                inst = cls(*m.args, **m.kwargs)
+                es.enter_context(contextlib.contextmanager(inst)(item))
+
+            yield

omlish/testing/testing.py

@@ -1,6 +1,7 @@
 import functools
 import importlib
 import os
+import sys
 import threading
 import time
 import traceback
@@ -100,3 +101,12 @@ def xfail(fn):
             traceback.print_exc()
 
     return inner
+
+
+def raise_in_thread(thr: threading.Thread, exc: BaseException | type[BaseException]) -> None:
+    if sys.implementation.name != 'cpython':
+        raise RuntimeError(sys.implementation.name)
+
+    # https://github.com/python/cpython/blob/37ba7531a59a0a2b240a86f7e2adfb1b1cd8ac0c/Lib/test/test_threading.py#L182
+    import ctypes as ct
+    ct.pythonapi.PyThreadState_SetAsyncExc(ct.c_ulong(thr.ident), ct.py_object(exc))  # type: ignore

omlish/text/delimit.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - replace with codecs.StreamReader
+"""
 import io
 import typing as ta
 

{omlish-0.0.0.dev3.dist-info → omlish-0.0.0.dev5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev3
+Version: 0.0.0.dev5
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -24,6 +24,9 @@ Provides-Extra: sql
 Requires-Dist: sqlalchemy ; extra == 'sql'
 Provides-Extra: test
 Requires-Dist: pytest ; extra == 'test'
+Provides-Extra: trio
+Requires-Dist: trio ; extra == 'trio'
+Requires-Dist: trio-asyncio ; extra == 'trio'
 Provides-Extra: wrapt
 Requires-Dist: wrapt ; extra == 'wrapt'
 Provides-Extra: yaml