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

omlish/term.py

@@ -20,7 +20,7 @@ def set_title(title: str) -> str:
 
 
 def strip_ansi_codes(s: str) -> str:
-    return re.sub(r'\033\\[([0-9]+)(;[0-9]+)*m', '', s)
+    return re.sub(r'\033\[([0-9]+)(;[0-9]+)*m', '', s)
 
 
 class ControlSequence:
@@ -90,7 +90,7 @@ HIDE_CURSOR = ControlSequence(lambda: CSI + '?25l', 'Hide Cursor')
 SGR = ControlSequence(lambda n: CSI + _str_val(n) + 'm', 'Select Graphic Rendition')
 
 
-class SGRs(lang.Namespace):
+class SGRs(lang.Namespace, lang.Final):
     RESET = 0
     NORMAL_COLOR_AND_INTENSITY = 22
 

omlish/testing/pytest/__init__.py

@@ -1,5 +1,3 @@
-from . import plugins  # noqa
-
 from .helpers import (  # noqa
     assert_raises_star,
 )
@@ -11,3 +9,6 @@ from .marks import (  # noqa
     skip_if_not_on_path,
     skip_if_python_version_less_than,
 )
+
+# Imported for convenience in things that import this but not lang.
+from ...lang import breakpoint_on_exception  # noqa

omlish/testing/pytest/inject/harness.py

@@ -24,7 +24,7 @@ class PytestScope(enum.Enum):
     FUNCTION = enum.auto()
 
 
-class Scopes(lang.Namespace):
+class Scopes(lang.Namespace, lang.Final):
     Session = inj.SeededScope(PytestScope.SESSION)
     Package = inj.SeededScope(PytestScope.PACKAGE)
     Module = inj.SeededScope(PytestScope.MODULE)
@@ -50,7 +50,7 @@ class Harness:
         super().__init__()
         self._orig_es = es
         self._es = inj.as_elements(
-            inj.as_binding(self),
+            inj.bind(self),
             *[
                 inj.as_elements(
                     inj.bind_scope(ss),
@@ -169,7 +169,7 @@ def bind(
         pts = scope if isinstance(scope, PytestScope) else PytestScope[check.isinstance(scope, str).upper()]
         check.isinstance(cls, type)
         register(inj.as_elements(
-            inj.in_(cls, _SCOPES_BY_PYTEST_SCOPE[pts]),
+            inj.bind(cls, in_=_SCOPES_BY_PYTEST_SCOPE[pts]),
         ))
         return cls
     return inner

omlish/testing/pytest/marks.py

@@ -11,9 +11,10 @@ from .plugins.managermarks import ManagerMark  # noqa
 
 
 if ta.TYPE_CHECKING:
-    import asyncio
+    from ...asyncs import asyncio as aiu
+
 else:
-    asyncio = lang.proxy_import('asyncio')
+    aiu = lang.proxy_import('...asyncs.asyncio', __package__)
 
 
 def skip_if_cant_import(module: str, *args, **kwargs):
@@ -40,9 +41,5 @@ def skip_if_nogil():
 
 class drain_asyncio(ManagerMark):  # noqa
     def __call__(self, item: pytest.Function) -> ta.Iterator[None]:
-        loop = asyncio.get_event_loop()
-        try:
+        with aiu.draining_asyncio_tasks():
             yield
-        finally:
-            while loop._ready or loop._scheduled:  # type: ignore  # noqa
-                loop._run_once()  # type: ignore  # noqa

omlish/testing/pytest/plugins/__init__.py

@@ -1,4 +1,5 @@
 from . import (  # noqa
+    asyncs,
     logging,
     managermarks,
     pydevd,

omlish/testing/pytest/plugins/asyncs.py

@@ -0,0 +1,136 @@
+"""
+TODO:
+ - auto drain_asyncio
+
+==
+
+_pytest:
+https://github.com/pytest-dev/pytest/blob/ef9b8f9d748b6f50eab5d43e32d93008f7880899/src/_pytest/python.py#L155
+"async def function and no async plugin installed (see warnings)"
+
+pytest_trio:
+https://github.com/python-trio/pytest-trio/blob/f03160aa1dd355a12d39fa21f4aee4e1239efea3/pytest_trio/plugin.py
+ - pytest_addoption
+ - pytest_configure
+ - pytest_collection_modifyitems
+ - pytest_runtest_call @(hookwrapper=True)
+ - pytest_fixture_setup
+
+pytest_asyncio:
+https://github.com/pytest-dev/pytest-asyncio/blob/f45aa18cf3eeeb94075de16a1d797858facab863/pytest_asyncio/plugin.py
+ - pytest_addoption
+ - pytest_configure
+ - pytest_pycollect_makeitem_preprocess_async_fixtures @(specname="pytest_pycollect_makeitem", tryfirst=True)
+ - pytest_pycollect_makeitem_convert_async_functions_to_subclass @(specname="pytest_pycollect_makeitem", hookwrapper=True)
+ - pytest_generate_tests @(tryfirst=True)
+ - pytest_runtest_setup(item: pytest.Item) -> None:
+ - pytest_pyfunc_call @(tryfirst=True, hookwrapper=True)
+ - pytest_collectstart @()
+ - pytest_report_header @(tryfirst=True)
+ - pytest_fixture_setup @(hookwrapper=True)
+
+anyio.pytest_plugin:
+https://github.com/agronholm/anyio/blob/8907964926a24461840eee0925d3f355e729f15d/src/anyio/pytest_plugin.py
+ - pytest_configure
+ - pytest_pycollect_makeitem @(tryfirst=True)
+ - pytest_pyfunc_call @(tryfirst=True)
+ - pytest_fixture_setup
+
+"""  # noqa
+import functools
+import inspect
+import typing as ta
+
+import pytest
+
+from .... import lang
+from ....asyncs import trio_asyncio as trai
+from ....diag import pydevd as pdu
+from ._registry import register
+
+
+if ta.TYPE_CHECKING:
+    import trio_asyncio
+else:
+    trio_asyncio = lang.proxy_import('trio_asyncio')
+
+
+ASYNCS_MARK = 'asyncs'
+
+KNOWN_BACKENDS = (
+    'asyncio',
+    'trio',
+    'trio_asyncio',
+)
+
+PARAM_NAME = '__async_backend'
+
+
+def iscoroutinefunction(func: ta.Any) -> bool:
+    return inspect.iscoroutinefunction(func) or getattr(func, '_is_coroutine', False)
+
+
+def is_async_function(func: ta.Any) -> bool:
+    return iscoroutinefunction(func) or inspect.isasyncgenfunction(func)
+
+
+@register
+class AsyncsPlugin:
+    ASYNC_BACKENDS: ta.ClassVar[ta.Sequence[str]] = [
+        *[s for s in KNOWN_BACKENDS if lang.can_import(s)],
+    ]
+
+    def pytest_configure(self, config):
+        config.addinivalue_line('markers', f'{ASYNCS_MARK}: marks for all async backends')
+        config.addinivalue_line('markers', 'trio_asyncio: marks for trio_asyncio backend')
+
+    def pytest_generate_tests(self, metafunc):
+        if (m := metafunc.definition.get_closest_marker(ASYNCS_MARK)) is not None:
+            if m.args:
+                bes = m.args
+            else:
+                bes = self.ASYNC_BACKENDS
+        elif metafunc.definition.get_closest_marker('trio_asyncio') is not None:
+            bes = ['trio_asyncio']
+        else:
+            return
+
+        if pdu.is_present():
+            pdu.patch_for_trio_asyncio()
+
+        metafunc.fixturenames.append(PARAM_NAME)
+        metafunc.parametrize(PARAM_NAME, bes)
+
+        for c in metafunc._calls:  # noqa
+            be = c.params[PARAM_NAME]
+            if be == 'trio_asyncio':
+                c.marks.extend([
+                    pytest.mark.trio.mark,
+                    pytest.mark.trio_asyncio.mark,
+                ])
+
+            else:
+                c.marks.append(getattr(pytest.mark, be).mark)
+
+            if pdu.is_present():
+                c.marks.append(pytest.mark.drain_asyncio.mark)
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_call(self, item):
+        bes = [be for be in self.ASYNC_BACKENDS if item.get_closest_marker(be) is not None]
+        if len(bes) > 1 and set(bes) != {'trio', 'trio_asyncio'}:
+            raise Exception(f'{item.nodeid}: multiple async backends specified: {bes}')
+        elif is_async_function(item.obj) and not bes:
+            raise Exception(f'{item.nodeid}: async def function and no async plugin specified')
+
+        if 'trio_asyncio' in bes:
+            obj = item.obj
+
+            @functools.wraps(obj)
+            @trai.with_trio_asyncio_loop(wait=True)
+            async def run(*args, **kwargs):
+                await trio_asyncio.aio_as_trio(obj)(*args, **kwargs)
+
+            item.obj = run
+
+        yield

omlish/testing/pytest/plugins/pydevd.py

@@ -1,4 +1,4 @@
-from ... import pydevd as opd
+from ....diag import pydevd as opd
 from ._registry import register
 
 

omlish/testing/pytest/plugins/switches.py

@@ -16,10 +16,21 @@ from ._registry import register
 Configable = pytest.FixtureRequest | pytest.Config
 
 
-SWITCHES = col.OrderedSet([
-    'online',
-    'slow',
-])
+SWITCHES = {
+    'docker': True,
+    'online': True,
+    'integration': True,
+    'slow': False,
+}
+
+
+SwitchState: ta.TypeAlias = bool | ta.Literal['only']
+
+SWITCH_STATE_OPT_PREFIXES: ta.Mapping[SwitchState, str] = {
+    True: '--',
+    False: '--no-',
+    'only': '--only-',
+}
 
 
 def _get_obj_config(obj: Configable) -> pytest.Config:
@@ -42,29 +53,53 @@ def skip_if_disabled(obj: Configable | None, name: str) -> None:
         pytest.skip(f'{name} disabled')
 
 
-def get_switches(obj: Configable) -> ta.Mapping[str, bool]:
-    return {
-        sw: _get_obj_config(obj).getoption(f'--no-{sw}')
-        for sw in SWITCHES
-    }
+def get_switches(obj: Configable) -> ta.Mapping[str, SwitchState]:
+    ret: dict[str, SwitchState] = {}
+    for sw, d in SWITCHES.items():
+        sts = {
+            st
+            for st, pfx in SWITCH_STATE_OPT_PREFIXES.items()
+            if _get_obj_config(obj).getoption(pfx + sw)
+        }
+        if sts:
+            if len(sts) > 1:
+                raise Exception(f'Multiple switches specified for {sw}')
+            ret[sw] = check.single(sts)
+        else:
+            ret[sw] = d
+    return ret
 
 
 @register
 class SwitchesPlugin:
 
+    def pytest_configure(self, config):
+        for sw in SWITCHES:
+            config.addinivalue_line('markers', f'{sw}: mark test as {sw}')
+
     def pytest_addoption(self, parser):
         for sw in SWITCHES:
             parser.addoption(f'--no-{sw}', action='store_true', default=False, help=f'disable {sw} tests')
+            parser.addoption(f'--{sw}', action='store_true', default=False, help=f'enables {sw} tests')
+            parser.addoption(f'--only-{sw}', action='store_true', default=False, help=f'enables only {sw} tests')
 
     def pytest_collection_modifyitems(self, config, items):
-        for sw in SWITCHES:
-            if not config.getoption(f'--no-{sw}'):
-                continue
-            skip = pytest.mark.skip(reason=f'omit --no-{sw} to run')
-            for item in items:
-                if sw in item.keywords:
-                    item.add_marker(skip)
+        sts = get_switches(config)
+        stx = col.multi_map(map(reversed, sts.items()))  # type: ignore
+        ts, fs, onlys = (stx.get(k, ()) for k in (True, False, 'only'))
 
-    def pytest_configure(self, config):
-        for sw in SWITCHES:
-            config.addinivalue_line('markers', f'{sw}: mark test as {sw}')
+        def process(item):
+            sws = {sw for sw in SWITCHES if sw in item.keywords}
+
+            if onlys:
+                if not any(sw in onlys for sw in sws):
+                    item.add_marker(pytest.mark.skip(reason=f'skipping switches {sws}'))
+                    return
+
+            else:
+                for sw in sws:
+                    if sw in fs:
+                        item.add_marker(pytest.mark.skip(reason=f'skipping switches {sw}'))
+
+        for item in items:
+            process(item)

omlish/text/glyphsplit.py

@@ -0,0 +1,97 @@
+"""
+Note: string.Formatter (and string.Template) shouldn't be ignored - if they can be used they probably should be.
+ - https://docs.python.org/3/library/string.html#custom-string-formatting
+ - https://docs.python.org/3/library/string.html#template-strings
+"""
+import dataclasses as dc
+import re
+
+from .. import check
+
+
+@dc.dataclass(frozen=True)
+class GlyphMatch:
+    l: str
+    s: str
+    r: str
+
+
+class GlyphSplitter:
+
+    def __init__(
+            self,
+            glyphs: tuple[str, str],
+            *,
+            escape_returned_doubles: bool = False,
+            compact: bool = False,
+    ) -> None:
+        super().__init__()
+
+        glyphs = tuple(map(check.of_isinstance(str), glyphs))  # type: ignore
+        check.state(all(len(s) == 1 for s in glyphs))
+        check.state(len(glyphs) == 2)
+
+        self._glyphs = glyphs
+        self._l_glyph, self._r_glyph = glyphs
+
+        self._escape_returned_doubles = escape_returned_doubles
+        self._compact = compact
+
+        self._l_double_glyph = self._l_glyph * 2
+        self._r_double_glyph = self._r_glyph * 2
+        self._double_glyphs = (self._l_double_glyph, self._r_double_glyph)
+
+        self._l_escaped_glyph = re.escape(self._l_glyph)
+        self._r_escaped_glyph = re.escape(self._r_glyph)
+
+        self._l_glyph_pat = re.compile(r'(%s)' % (self._l_escaped_glyph * 2,))  # noqa
+        self._r_glyph_pat = re.compile(r'(%s)' % (self._r_escaped_glyph * 2,))  # noqa
+
+        self._single_glyph_pat = re.compile(r'(%s[^%s]*?%s)' % (self._l_escaped_glyph, self._r_escaped_glyph, self._r_escaped_glyph))  # noqa
+
+    def split(self, s: str) -> list[GlyphMatch | str]:
+        ps = self._l_glyph_pat.split(s)
+        ps = [p[::-1] for p in ps for p in reversed(self._r_glyph_pat.split(p[::-1]))]
+
+        ret = []  # type: ignore
+
+        def append_ret(o):
+            if self._compact and isinstance(o, str) and ret and isinstance(ret[-1], str):
+                ret[-1] = ret[-1] + o
+            else:
+                ret.append(o)
+
+        for p in ps:
+            if p in self._double_glyphs:
+                if self._escape_returned_doubles:
+                    p = self._glyphs[p == self._r_double_glyph]
+                append_ret(p)
+                continue
+
+            ms = list(self._single_glyph_pat.finditer(p))
+            if not ms:
+                append_ret(p)
+                continue
+
+            l = 0
+            for m in ms:
+                if m.start() != l:
+                    append_ret(p[l:m.start()])
+                append_ret(GlyphMatch(self._l_glyph, p[m.start() + 1:m.end() - 1], self._r_glyph))
+                l = m.end()
+
+            if l < len(p):
+                append_ret(p[l:])
+
+        return ret
+
+
+_PAREN_GLYPH_SPLITTER = GlyphSplitter(('(', ')'), escape_returned_doubles=True, compact=True)
+_BRACE_GLYPH_SPLITTER = GlyphSplitter(('{', '}'), escape_returned_doubles=True, compact=True)
+_BRACKET_GLYPH_SPLITTER = GlyphSplitter(('[', ']'), escape_returned_doubles=True, compact=True)
+_ANGLE_BRACKET_GLYPH_SPLITTER = GlyphSplitter(('<', '>'), escape_returned_doubles=True, compact=True)
+
+split_parens = _PAREN_GLYPH_SPLITTER.split
+split_braces = _BRACE_GLYPH_SPLITTER.split
+split_brackets = _BRACKET_GLYPH_SPLITTER.split
+split_angle_brackets = _ANGLE_BRACKET_GLYPH_SPLITTER.split

omlish-0.0.0.dev7.dist-info/METADATA

@@ -0,0 +1,50 @@
+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: trio >=0.26 ; extra == 'async'
+Requires-Dist: greenlet >=3 ; (python_version < "3.13") and 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: zstd >=1.5 ; extra == 'compression'
+Requires-Dist: python-snappy >=0.7 ; (python_version < "3.13") and 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: 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: sqlalchemy[asyncio] >=2 ; (python_version < "3.13") and extra == 'sql'
+Requires-Dist: asyncpg >=0.29 ; (python_version < "3.13") and extra == 'sql'
+Requires-Dist: sqlalchemy >=2 ; (python_version >= "3.13") and extra == 'sql'
+Provides-Extra: sqlx
+Requires-Dist: duckdb >=1 ; extra == 'sqlx'
+Requires-Dist: sqlean.py >=3.45 ; (python_version < "3.13") and extra == 'sqlx'
+Provides-Extra: testing
+Requires-Dist: pytest >=8 ; extra == 'testing'
+