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

omlish/__about__.py

@@ -1,6 +1,110 @@
-__author__ = 'wrmsr'
-__url__ = 'https://github.com/wrmsr/omlish'
-__license__ = 'BSD-3-Clause'
-__requires_python__ = '>=3.12'
+__version__ = '0.0.0.dev7'
 
-__version__ = '0.0.0.dev5'
+
+#
+
+
+class ProjectBase:
+    name: str | None = None
+    authors = [{'name': 'wrmsr'}]
+    urls = {'source': 'https://github.com/wrmsr/omlish'}
+    license = {'text': 'BSD-3-Clause'}
+    requires_python = '>=3.12'
+
+    version = __version__
+
+    classifiers = [
+        'License :: OSI Approved :: BSD License',
+        'Development Status :: 2 - Pre-Alpha',
+        'Intended Audience :: Developers',
+
+        'Operating System :: OS Independent',
+        'Operating System :: POSIX',
+    ]
+
+
+class Project(ProjectBase):
+    name = 'omlish'
+    description = 'omlish'
+
+    optional_dependencies = {
+        'async': [
+            'anyio >= 4.4',
+            'sniffio >= 1.3',
+
+            'greenlet >= 3; python_version < "3.13"',
+
+            'trio >= 0.26',
+            'trio-asyncio >= 0.15; python_version < "3.13"',
+        ],
+
+        'compression': [
+            'lz4 >= 4',
+            'python-snappy >= 0.7; python_version < "3.13"',
+            'zstd >= 1.5',
+        ],
+
+        'formats': [
+            'orjson > 3.10',
+            'cloudpickle >= 3',
+            'pyyaml >= 5',
+        ],
+
+        'http': [
+            'httpx[http2] >= 0.27',
+        ],
+
+        'misc': [
+            'jinja2 >= 3.1',
+            'psutil >= 6',
+            'wrapt >= 1.14',
+        ],
+
+        'secrets': [
+            'cryptography >= 43',
+        ],
+
+        'sql': [
+            'sqlalchemy >= 2; python_version >= "3.13"',
+            'sqlalchemy[asyncio] >= 2; python_version < "3.13"',
+
+            'pg8000 >= 1.31',
+            'pymysql >= 1.1',
+
+            'aiomysql >= 0.2',
+            'aiosqlite >= 0.20',
+            'asyncpg >= 0.29; python_version < "3.13"',
+        ],
+
+        'sqlx': [
+            "sqlean.py >= 3.45; python_version < '3.13'",
+
+            'duckdb >= 1',
+        ],
+
+        'testing': [
+            'pytest >= 8',
+        ],
+    }
+
+
+#
+
+
+class SetuptoolsBase:
+    manifest_in = [
+        'global-exclude **/conftest.py',
+    ]
+
+    include_package_data = False
+
+    find_packages = {
+        'exclude': ['*.tests', '*.tests.*'],
+    }
+
+
+class Setuptools(SetuptoolsBase):
+    find_packages = {
+        'include': ['omlish', 'omlish.*'],
+        'exclude': [*SetuptoolsBase.find_packages['exclude']],
+    }

omlish/__init__.py

@@ -1,8 +0,0 @@
-import sys as _sys
-
-
-REQUIRED_PYTHON_VERSION = (3, 12)
-
-
-if _sys.version_info < REQUIRED_PYTHON_VERSION:
-    raise RuntimeError(f'Python version {_sys.version_info=} < {REQUIRED_PYTHON_VERSION}')

omlish/asyncs/__init__.py

@@ -6,6 +6,15 @@ from .asyncs import (  # noqa
     syncable_iterable,
 )
 
