omlish 0.0.0.dev5__tar.gz → 0.0.0.dev7__tar.gz

omlish-0.0.0.dev7/MANIFEST.in

@@ -0,0 +1 @@
+global-exclude **/conftest.py

omlish-0.0.0.dev7/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.1
+Name: omlish
+Version: 0.0.0.dev7
+Summary: omlish
+Author: wrmsr
+License: BSD-3-Clause
+Project-URL: source, https://github.com/wrmsr/omlish
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Requires-Python: >=3.12
+License-File: LICENSE
+Provides-Extra: async
+Requires-Dist: anyio>=4.4; extra == "async"
+Requires-Dist: sniffio>=1.3; extra == "async"
+Requires-Dist: greenlet>=3; python_version < "3.13" and extra == "async"
+Requires-Dist: trio>=0.26; extra == "async"
+Requires-Dist: trio-asyncio>=0.15; python_version < "3.13" and extra == "async"
+Provides-Extra: compression
+Requires-Dist: lz4>=4; extra == "compression"
+Requires-Dist: python-snappy>=0.7; python_version < "3.13" and extra == "compression"
+Requires-Dist: zstd>=1.5; extra == "compression"
+Provides-Extra: formats
+Requires-Dist: orjson>3.10; extra == "formats"
+Requires-Dist: cloudpickle>=3; extra == "formats"
+Requires-Dist: pyyaml>=5; extra == "formats"
+Provides-Extra: http
+Requires-Dist: httpx[http2]>=0.27; extra == "http"
+Provides-Extra: misc
+Requires-Dist: jinja2>=3.1; extra == "misc"
+Requires-Dist: psutil>=6; extra == "misc"
+Requires-Dist: wrapt>=1.14; extra == "misc"
+Provides-Extra: secrets
+Requires-Dist: cryptography>=43; extra == "secrets"
+Provides-Extra: sql
+Requires-Dist: sqlalchemy>=2; python_version >= "3.13" and extra == "sql"
+Requires-Dist: sqlalchemy[asyncio]>=2; python_version < "3.13" and extra == "sql"
+Requires-Dist: pg8000>=1.31; extra == "sql"
+Requires-Dist: pymysql>=1.1; extra == "sql"
+Requires-Dist: aiomysql>=0.2; extra == "sql"
+Requires-Dist: aiosqlite>=0.20; extra == "sql"
+Requires-Dist: asyncpg>=0.29; python_version < "3.13" and extra == "sql"
+Provides-Extra: sqlx
+Requires-Dist: sqlean.py>=3.45; python_version < "3.13" and extra == "sqlx"
+Requires-Dist: duckdb>=1; extra == "sqlx"
+Provides-Extra: testing
+Requires-Dist: pytest>=8; extra == "testing"

omlish-0.0.0.dev7/README.rst

@@ -0,0 +1 @@
+*omlish*

omlish-0.0.0.dev7/omlish/__about__.py

@@ -0,0 +1,110 @@
+__version__ = '0.0.0.dev7'
+
+
+#
+
+
+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-0.0.0.dev5 → omlish-0.0.0.dev7}/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-0.0.0.dev5 → omlish-0.0.0.dev7}/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-0.0.0.dev7/omlish/asyncs/asyncio.py

@@ -0,0 +1,42 @@
+import asyncio
+import contextlib
+import functools
+import typing as ta
+
+
+CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
+
+
+def asyncio_once(fn: CallableT) -> CallableT:
+    future = None
+
+    @functools.wraps(fn)
+    async def inner(*args, **kwargs):
+        nonlocal future
+        if not future:
+            future = asyncio.create_task(fn(*args, **kwargs))
+        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-0.0.0.dev5 → omlish-0.0.0.dev7}/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]: