omlish 0.0.0.dev447__py3-none-any.whl → 0.0.0.dev484__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/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev447'
-__revision__ = 'b7728880793e311f2b0080bb2b0ad2508b86e7b3'
+__version__ = '0.0.0.dev484'
+__revision__ = '7c8d11bd7ee674238104cc5940ee4971dbf70a29'
 
 
 #
@@ -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',
+            'aiomysql ~= 0.3',
             'aiosqlite ~= 0.21',
-            'asyncpg ~= 0.30',
+            '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',
         ],
     }
 
@@ -185,7 +185,7 @@ class SetuptoolsBase:
 
 
 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()],

omlish/bootstrap/diag.py

@@ -13,23 +13,14 @@ from .base import ContextBootstrap
 from .base import SimpleBootstrap
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     import cProfile  # noqa
     import pstats
 
-    from ..diag import debug as ddbg
-    from ..diag import pycharm as diagpc
-    from ..diag import replserver as diagrs
-    from ..diag import threads as diagt
-
-else:
-    cProfile = lang.proxy_import('cProfile')  # noqa
-    pstats = lang.proxy_import('pstats')
-
-    ddbg = lang.proxy_import('..diag.debug', __package__)
-    diagpc = lang.proxy_import('..diag.pycharm', __package__)
-    diagrs = lang.proxy_import('..diag.replserver', __package__)
-    diagt = lang.proxy_import('..diag.threads', __package__)
+    from ..diag import debug as d_debug
+    from ..diag import pycharm as d_pycharm
+    from ..diag import replserver
+    from ..diag import threads as d_threads
 
 
 ##
@@ -110,7 +101,7 @@ class ThreadDumpBootstrap(ContextBootstrap['ThreadDumpBootstrap.Config']):
     @contextlib.contextmanager
     def enter(self) -> ta.Iterator[None]:
         if self._config.interval_s:
-            tdt = diagt.create_thread_dump_thread(
+            tdt = d_threads.create_thread_dump_thread(
                 interval_s=self._config.interval_s,
                 start=True,
                 nodaemon=self._config.nodaemon,
@@ -119,7 +110,7 @@ class ThreadDumpBootstrap(ContextBootstrap['ThreadDumpBootstrap.Config']):
             tdt = None
 
         if self._config.on_sigquit:
-            dump_threads_str = diagt.dump_threads_str
+            dump_threads_str = d_threads.dump_threads_str
 
             def handler(signum, frame):
                 print(dump_threads_str(), file=sys.stderr)
@@ -153,7 +144,7 @@ class TimebombBootstrap(ContextBootstrap['TimebombBootstrap.Config']):
             yield
             return
 
-        tbt = diagt.create_timebomb_thread(
+        tbt = d_threads.create_timebomb_thread(
             self._config.delay_s,
             start=True,
         )
@@ -173,8 +164,8 @@ class PycharmBootstrap(SimpleBootstrap['PycharmBootstrap.Config']):
 
     def run(self) -> None:
         if self._config.debug is not None:
-            prd = diagpc.PycharmRemoteDebugger.parse(self._config.debug)
-            diagpc.pycharm_remote_debugger_attach(prd)
+            prd = d_pycharm.PycharmRemoteDebugger.parse(self._config.debug)
+            d_pycharm.pycharm_remote_debugger_attach(prd)
 
 
 ##
@@ -190,7 +181,7 @@ class ReplServerBootstrap(ContextBootstrap['ReplServerBootstrap.Config']):
         if self._config.path is None:
             return
 
-        with diagrs.ReplServer(diagrs.ReplServer.Config(
+        with replserver.ReplServer(replserver.ReplServer.Config(
             path=self._config.path,
         )) as rs:
             thread = threading.Thread(target=rs.run, name='replserver')
@@ -212,5 +203,5 @@ class DebugBootstrap(ContextBootstrap['DebugBootstrap.Config']):
         if not self._config.enable:
             return
 
-        with ddbg.debugging_on_exception():
+        with d_debug.debugging_on_exception():
             yield

omlish/bootstrap/main.py

@@ -1,9 +1,9 @@
+# ruff: noqa: UP006 UP007 UP045
 """
 TODO:
  - -x / --exec - os.exec entrypoint
  - refuse to install non-exec-relevant Bootstraps when chosen
 """
-# ruff: noqa: UP006 UP007 UP045
 import argparse
 import dataclasses as dc
 import io
@@ -19,12 +19,9 @@ from .harness import BOOTSTRAP_TYPES_BY_NAME
 from .harness import bootstrap
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     import runpy
 
-else:
-    runpy = lang.proxy_import('runpy')
-
 
 ##
 

omlish/bootstrap/sys.py

@@ -2,14 +2,10 @@
 import contextlib
 import dataclasses as dc
 import enum
-import faulthandler
 import gc
 import importlib
 import logging
 import os
-import pwd
-import resource
-import signal
 import sys
 import typing as ta
 
@@ -19,18 +15,17 @@ from .base import ContextBootstrap
 from .base import SimpleBootstrap
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
+    import faulthandler
+    import pwd
+    import resource
+    import signal
+
     from .. import libc
     from ..formats import dotenv
     from ..logs import all as logs
     from ..os.pidfiles import pidfile
 
-else:
-    libc = lang.proxy_import('..libc', __package__)
-    logs = lang.proxy_import('..logs', __package__)
-    dotenv = lang.proxy_import('..formats.dotenv', __package__)
-    pidfile = lang.proxy_import('..os.pidfiles.pidfile', __package__)
-
 
 ##
 
@@ -184,14 +179,16 @@ class FaulthandlerBootstrap(ContextBootstrap['FaulthandlerBootstrap.Config']):
 ##
 
 
-SIGNALS_BY_NAME = {
-    a[len('SIG'):]: v  # noqa
-    for a in dir(signal)
-    if a.startswith('SIG')
-    and not a.startswith('SIG_')
-    and a == a.upper()
-    and isinstance((v := getattr(signal, a)), int)
-}
+@lang.cached_function
+def signals_by_name() -> ta.Mapping[str, int]:
+    return {
+        a[len('SIG'):]: v  # noqa
+        for a in dir(signal)
+        if a.startswith('SIG')
+        and not a.startswith('SIG_')
+        and a == a.upper()
+        and isinstance((v := getattr(signal, a)), int)
+    }
 
 
 class PrctlBootstrap(SimpleBootstrap['PrctlBootstrap.Config']):
@@ -208,20 +205,22 @@ class PrctlBootstrap(SimpleBootstrap['PrctlBootstrap.Config']):
             if isinstance(self._config.deathsig, int):
                 sig = self._config.deathsig
             else:
-                sig = SIGNALS_BY_NAME[self._config.deathsig.upper()]
+                sig = signals_by_name()[self._config.deathsig.upper()]
             libc.prctl(libc.PR_SET_PDEATHSIG, sig, 0, 0, 0, 0)
 
 
 ##
 
 
-RLIMITS_BY_NAME = {
-    a[len('RLIMIT_'):]: v  # noqa
-    for a in dir(resource)
-    if a.startswith('RLIMIT_')
-    and a == a.upper()
-    and isinstance((v := getattr(resource, a)), int)
-}
+@lang.cached_function
+def rlimits_by_name() -> ta.Mapping[str, int]:
+    return {
+        a[len('RLIMIT_'):]: v  # noqa
+        for a in dir(resource)
+        if a.startswith('RLIMIT_')
+        and a == a.upper()
+        and isinstance((v := getattr(resource, a)), int)
+    }
 
 
 class RlimitBootstrap(ContextBootstrap['RlimitBootstrap.Config']):
@@ -240,7 +239,7 @@ class RlimitBootstrap(ContextBootstrap['RlimitBootstrap.Config']):
 
         prev = {}
         for k, (s, h) in self._config.limits.items():
-            i = RLIMITS_BY_NAME[k.upper()]
+            i = rlimits_by_name()[k.upper()]
             prev[i] = resource.getrlimit(i)
             resource.setrlimit(i, (or_infin(s), or_infin(h)))
 

omlish/cexts/include/omlish/omlish.hh

@@ -0,0 +1 @@
+#pragma once

omlish/collections/__init__.py

@@ -6,12 +6,21 @@ from .. import lang as _lang
 with _lang.auto_proxy_init(globals()):
     ##
 
+    from .attrregistry import (  # noqa
+        AttrRegistry,
+
+        AttrRegistryCache,
+        SimpleAttrRegistryCache,
+    )
+
     from .bimap import (  # noqa
         BiMap,
 
         make_bi_map,
     )
 
+    from . import cache  # noqa
+
     from .coerce import (  # noqa
         abs_set,
         abs_set_of,
@@ -64,9 +73,10 @@ with _lang.auto_proxy_init(globals()):
     from . import kv  # noqa
 
     from .mappings import (  # noqa
+        DynamicTypeMap,
         MissingDict,
         TypeMap,
-        DynamicTypeMap,
+        dict_factory,
         guarded_map_update,
         multikey_dict,
     )
@@ -145,6 +155,8 @@ with _lang.auto_proxy_init(globals()):
         key_cmp,
         make_map,
         make_map_by,
+        map_keys,
+        map_values,
         multi_map,
         multi_map_by,
         partition,