+from .bridge import (  # noqa
+    a_to_s,
+    is_in_bridge,
+    s_to_a,
+    s_to_a_await,
+    trivial_a_to_s,
+    trivial_s_to_a,
+)
+
 from .flavors import (  # noqa
     ContextManagerAdapter,
     Flavor,
@@ -24,12 +33,3 @@ from .flavors import (  # noqa
     mark_trio,
     with_adapter_loop,
 )
-
-from .futures import (  # noqa
-    FutureError,
-    FutureTimeoutError,
-    ImmediateExecutor,
-    new_thread_or_immediate_executor,
-    wait_dependent_futures,
-    wait_futures,
-)

omlish/asyncs/anyio.py

@@ -13,11 +13,23 @@ lookit:
  - https://github.com/M-o-a-T/aevent
  - https://github.com/florimondmanca/aiometer
  - https://github.com/sanitizers/octomachinery/blob/b36c3d3d49da813ac46e361424132955a4e99ac8/octomachinery/utils/asynctools.py
+
+==
+
+async def killer(shutdown: anyio.Event, sleep_s: float) -> None:
+    log.warning('Killing in %d seconds', sleep_s)
+    await anyio.sleep(sleep_s)
+    log.warning('Killing')
+    shutdown.set()
+
 """  # noqa
+import signal
 import typing as ta
 
+import anyio.abc
 import anyio.streams.memory
 import anyio.streams.stapled
+import sniffio
 
 from .. import check
 from .. import lang
@@ -26,6 +38,9 @@ from .. import lang
 T = ta.TypeVar('T')
 
 
+##
+
+
 async def anyio_eof_to_empty(fn: ta.Callable[..., ta.Awaitable[T]], *args: ta.Any, **kwargs: ta.Any) -> T | bytes:
     try:
         return await fn(*args, **kwargs)
@@ -33,6 +48,85 @@ async def anyio_eof_to_empty(fn: ta.Callable[..., ta.Awaitable[T]], *args: ta.An
         return b''
 
 
+async def gather(*fns: ta.Callable[..., ta.Awaitable[T]], take_first: bool = False) -> list[lang.Maybe[T]]:
+    results: list[lang.Maybe[T]] = [lang.empty()] * len(fns)
+
+    async def inner(fn, i):
+        results[i] = lang.just(await fn())
+        if take_first:
+            tg.cancel_scope.cancel()
+
+    async with anyio.create_task_group() as tg:
+        for i, fn in enumerate(fns):
+            tg.start_soon(inner, fn, i)
+
+    return results
+
+
+async def first(*fns: ta.Callable[..., ta.Awaitable[T]], **kwargs: ta.Any) -> list[lang.Maybe[T]]:
+    return await gather(*fns, take_first=True, **kwargs)
+
+
+##
+
+
+def get_current_task() -> anyio.TaskInfo | None:
+    try:
+        return anyio.get_current_task()
+    except sniffio.AsyncLibraryNotFoundError:
+        return None
+
+
+#
+
+
+BackendTask: ta.TypeAlias = ta.Union[  # noqa
+    # asyncio.tasks.Task,
+    # trio.lowlevel.Task,
+    ta.Any,
+]
+
+
+def _is_class_named(obj: ta.Any, m: str, n: str) -> bool:
+    cls = obj.__class__
+    return cls.__module__ == m and cls.__name__ == n
+
+
+def get_backend_task(at: anyio.TaskInfo) -> BackendTask | None:
+    if _is_class_named(at, 'anyio._backends._asyncio', 'AsyncIOTaskInfo'):
+        # https://github.com/agronholm/anyio/blob/8907964926a24461840eee0925d3f355e729f15d/src/anyio/_backends/_asyncio.py#L1846  # noqa
+        # weakref.ref
+        obj = at._task()  # type: ignore  # noqa
+        if obj is not None and not (
+                _is_class_named(obj, '_asyncio', 'Task') or
+                _is_class_named(obj, 'asyncio.tasks', 'Task')
+        ):
+            raise TypeError(obj)
+        return obj
+
+    elif _is_class_named(at, 'anyio._backends._trio', 'TrioTaskInfo'):
+        # https://github.com/agronholm/anyio/blob/8907964926a24461840eee0925d3f355e729f15d/src/anyio/_backends/_trio.py#L850  # noqa
+        # weakref.proxy
+        # https://stackoverflow.com/a/62144308 :|
+        obj = at._task.__repr__.__self__  # type: ignore  # noqa
+        if obj is not None and not _is_class_named(obj, 'trio.lowlevel', 'Task'):
+            raise TypeError(obj)
+        return obj
+
+    else:
+        raise TypeError(at)
+
+
+def get_current_backend_task() -> BackendTask | None:
+    if (at := get_current_task()) is not None:
+        return get_backend_task(at)
+    else:
+        return None
+
+
+##
+
+
 def split_memory_object_streams(
         *args: anyio.create_memory_object_stream[T],
 ) -> tuple[
@@ -72,25 +166,6 @@ def staple_memory_object_stream2[T](max_buffer_size: float = 0) -> anyio.streams
     )
 
 
-async def gather(*fns: ta.Callable[..., ta.Awaitable[T]], take_first: bool = False) -> list[lang.Maybe[T]]:
-    results: list[lang.Maybe[T]] = [lang.empty()] * len(fns)
-
-    async def inner(fn, i):
-        results[i] = lang.just(await fn())
-        if take_first:
-            tg.cancel_scope.cancel()
-
-    async with anyio.create_task_group() as tg:
-        for i, fn in enumerate(fns):
-            tg.start_soon(inner, fn, i)
-
-    return results
-
-
-async def first(*fns: ta.Callable[..., ta.Awaitable[T]], **kwargs: ta.Any) -> list[lang.Maybe[T]]:
-    return await gather(*fns, take_first=True, **kwargs)
-
-
 ##
 
 
@@ -150,3 +225,32 @@ class LazyFn(ta.Generic[T]):
             self._v = lang.just(await self._fn())
         await self._once.do(do)
         return self._v.must()
+
+
+##
+
+
+async def install_shutdown_signal_handler(
+        tg: anyio.abc.TaskGroup,
+        event: anyio.Event | None = None,
+        *,
+        signals: ta.Iterable[int] = (signal.SIGINT, signal.SIGTERM),
+        echo: bool = False,
+) -> ta.Callable[..., ta.Awaitable[None]] | None:
+    if event is None:
+        event = anyio.Event()
+
+    async def _handler(*, task_status=anyio.TASK_STATUS_IGNORED):
+        with anyio.open_signal_receiver(*signals) as it:  # type: ignore
+            task_status.started()
+            async for signum in it:
+                if echo:
+                    if signum == signal.SIGINT:
+                        print('Ctrl+C pressed!')
+                    else:
+                        print('Terminated!')
+                event.set()
+                return
+
+    await tg.start(_handler)
+    return event.wait

omlish/asyncs/asyncio.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 import functools
 import typing as ta
 
@@ -17,3 +18,25 @@ def asyncio_once(fn: CallableT) -> CallableT:
         return await future
 
     return ta.cast(CallableT, inner)
+
+
+def get_real_current_loop() -> asyncio.AbstractEventLoop | None:
+    return asyncio.get_event_loop_policy()._local._loop  # type: ignore  # noqa
+
+
+def drain_tasks(loop=None):
+    if loop is None:
+        loop = get_real_current_loop()
+
+    while loop._ready or loop._scheduled:  # noqa
+        loop._run_once()  # noqa
+
+
+@contextlib.contextmanager
+def draining_asyncio_tasks() -> ta.Iterator[None]:
+    loop = get_real_current_loop()
+    try:
+        yield
+    finally:
+        if loop is not None:
+            drain_tasks(loop)  # noqa

omlish/asyncs/asyncs.py

@@ -5,10 +5,10 @@ TODO:
   517 ns ± 13.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
   - injected io provider - sync vs greenlet aio trampolined
  - push/pull bridge?
+ - move to lang
 
 https://github.com/sqlalchemy/sqlalchemy/blob/1e75c189da721395bc8c2d899c722a5b9a170404/lib/sqlalchemy/util/_concurrency_py3k.py#L83
 """
-import contextlib
 import functools
 import typing as ta
 
@@ -16,8 +16,7 @@ import typing as ta
 T = ta.TypeVar('T')
 
 
-def sync_await(fn: ta.Callable[..., T], *args, **kwargs) -> T:
-    ret: ta.Any
+def sync_await(fn: ta.Callable[..., T], *args: ta.Any, **kwargs: ta.Any) -> T:
     ret = missing = object()
 
     async def gate():
@@ -25,13 +24,17 @@ def sync_await(fn: ta.Callable[..., T], *args, **kwargs) -> T:
         ret = await fn(*args, **kwargs)  # type: ignore
 
     cr = gate()
-    with contextlib.closing(cr):
-        with contextlib.suppress(StopIteration):
+    try:
+        try:
             cr.send(None)
+        except StopIteration:
+            pass
         if ret is missing or cr.cr_await is not None or cr.cr_running:
             raise TypeError('Not terminated')
+    finally:
+        cr.close()
 
-    return ta.cast(T, ret)
+    return ret  # type: ignore
 
 
 def sync_list(fn: ta.Callable[..., ta.AsyncIterator[T]], *args, **kwargs) -> list[T]: