omlish 0.0.0.dev447__py3-none-any.whl → 0.0.0.dev493__py3-none-any.whl

omlish/.omlish-manifests.json

@@ -359,5 +359,17 @@
         "module": "omlish.specs.jmespath.__main__"
       }
     }
+  },
+  {
+    "module": ".text.docwrap.__main__",
+    "attr": "_CLI_MODULE",
+    "file": "omlish/text/docwrap/__main__.py",
+    "line": 1,
+    "value": {
+      "!omdev.cli.types.CliModule": {
+        "name": "docwrap",
+        "module": "omlish.text.docwrap.__main__"
+      }
+    }
   }
 ]

omlish/README.md

@@ -0,0 +1,199 @@
+# Overview
+
+Core utilities and foundational code. It's relatively large but completely self-contained, and has **no required
+dependencies of any kind**.
+
+# Notable packages
+
+- **[lang](https://github.com/wrmsr/omlish/blob/master/omlish/lang)** - The standard library of this standard library.
+  Usually imported as a whole (`from omlish import lang`), it contains an array of general purpose utilities used
+  practically everywhere. It is kept relatively lightweight: its heaviest import is stdlib dataclasses and its
+  transitives. Some of its contents include:
+
+  - **[cached](https://github.com/wrmsr/omlish/blob/master/omlish/lang/cached)** - The standard `cached_function` /
+    `cached_property` tools, which are more capable than
+    [`functools.lru_cache`](https://docs.python.org/3/library/functools.html#functools.lru_cache).
+  - **[imports](https://github.com/wrmsr/omlish/blob/master/omlish/lang/imports.py)** - Import tools like:
+    - `proxy_import` - For late-loaded imports.
+    - `proxy_init` - For late-loaded module globals.
+    - `auto_proxy_init` - For automatic late-loaded package exports.
+  - **[classes](https://github.com/wrmsr/omlish/blob/master/omlish/lang/classes)** - Class tools and bases, such as
+    `Abstract` (which checks at subclass definition not instantiation), `Sealed` / `PackageSealed`, and `Final`.
+  - **[maybes](https://github.com/wrmsr/omlish/blob/master/omlish/lite/maybes.py)** - A simple, nestable formalization
+    of the presence or absence of an object, as in [many](https://en.cppreference.com/w/cpp/utility/optional)
+    [other](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html)
+    [languages](https://doc.rust-lang.org/std/option/).
+  - **[maysync](https://github.com/wrmsr/omlish/blob/master/omlish/lite/maysync.py)** - A lightweight means of sharing
+    code between sync and async contexts, eliminating the need for maintaining sync and async versions of functions.
+
+- **[bootstrap](https://github.com/wrmsr/omlish/blob/master/omlish/bootstrap)** - A centralized, configurable,
+  all-in-one collection of various process-initialization minutiae like resource limiting, profiling, remote debugging,
+  log configuration, environment variables, et cetera. Usable as a context manager or via its
+  [cli](https://github.com/wrmsr/omlish/blob/master/omlish/bootstrap/main.py).
+
+- **[collections](https://github.com/wrmsr/omlish/blob/master/omlish/collections)** - A handful of collection utilities
+  and simple implementations, including:
+
+  - **[cache](https://github.com/wrmsr/omlish/blob/master/omlish/collections/cache)** - A configurable LRU / LFU cache
+    with options like ttl and  max size / weight.
+  - **[hasheq](https://github.com/wrmsr/omlish/blob/master/omlish/collections/hasheq.py)** - A dict taking an external
+    `__hash__` / `__eq__` implementation.
+  - **[identity](https://github.com/wrmsr/omlish/blob/master/omlish/collections/identity.py)** - Identity-keyed
+    collections.
+  - **[sorted](https://github.com/wrmsr/omlish/blob/master/omlish/collections/sorted)** - Interfaces for value-sorted
+    collections and key-sorted mappings, and a simple but correct skiplist-backed implementation.
+  - **[persistent](https://github.com/wrmsr/omlish/blob/master/omlish/collections/persistent)** - Interfaces for
+    [persistent](https://en.wikipedia.org/wiki/Persistent_data_structure) maps, and a simple but correct treap-backed
+    implementation.
+
+- **[dataclasses](https://github.com/wrmsr/omlish/blob/master/omlish/dataclasses)** - A fully-compatible
+  reimplementation of stdlib [dataclasses](https://docs.python.org/3/library/dataclasses.html) with numerous
+  enhancements and additional features. The
+  [full stdlib test suite](https://github.com/wrmsr/omlish/blob/master/omlish/dataclasses/tests/cpython) is run against
+  it ensuring compatibility - they *are* dataclasses. Current enhancements include:
+
+  - Simple field coercion and validation.
+  - Any number of `@dc.init` or `@dc.validate` methods, not just a central `__post_init__`.
+  - Optional generic type parameter substitution in generated `__init__` methods, enabling accurate reflection.
+  - An optional [metaclass](https://github.com/wrmsr/omlish/blob/master/omlish/dataclasses/metaclass) which removes the
+    need for re-decorating subclasses (with support for inheritance of dataclass parameters like `frozen`), and some
+    basic [base classes](https://github.com/wrmsr/omlish/blob/master/omlish/dataclasses/metaclass/bases.py).
+  - Support for ahead-of-time / build-time code generation, significantly reducing import times.
+
+  The stdlib-equivalent api is exported in such a way as to appear to be direct aliases for the stdlib api itself,
+  simplifying tool support.
+
+- **[dispatch](https://github.com/wrmsr/omlish/blob/master/omlish/dispatch)** - A beefed-up version of
+  [functools.singledispatch](https://docs.python.org/3/library/functools.html#functools.singledispatch), most notably
+  supporting MRO-honoring method impl dispatch.
+
+- **[formats](https://github.com/wrmsr/omlish/blob/master/omlish/formats)** - Tools for various data formats, including:
+
+  - **[json](https://github.com/wrmsr/omlish/blob/master/omlish/formats/json)** - Tools for json, including abstraction
+    over various backends and a self-contained streaming / incremental parser.
+  - **[json5](https://github.com/wrmsr/omlish/blob/master/omlish/formats/json5)** - A self-contained and tested
+    [Json5](https://json5.org/) parser.
+  - **[toml](https://github.com/wrmsr/omlish/blob/master/omlish/formats/toml)** - Toml tools, including a
+    [lite](#lite-code) version of the stdlib parser (for use in older pythons).
+
+- **[http](https://github.com/wrmsr/omlish/blob/master/omlish/http)** - HTTP code, including:
+
+  - **[clients](https://github.com/wrmsr/omlish/blob/master/omlish/http/clients)** - An abstraction over HTTP clients,
+    with urllib and httpx implementations.
+  - **[coro](https://github.com/wrmsr/omlish/blob/master/omlish/http/coro)** - Coroutine /
+    [sans-io](https://sans-io.readthedocs.io/) style reformulation of some stdlib http machinery - namely `http.server`
+    (and soon `http.client`). This style of code can run the same in sync, async, or
+    [any](https://docs.python.org/3/library/selectors.html)
+    [other](https://github.com/wrmsr/omlish/blob/master/omlish/asyncs/bluelet) context.
+
+- **[inject](https://github.com/wrmsr/omlish/blob/master/omlish/inject)** - A
+  [guice](https://github.com/google/guice)-style dependency injector.
+
+- **[io](https://github.com/wrmsr/omlish/blob/master/omlish/io)** - IO tools, including:
+
+  - **[compress](https://github.com/wrmsr/omlish/blob/master/omlish/io/compress)** - Abstraction over various
+    compression schemes, with particular attention to incremental operation. For example it includes
+    [an incremental reformulation of stdlib's gzip](https://github.com/wrmsr/omlish/blob/master/omlish/io/compress/gzip.py).
+  - **[coro](https://github.com/wrmsr/omlish/blob/master/omlish/io/coro)** - Utilities for coroutine / sans-io style
+    code.
+  - **[fdio](https://github.com/wrmsr/omlish/blob/master/omlish/io/fdio)** - An implementation of classic
+    [selector](https://docs.python.org/3/library/selectors.html)-style IO dispatch, akin to the deprecated
+    [asyncore](https://docs.python.org/3.11/library/asyncore.html). While more modern asyncio style code is generally
+    preferred, it nearly always involves
+    [background threads](https://github.com/python/cpython/blob/95d9dea1c4ed1b1de80074b74301cee0b38d5541/Lib/asyncio/unix_events.py#L1349)
+    making it [unsuitable for forking processes](https://rachelbythebay.com/w/2011/06/07/forked/) like
+    [process supervisors](https://github.com/wrmsr/omlish/blob/master/ominfra/supervisor).
+
+- **[jmespath](https://github.com/wrmsr/omlish/blob/master/omlish/specs/jmespath)** - A vendoring of
+  [jmespath community edition](https://github.com/jmespath-community/python-jmespath), modernized and adapted to this
+  codebase.
+
+- **[marshal](https://github.com/wrmsr/omlish/blob/master/omlish/marshal)** - A
+  [jackson](https://github.com/FasterXML/jackson)-style serde system.
+
+- **[manifests](https://github.com/wrmsr/omlish/blob/master/omlish/manifests)** - A system for sharing lightweight
+  metadata within / across codebases.
+
+- **[reflect](https://github.com/wrmsr/omlish/blob/master/omlish/reflect)** - Reflection utilities, including primarily
+  a formalization of stdlib type annotations for use at runtime, decoupled from stdlib impl detail. Keeping this working
+  is notoriously difficult across python versions (one of the primary reasons for only supporting 3.13+).
+
+- **[sql](https://github.com/wrmsr/omlish/blob/master/omlish/sql)** - A collection of SQL utilities, including:
+
+  - **[api](https://github.com/wrmsr/omlish/blob/master/omlish/sql/api)** - An abstracted api for SQL interaction, with
+    support for dbapi compatible drivers (and a SQLAlchemy adapter).
+  - **[queries](https://github.com/wrmsr/omlish/blob/master/omlish/sql/queries)** - A SQL query builder with a fluent
+    interface.
+  - **[alchemy](https://github.com/wrmsr/omlish/blob/master/omlish/sql/alchemy)** - SQLAlchemy utilities. The codebase
+    has moved away from SQLAlchemy in favor of its own internal SQL api, but it will likely still remain as an optional
+    dep for the api adapter.
+
+- **[testing](https://github.com/wrmsr/omlish/blob/master/omlish/testing)** - Test - primarily pytest - helpers,
+  including:
+
+  - **['harness'](https://github.com/wrmsr/omlish/blob/master/omlish/testing/pytest/inject/harness.py)** - An all-in-one
+    fixture marrying it to the codebase's dependency injector.
+  - **[plugins/async](https://github.com/wrmsr/omlish/blob/master/omlish/testing/pytest/plugins/asyncs)** - An in-house
+    async-backend abstraction plugin, capable of handling all of asyncio / trio / trio-asyncio /
+    *any-future-event-loop-impl* without having multiple fighting plugins (*[I know, I know](https://xkcd.com/927/)*).
+  - **[plugins](https://github.com/wrmsr/omlish/blob/master/omlish/testing/pytest/plugins)** - Various other plugins.
+
+- **[typedvalues](https://github.com/wrmsr/omlish/blob/master/omlish/typedvalues)** - A little toolkit around 'boxed'
+  values, whose 'box' types convey more information than the bare values themselves. A rebellion against kwargs and env
+  vars: instead of `foo(bar=1, baz=2)`, you do `foo(Bar(1), Baz(2))`.
+
+- **[lite](https://github.com/wrmsr/omlish/blob/master/omlish/lite)** - The standard library of 'lite' code. This is the
+  only package beneath `lang`, and parts of it are re-exported by it for deduplication. On top of miscellaneous
+  utilities it contains a handful of independent, self-contained, significantly simplified 'lite' equivalents of some
+  major core packages:
+
+  - **[lite/inject.py](https://github.com/wrmsr/omlish/blob/master/omlish/lite/inject.py)** - The lite injector, which
+    is more conservative with features and reflection than the core injector. The codebase's
+    [MiniGuice](https://github.com/google/guice/commit/70248eafa90cd70a68b293763e53f6aec656e73c).
+  - **[lite/marshal.py](https://github.com/wrmsr/omlish/blob/master/omlish/lite/marshal.py)** - The lite marshalling
+    system, which is a classic canned setup of simple type-specific 2-method classes and limited generic handling.
+
+# Lite code
+
+A subset of this codebase is written in a 'lite' style (non-'lite' code is referred to as *standard* code). While
+standard code is written for python 3.13+, 'lite' code is written for 3.8+, and is written in a style conducive to
+[amalgamation](https://github.com/wrmsr/omlish/blob/master/omdev#amalgamation) in which multiple python source files are
+stitched together into one single self-contained python script.
+
+Code written in this style has notable differences from standard code, including (but not limited to):
+
+- No name mangling is done in amalgamation, which means (among other things) that code must be written expecting to be
+  all dumped into the same giant namespace. Where a standard class might be
+  [`omlish.inject.keys.Key`](https://github.com/wrmsr/omlish/blob/master/omlish/inject/keys.py), a lite equivalent might
+  be [`omlish.lite.inject.InjectorKey`](https://github.com/wrmsr/omlish/blob/master/omlish/lite/inject.py).
+- All internal imports `import` each individual item out of modules rather than importing the modules and referencing
+  their contents. Where standard code would `from .. import x; x.y`, lite code would `from ..x import y; y`. As a result
+  there are frequently 'api' non-instantiated namespace classes serving the purpose of modules - just handy bags of
+  stuff with shortened names.
+- As lite code is tested in 3.8+ but core code requires 3.13+, packages containing lite code can't import anything
+  standard in their (and their ancestors') `__init__.py`'s. Furthermore, `__init__.py` files are omitted outright in
+  amalgamation, so they effectively must be empty in any package containing any lite code. As a result there are
+  frequently [`all.py`](https://github.com/wrmsr/omlish/blob/master/omlish/configs/all.py) files in mixed-lite packages
+  which serve the purpose of `__init__.py` for standard usage - where importing standard packages from standard code
+  would be done via `from .. import lang`, importing mixed-lite packages from standard code would be done via
+  `from ..configs import all as cfgs`.
+
+# Dependencies
+
+This library has no required dependencies of any kind, but there are some optional integrations - see
+[`__about__.py`](https://github.com/wrmsr/omlish/blob/master/omlish/__about__.py) for a full list, but some specific
+examples are:
+
+- **asttokens / executing** - For getting runtime source representations of function call arguments, an optional
+  capability of [check](https://github.com/wrmsr/omlish/blob/master/omlish/check.py).
+- **anyio** - While lite code must use only asyncio, non-trivial async standard code prefers to be written to anyio.
+- **pytest** - What is used for all standard testing - as lite code has no dependencies of any kind its testing uses
+  stdlib's [unittest](https://docs.python.org/3/library/unittest.html).
+- **sqlalchemy** - The codebase has migrated away from SQLAlchemy in favor of the internal api but it retains it as an
+  optional dep to support adapting the internal api to it.
+
+Additionally, some catchall dep categories include:
+
+- **compression** - Various preferred compression backends like lz4, python-snappy, zstandard, and brotli.
+- **formats** - Various preferred data format backends like orjson/ujson, pyyaml, cbor2, and cloudpickle.
+- **sql drivers** - Various preferred and tested sql drivers.

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev447'
-__revision__ = 'b7728880793e311f2b0080bb2b0ad2508b86e7b3'
+__version__ = '0.0.0.dev493'
+__revision__ = 'def7f860da290b32214a8db616442d7d9759fb58'
 
 
 #
@@ -36,12 +36,12 @@ class Project(ProjectBase):
 
     optional_dependencies = {
         'async': [
-            'anyio ~= 4.10',
+            'anyio ~= 4.11',
             'sniffio ~= 1.3',
 
-            'greenlet ~= 3.2',
+            'greenlet ~= 3.3',
 
-            'trio ~= 0.31',
+            'trio ~= 0.32',
             'trio-asyncio ~= 0.15',
         ],
 
@@ -53,7 +53,7 @@ class Project(ProjectBase):
 
             'zstandard ~= 0.25; python_version < "3.14"',
 
-            'brotli ~= 1.1',
+            'brotli ~= 1.2',
         ],
 
         'diag': [
@@ -79,11 +79,11 @@ class Project(ProjectBase):
         ],
 
         'misc': [
-            'wrapt ~= 1.17',
+            'wrapt ~= 2.0',
         ],
 
         'secrets': [
-            'cryptography ~= 45.0',
+            'cryptography ~= 46.0',
         ],
 
         'sqlalchemy': [
@@ -92,18 +92,18 @@ class Project(ProjectBase):
 
         'sqldrivers': [
             'pg8000 ~= 1.31',
-            # 'psycopg2 ~= 2.9',
+            # 'psycopg2 ~= 3.3',
             # 'psycopg ~= 3.2',
 
             'pymysql ~= 1.1',
-            # 'mysql-connector-python ~= 9.3',
+            # 'mysql-connector-python ~= 9.5',
             # 'mysqlclient ~= 2.2',
 
-            'aiomysql ~= 0.2',
-            'aiosqlite ~= 0.21',
-            'asyncpg ~= 0.30',
+            'aiomysql ~= 0.3',
+            'aiosqlite ~= 0.22',
+            'asyncpg ~= 0.31',
 
-            'apsw ~= 3.50',
+            'apsw ~= 3.51',
 
             'sqlean.py ~= 3.50',
 
@@ -117,7 +117,7 @@ class Project(ProjectBase):
         ],
 
         'testing': [
-            'pytest ~= 8.4',
+            'pytest ~= 9.0',
         ],
     }
 
@@ -178,14 +178,19 @@ class SetuptoolsBase:
 
             '.omlish-manifests.json',
 
+            'README',
+            'README.md',
+
             'LICENSE',
             'LICENSE.txt',
+
+            'AUTHORS',
         ],
     }
 
 
 class Setuptools(SetuptoolsBase):
-    cexts = True
+    cext = True
 
     find_packages = {
         'include': [Project.name, f'{Project.name}.*'],

omlish/argparse/all.py

@@ -1,17 +1,25 @@
 # ruff: noqa: I001
 import argparse
 
-from .cli import (  # noqa
-    ArgparseArg as Arg,
-    argparse_arg as arg,
-    argparse_arg_ as arg_,
+from .. import lang as _lang
 
-    ArgparseCmdFn as CmdFn,
-    ArgparseCmd as Cmd,
-    argparse_cmd as cmd,
 
-    ArgparseCli as Cli,
-)
+with _lang.auto_proxy_init(globals()):
+    from .cli import (  # noqa
+        ArgparseArg as Arg,
+        argparse_arg as arg,
+        argparse_arg_ as arg_,
+
+        ArgparseCmdFn as CmdFn,
+        ArgparseCmd as Cmd,
+        argparse_cmd as cmd,
+
+        ArgparseCli as Cli,
+    )
+
+    from .utils import (  # noqa
+        NoExitArgumentParser,
+    )
 
 
 ##

omlish/argparse/cli.py

@@ -10,6 +10,7 @@ TODO:
  - pre-run, post-run hooks
  - exitstack?
  - suggestion - difflib.get_close_matches
+ - add_argument_group - group kw on ArgparseKwarg?
 """
 import argparse
 import dataclasses as dc
@@ -36,6 +37,7 @@ ArgparseCmdFn = ta.Callable[[], ta.Optional[int]]  # ta.TypeAlias
 class ArgparseArg:
     args: ta.Sequence[ta.Any]
     kwargs: ta.Mapping[str, ta.Any]
+    group: ta.Optional[str] = None
     dest: ta.Optional[str] = None
 
     def __get__(self, instance, owner=None):
@@ -45,7 +47,11 @@ class ArgparseArg:
 
 
 def argparse_arg(*args, **kwargs) -> ArgparseArg:
-    return ArgparseArg(args, kwargs)
+    return ArgparseArg(
+        args=args,
+        group=kwargs.pop('group', None),
+        kwargs=kwargs,
+    )
 
 
 def argparse_arg_(*args, **kwargs) -> ta.Any:
@@ -215,6 +221,10 @@ class ArgparseCli:
                     subparser.set_defaults(_cmd=obj)
 
             elif isinstance(obj, ArgparseArg):
+                if obj.group is not None:
+                    # FIXME: add_argument_group
+                    raise NotImplementedError
+
                 if att in anns:
                     ann_kwargs = _get_argparse_arg_ann_kwargs(anns[att])
                     obj.kwargs = {**ann_kwargs, **obj.kwargs}
@@ -260,7 +270,7 @@ class ArgparseCli:
 
         if self._unknown_args and not (cmd is not None and cmd.accepts_unknown):
             msg = f'unrecognized arguments: {" ".join(self._unknown_args)}'
-            if (parser := self.get_parser()).exit_on_error:
+            if (parser := self.get_parser()).exit_on_error:  # noqa
                 parser.error(msg)
             else:
                 raise argparse.ArgumentError(None, msg)
@@ -280,7 +290,10 @@ class ArgparseCli:
         return fn()
 
     def cli_run_and_exit(self) -> ta.NoReturn:
-        sys.exit(rc if isinstance(rc := self.cli_run(), int) else 0)
+        rc = self.cli_run()
+        if not isinstance(rc, int):
+            rc = 0
+        raise SystemExit(rc)
 
     def __call__(self, *, exit: bool = False) -> ta.Optional[int]:  # noqa
         if exit:

omlish/argparse/utils.py

@@ -0,0 +1,21 @@
+import argparse
+import typing as ta
+
+
+##
+
+
+class NoExitArgumentParser(argparse.ArgumentParser):
+    def __init__(
+            self,
+            *args: ta.Any,
+            exit_on_error: bool = False,
+            **kwargs: ta.Any,
+    ) -> None:
+        if exit_on_error:
+            raise TypeError('exit_on_error=True not supported')
+
+        super().__init__(*args, exit_on_error=False, **kwargs)  # type: ignore[misc]
+
+    def exit(self, status=0, message=None):
+        raise TypeError('NoExitArgumentParser.exit() not supported')

omlish/asyncs/asyncio/rlock.py

@@ -0,0 +1,110 @@
+# MIT License
+#
+# Copyright (c) 2023 Joshua George Albert
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# https://github.com/Joshuaalbert/FairAsyncRLock/blob/7c3ed4e08892638dba262eaf0b1a7b1fad4b2608/fair_async_rlock/fair_async_rlock.py
+import asyncio
+import collections
+import typing as ta
+
+
+##
+
+
+class AsyncioRLock:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._owner: asyncio.Task | None = None
+        self._count = 0
+        self._owner_transfer = False
+        self._queue: collections.deque[asyncio.Event] = collections.deque()
+
+    def is_owner(self, task: asyncio.Task | None = None) -> bool:
+        if task is None:
+            task = asyncio.current_task()
+        return self._owner == task
+
+    def is_locked(self) -> bool:
+        return self._owner is not None
+
+    async def acquire(self) -> None:
+        me = asyncio.current_task()
+
+        # If the lock is reentrant, acquire it immediately
+        if self.is_owner(task=me):
+            self._count += 1
+            return
+
+        # If the lock is free (and ownership not in midst of transfer), acquire it immediately
+        if not self._count and not self._owner_transfer:
+            self._owner = me
+            self._count = 1
+            return
+
+        # Create an event for this task, to notify when it's ready for acquire
+        event = asyncio.Event()
+        self._queue.append(event)
+
+        # Wait for the lock to be free, then acquire
+        try:
+            await event.wait()
+            self._owner_transfer = False
+            self._owner = me
+            self._count = 1
+
+        except asyncio.CancelledError:
+            try:  # if in queue, then cancelled before release
+                self._queue.remove(event)
+
+            except ValueError:  # otherwise, release happened, this was next, and we simulate passing on
+                self._owner_transfer = False
+                self._owner = me
+                self._count = 1
+                self._current_task_release()
+
+            raise
+
+    def _current_task_release(self) -> None:
+        self._count -= 1
+        if not self._count:
+            self._owner = None
+
+            if self._queue:
+                # Wake up the next task in the queue
+                event = self._queue.popleft()
+                event.set()
+
+                # Setting this here prevents another task getting lock until owner transfer.
+                self._owner_transfer = True
+
+    def release(self) -> None:
+        me = asyncio.current_task()
+
+        if self._owner is None:
+            raise RuntimeError(f'Cannot release un-acquired lock. {me} tried to release.')
+
+        if not self.is_owner(task=me):
+            raise RuntimeError(f'Cannot release foreign lock. {me} tried to unlock {self._owner}.')
+
+        self._current_task_release()
+
+    async def __aenter__(self) -> ta.Self:
+        await self.acquire()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        self.release()

omlish/asyncs/asyncio/sync.py

@@ -0,0 +1,43 @@
+# ruff: noqa: UP045
+# @omlish-lite
+import asyncio
+import typing as ta
+
+from ...sync import SyncBufferRelay
+from ..sync import AsyncBufferRelay
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@ta.final
+class AsyncioBufferRelay(AsyncBufferRelay[T]):
+    def __init__(
+            self,
+            *,
+            event: ta.Optional[asyncio.Event] = None,
+            loop: ta.Optional[ta.Any] = None,
+    ) -> None:
+        if event is None:
+            event = asyncio.Event()
+        self._event = event
+        if loop is None:
+            loop = asyncio.get_running_loop()
+        self._loop = loop
+
+        self._relay: SyncBufferRelay[T] = SyncBufferRelay(
+            wake_fn=lambda: loop.call_soon_threadsafe(event.set),  # type: ignore[arg-type]
+        )
+
+    def push(self, *vs: T) -> None:
+        self._relay.push(*vs)
+
+    def swap(self) -> ta.Sequence[T]:
+        return self._relay.swap()
+
+    async def wait(self) -> None:
+        await self._event.wait()
+        self._event.clear()

omlish/asyncs/asyncio/utils.py

@@ -76,6 +76,8 @@ async def asyncio_wait_concurrent(
     if isinstance(concurrency, asyncio.Semaphore):
         semaphore = concurrency
     elif isinstance(concurrency, int):
+        if concurrency < 1:
+            raise ValueError(f'Concurrency must be >= 1, got {concurrency}')
         semaphore = asyncio.Semaphore(concurrency)
     else:
         raise TypeError(concurrency)

omlish/asyncs/sync.py

@@ -0,0 +1,25 @@
+# @omlish-lite
+import abc
+import typing as ta
+
+from ..lite.abstract import Abstract
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class AsyncBufferRelay(Abstract, ta.Generic[T]):
+    @abc.abstractmethod
+    def push(self, *vs: T) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def swap(self) -> ta.Sequence[T]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def wait(self) -> None:
+        raise NotImplementedError

omlish/bootstrap/_marshal.py

@@ -8,7 +8,7 @@ from .harness import BOOTSTRAP_TYPES_BY_NAME
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     cfgs_poly = msh.Polymorphism(
         Bootstrap.Config,
         [msh.Impl(b.Config, n) for n, b in BOOTSTRAP_TYPES_BY_NAME.items()],