omlish 0.0.0.dev1__py3-none-any.whl

omlish/term.py

@@ -0,0 +1,222 @@
+import enum
+import re
+import typing as ta
+
+from . import lang
+
+
+ESC = '\x1b'
+BEL = '\x07'
+
+DCS = ESC + 'P'
+CSI = ESC + '['
+ST = ESC + '\\'
+OSC = ESC + ']'
+RIS = ESC + 'c'
+
+
+def set_title(title: str) -> str:
+    return OSC + '0;' + title + BEL
+
+
+def strip_ansi_codes(s: str) -> str:
+    return re.sub(r'\033\\[([0-9]+)(;[0-9]+)*m', '', s)
+
+
+class ControlSequence:
+
+    def __init__(self, fn: ta.Callable[..., str], desc: str) -> None:
+        super().__init__()
+        self._fn = fn
+        self._desc = desc
+
+    @property
+    def description(self) -> str:
+        return self._desc
+
+    def __call__(self, *args, **kwargs) -> str:
+        return self._fn(*args, **kwargs)
+
+
+CUU = ControlSequence(lambda n: CSI + str(n) + 'A', 'Cursor Up')
+CUD = ControlSequence(lambda n: CSI + str(n) + 'B', 'Cursor Down')
+CUF = ControlSequence(lambda n: CSI + str(n) + 'C', 'Cursor Forward')
+CUB = ControlSequence(lambda n: CSI + str(n) + 'D', 'Cursor Back')
+
+CNL = ControlSequence(lambda n: CSI + str(n) + 'E', 'Cursor Next Line')
+CPL = ControlSequence(lambda n: CSI + str(n) + 'F', 'Cursor Previous Line')
+CHA = ControlSequence(lambda n: CSI + str(n) + 'G', 'Cursor Horizontal Line Absolute')
+
+CUP = ControlSequence(lambda n, m: CSI + str(n) + ';' + str(m) + 'H', 'Cursor Position')
+HVP = ControlSequence(lambda n, m: CSI + str(n) + ';' + str(m) + 'f', 'Horizontal Vertical Position')
+
+
+def _str_val(val: ta.Any) -> str:
+    if isinstance(val, enum.Enum):
+        return str(val.value)
+    else:
+        return str(val)
+
+
+class EDs(enum.Enum):
+    FROM_CURSOR_TO_END = 0
+    FROM_CURSOR_TO_BEGINNING = 1
+    ALL = 2
+    ALL_AND_SCROLLBACK = 3
+
+
+ED = ControlSequence(lambda n: CSI + _str_val(n) + 'J', 'Erase in Display')
+
+
+class ELs(enum.Enum):
+    FROM_CURSOR_TO_END = 0
+    FROM_CURSOR_TO_BEGINNING = 1
+    ALL = 2
+
+
+EL = ControlSequence(lambda n: CSI + _str_val(n) + 'K', 'Erase in Line')
+
+SU = ControlSequence(lambda n: CSI + str(n) + 'S', 'Scroll Up')
+SD = ControlSequence(lambda n: CSI + str(n) + 'T', 'Scroll Down')
+
+DSR = ControlSequence(lambda: CSI + '6n', 'Device Status Report')
+
+SCP = ControlSequence(lambda: CSI + 's', 'Save Cursor Position')
+RCP = ControlSequence(lambda: CSI + 'u', 'Restore Cursor Position')
+
+SHOW_CURSOR = ControlSequence(lambda: CSI + '?25h', 'Show Cursor')
+HIDE_CURSOR = ControlSequence(lambda: CSI + '?25l', 'Hide Cursor')
+
+SGR = ControlSequence(lambda n: CSI + _str_val(n) + 'm', 'Select Graphic Rendition')
+
+
+class SGRs(lang.Namespace):
+    RESET = 0
+    NORMAL_COLOR_AND_INTENSITY = 22
+
+    class FONT(enum.Enum):
+        BOLD = 1
+        FAINT = 2
+        ITALIC = 3
+        UNTERLINE = 4
+
+        SLOW_BLINK = 5
+        RAPID_BLINK = 6
+
+        REVERSE_VIDEO = 7
+
+        PRIMARY_FONT = 10
+        ITALIC_OFF = 23
+        UNDERLINE_OFF = 24
+        BLINK_OFF = 25
+        INVERSE_OFF = 27
+
+        FRAMED = 51
+        ENCIRCLED = 52
+        OVERLINED = 53
+        NOT_FRAMED_OR_ENCIRCLED = 54
+        NOT_OVERLINED = 55
+
+    class FG(enum.Enum):
+        BLACK = 30
+        RED = 31
+        GREEN = 32
+        YELLOW = 33
+        BLUE = 34
+        MAGENTA = 35
+        CYAN = 36
+        WHITE = 37
+
+        BRIGHT_BLACK = 90
+        BRIGHT_RED = 91
+        BRIGHT_GREEN = 92
+        BRIGHT_YELLOW = 93
+        BRIGHT_BLUE = 94
+        BRIGHT_MAGENTA = 95
+        BRIGHT_CYAN = 96
+        BRIGHT_WHITE = 97
+
+    class BG(enum.Enum):
+        BLACK = 40
+        RED = 41
+        GREEN = 42
+        YELLOW = 43
+        BLUE = 44
+        MAGENTA = 45
+        CYAN = 46
+        WHITE = 47
+
+        BRIGHT_BLACK = 100
+        BRIGHT_RED = 101
+        BRIGHT_GREEN = 102
+        BRIGHT_YELLOW = 103
+        BRIGHT_BLUE = 104
+        BRIGHT_MAGENTA = 105
+        BRIGHT_CYAN = 106
+        BRIGHT_WHITE = 107
+
+
+def _clamp_ofs(v: int, hi: int, ofs: int) -> str:
+    if v < 0 or v > hi:
+        raise ValueError(v)
+    return str(v + ofs)
+
+
+FG8 = ControlSequence(
+    lambda n: CSI + '38;5;' + str(n) + 'm',
+    '8-Bit Foreground Color')
+FG8_STANDARD = ControlSequence(
+    lambda n: CSI + '38;5;' + _clamp_ofs(n, 8, 0) + 'm',
+    '8-Bit Foreground Color (Standard)')
+FG8_HIGH_INTENSITY = ControlSequence(
+    lambda n: CSI + '38;5;' + _clamp_ofs(n, 8, 8) + 'm',
+    '8-Bit Foreground Color (High Intensity)')
+FG8_216 = ControlSequence(
+    lambda n: CSI + '38;5;' + _clamp_ofs(n, 216, 16) + 'm',
+    '8-Bit Foreground Color (High Intensity)')
+FG8_GRAYSCALE = ControlSequence(
+    lambda n: CSI + '38;5;' + _clamp_ofs(n, 24, 232) + 'm',
+    '8-Bit Foreground Color (Grayscale)')
+FG8_RGB = ControlSequence(
+    lambda r, g, b: CSI + '38;5;' + str(36 * r + 6 * g + b) + 'm',
+    '8-Bit Foreground Color (RGB)')
+
+BG8 = ControlSequence(
+    lambda n: CSI + '48;5;' + str(n) + 'm',
+    '8-Bit Background Color')
+BG8_STANDARD = ControlSequence(
+    lambda n: CSI + '48;5;' + _clamp_ofs(n, 8, 0) + 'm',
+    '8-Bit Background Color (Standard)')
+BG8_HIGH_INTENSITY = ControlSequence(
+    lambda n: CSI + '48;5;' + _clamp_ofs(n, 8, 8) + 'm',
+    '8-Bit Background Color (High Intensity)')
+BG8_216 = ControlSequence(
+    lambda n: CSI + '48;5;' + _clamp_ofs(n, 216, 16) + 'm',
+    '8-Bit Background Color (High Intensity)')
+BG8_GRAYSCALE = ControlSequence(
+    lambda n: CSI + '48;5;' + _clamp_ofs(n, 24, 232) + 'm',
+    '8-Bit Background Color (Grayscale)')
+BG8_RGB = ControlSequence(
+    lambda r, g, b: CSI + '48;5;' + str(36 * r + 6 * g + b) + 'm',
+    '8-Bit Background Color (RGB)')
+
+FG24_RGB = ControlSequence(
+    lambda r, g, b: CSI + '38;2;' + str(r) + ';' + str(g) + ';' + str(b) + 'm',
+    '24-Bit Foreground Color (RGB)')
+BG24_RGB = ControlSequence(
+    lambda r, g, b: CSI + '48;2;' + str(r) + ';' + str(g) + ';' + str(b) + 'm',
+    '24-Bit Background Color (RGB)')
+
+
+def main():
+    import sys
+
+    sys.stdout.write(SGR(SGRs.RESET))
+    sys.stdout.write(BG8(15) + ' ')
+    for i in [196, 160, 124, 88, 52, 16]:
+        sys.stdout.write(BG8(i) + ' ')
+    sys.stdout.write(SGR(SGRs.RESET) + '\n')
+
+
+if __name__ == '__main__':
+    main()

omlish/testing/__init__.py

@@ -0,0 +1,7 @@
+from .testing import (  # noqa
+    call_many_with_timeout,
+    can_import,
+    run_with_timeout,
+    waitpid_with_timeout,
+    xfail,
+)

omlish/testing/pydevd.py

@@ -0,0 +1,225 @@
+"""
+A small but likely growing collection of (completely optional) tools to make pydevd (PyCharm's, among other python
+IDE's, debugger) do hard things. Originally explored and added to get spark jvm python subprocesses to connect back to
+an already-debugging PyCharm instance to debug PySpark jobs.
+
+TODO:
+ - https://www.jetbrains.com/help/pycharm/remote-debugging-with-product.html#
+ - move to dev?
+ - cython help? or in cython.py
+"""
+import json
+import os
+import sys
+import tempfile
+import textwrap
+import types
+import typing as ta
+
+from .. import check
+from .. import lang
+
+
+ALLOW_DEBUGGER_CALLS = False
+
+
+DEBUGGER_CALL_PACKAGES = {
+    '_pydevd_bundle',
+}
+
+
+def is_debugger_call(hoist: int = 0, walk: int = 2) -> bool:
+    frame: ta.Optional[types.FrameType] = sys._getframe(2 + hoist)  # noqa
+    for _ in range(walk):
+        if frame is None:
+            break
+        package = frame.f_globals.get('__package__')
+        if package in DEBUGGER_CALL_PACKAGES:
+            return True
+        frame = frame.f_back
+    return False
+
+
+class DebuggerCallForbiddenException(Exception):
+    pass
+
+
+def forbid_debugger_call(hoist: int = 0) -> None:
+    # FIXME: only reentrant?
+    if not ALLOW_DEBUGGER_CALLS and is_debugger_call(hoist + 1):
+        raise DebuggerCallForbiddenException
+
+
+##
+
+
+@lang.cached_function
+def silence_subprocess_check() -> None:
+    try:
+        # /Applications/PyCharm.app/Contents/plugins/python/helpers/pydev/_pydev_bundle/pydev_monkey.py
+        from _pydev_bundle import pydev_monkey  # noqa
+    except ImportError:
+        return
+
+    new_tb = lang.proxy_import('traceback')
+    new_tb.print_exc = lambda *a, **k: None  # type: ignore
+    pydev_monkey.traceback = new_tb
+
+
+@lang.cached_function
+def patch_for_trio_asyncio() -> None:
+    try:
+        import pydevd_nest_asyncio  # noqa
+    except ImportError:
+        return
+
+    import trio_asyncio._base  # noqa
+
+    def new_call_soon(self, callback, *args, **context):
+        _, callback = pydevd_nest_asyncio._PydevdAsyncioUtils.try_to_get_internal_callback(callback)  # noqa
+        return orig_call_soon(self, callback, *args, **context)
+
+    orig_call_soon = trio_asyncio._base.BaseTrioEventLoop.call_soon  # noqa
+    trio_asyncio._base.BaseTrioEventLoop.call_soon = new_call_soon  # noqa
+
+
+##
+
+
+@lang.cached_function
+def _pydevd() -> ta.Optional[types.ModuleType]:
+    try:
+        return __import__('pydevd')
+    except ImportError:
+        return None
+
+
+def is_present() -> bool:
+    return _pydevd() is not None
+
+
+def get_setup() -> ta.Optional[dict]:
+    if is_present():
+        return _pydevd().SetupHolder.setup
+    else:
+        return None
+
+
+def is_running() -> bool:
+    return get_setup() is not None
+
+
+##
+
+
+ARGS_ENV_VAR = 'PYDEVD_ARGS'
+
+
+def get_args() -> list[str]:
+    check.state(is_present())
+    setup: ta.Mapping[ta.Any, ta.Any] = check.isinstance(get_setup(), dict)
+    args = [_pydevd().__file__]
+
+    for k in [
+        'port',
+        'vm_type',
+        'client',
+    ]:
+        if v := setup[k]:
+            args.extend(['--' + k, str(v)])
+
+    for k in [
+        'server',
+        'multiproc',
+        'multiprocess',
+        'save-signatures',
+        'save-threading',
+        'save-asyncio',
+        'print-in-debugger-startup',
+        'cmd-line',
+    ]:
+        if setup[k]:
+            args.append('--' + k)
+
+    if setup['qt-support']:
+        args.append('--qt-support=' + setup['qt-support'])
+
+    return args
+
+
+def save_args() -> None:
+    if is_present():
+        os.environ[ARGS_ENV_VAR] = json.dumps(get_args())
+
+
+def maybe_reexec(
+        *,
+        file: ta.Optional[str] = None,
+        module: ta.Optional[str] = None,
+        silence: bool = False,
+) -> None:
+    if ARGS_ENV_VAR not in os.environ:
+        return
+
+    try:
+        import pydevd  # noqa
+    except ImportError:
+        return
+
+    if pydevd.SetupHolder.setup is not None:  # noqa
+        return
+
+    if module is not None:
+        if file is not None:
+            raise ValueError
+
+        tmpdir = tempfile.mkdtemp()
+        bootstrap_path = os.path.join(tmpdir, 'bootstrap.py')
+        with open(bootstrap_path, 'w') as f:
+            f.write(textwrap.dedent(f"""
+            import sys
+            old_paths = set(sys.path)
+            for new_path in {sys.path!r}:
+                if new_path not in old_paths:
+                    sys.path.insert(0, new_path)
+
+            import runpy
+            runpy.run_module({module!r}, run_name='__main__')
+            """))
+        file = bootstrap_path
+
+    else:
+        if file is None:
+            raise ValueError
+
+    args = [sys.executable]
+    args.extend(json.loads(os.environ[ARGS_ENV_VAR]))
+    args.extend(['--file', file])
+    args.extend(sys.argv[1:])
+
+    if silence:
+        tmpdir = tempfile.mkdtemp()
+        bootstrap_path = os.path.join(tmpdir, 'bootstrap.py')
+        with open(bootstrap_path, 'w') as f:
+            f.write(textwrap.dedent(f"""
+            import sys
+            old_paths = set(sys.path)
+            for new_path in {sys.path!r}:
+                if new_path not in old_paths:
+                    sys.path.insert(0, new_path)
+
+            _stderr_write = sys.stderr.write
+            def stderr_write(*args, **kwargs):
+                code = sys._getframe(1).f_code
+                if code is not None and code.co_filename and code.co_filename.endswith('/pydev_log.py'):
+                    return
+                _stderr_write(*args, **kwargs)
+            sys.stderr.write = stderr_write
+
+            sys.argv = {args[1:]!r}
+            import runpy
+            runpy.run_path({args[1]!r}, run_name='__main__')
+            """))
+        args = [args[0], bootstrap_path]
+
+    os.execvp(sys.executable, args)

omlish/testing/pytest/__init__.py

@@ -0,0 +1,8 @@
+from . import plugins  # noqa
+
+from .helpers import (  # noqa
+    assert_raises_star,
+    skip_if_cant_import,
+    skip_if_not_on_path,
+    skip_if_python_version_less_than,
+)

omlish/testing/pytest/helpers.py

@@ -0,0 +1,35 @@
+import contextlib
+import shutil
+import sys
+import typing as ta
+
+import pytest
+
+from ..testing import can_import
+
+
+def skip_if_cant_import(module: str, *args, **kwargs):
+    return pytest.mark.skipif(not can_import(module, *args, **kwargs), reason=f'requires import {module}')
+
+
+def skip_if_not_on_path(exe: str):
+    return pytest.mark.skipif(shutil.which(exe) is None, reason=f'requires exe on path {exe}')
+
+
+def skip_if_python_version_less_than(num: ta.Sequence[int]):
+    return pytest.mark.skipif(sys.version_info < tuple(num), reason=f'python version {tuple(sys.version_info)} < {tuple(num)}')  # noqa
+
+
+def skip_if_not_single():
+    # [resolve_collection_argument(a) for a in session.config.args]
+    raise NotImplementedError
+
+
+@contextlib.contextmanager
+def assert_raises_star(et):
+    num_caught = 0
+    try:
+        yield
+    except* et as eg:  # noqa
+        num_caught += 1
+    assert num_caught > 0

omlish/testing/pytest/inject/__init__.py

@@ -0,0 +1 @@
+from . import harness  # noqa

omlish/testing/pytest/inject/harness.py

@@ -0,0 +1,159 @@
+import contextlib
+import enum
+import typing as ta
+
+import pytest
+
+from .. import plugins
+from .... import check
+from .... import inject as inj
+from .... import lang
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class PytestScope(enum.Enum):
+    SESSION = enum.auto()
+    PACKAGE = enum.auto()
+    MODULE = enum.auto()
+    CLASS = enum.auto()
+    FUNCTION = enum.auto()
+
+
+class Scopes(lang.Namespace):
+    Session = inj.SeededScope(PytestScope.SESSION)
+    Package = inj.SeededScope(PytestScope.PACKAGE)
+    Module = inj.SeededScope(PytestScope.MODULE)
+    Class = inj.SeededScope(PytestScope.CLASS)
+    Function = inj.SeededScope(PytestScope.FUNCTION)
+
+
+_SCOPES_BY_PYTEST_SCOPE: ta.Mapping[PytestScope, inj.SeededScope] = {
+    check.isinstance(a.tag, PytestScope): a
+    for n, a in Scopes.__dict__.items()
+    if isinstance(a, inj.SeededScope)
+}
+
+
+##
+
+
+_ACTIVE_HARNESSES: set['Harness'] = set()
+
+
+class Harness:
+    def __init__(self, es: inj.Elements) -> None:
+        super().__init__()
+        self._orig_es = es
+        self._es = inj.as_elements(
+            inj.as_binding(self),
+            *[
+                inj.as_elements(
+                    inj.bind_scope(ss),
+                    inj.bind_scope_seed(ss, inj.Key(pytest.FixtureRequest, tag=pts)),
+                )
+                for pts, ss in _SCOPES_BY_PYTEST_SCOPE.items()
+            ],
+            es,
+        )
+        self._inj: inj.Injector | None = None
+
+    ##
+
+    @contextlib.contextmanager
+    def activate(self) -> ta.Generator[ta.Self, None, None]:
+        check.none(self._inj)
+        check.not_in(self, _ACTIVE_HARNESSES)
+        _ACTIVE_HARNESSES.add(self)
+        try:
+            with inj.create_managed_injector(self._es) as i:
+                self._inj = i
+                yield self
+        finally:
+            self._inj = None
+            _ACTIVE_HARNESSES.remove(self)
+
+    ##
+
+    def __getitem__(
+            self,
+            target: ta.Union[inj.Key[T], type[T]],
+    ) -> T:
+        return check.not_none(self._inj)[target]
+
+    def session(self) -> pytest.FixtureRequest:
+        return self[inj.Key(pytest.FixtureRequest, tag=PytestScope.SESSION)]
+
+    def package(self) -> pytest.FixtureRequest:
+        return self[inj.Key(pytest.FixtureRequest, tag=PytestScope.PACKAGE)]
+
+    def module(self) -> pytest.FixtureRequest:
+        return self[inj.Key(pytest.FixtureRequest, tag=PytestScope.MODULE)]
+
+    def class_(self) -> pytest.FixtureRequest:
+        return self[inj.Key(pytest.FixtureRequest, tag=PytestScope.CLASS)]
+
+    def function(self) -> pytest.FixtureRequest:
+        return self[inj.Key(pytest.FixtureRequest, tag=PytestScope.FUNCTION)]
+
+    ##
+
+    @contextlib.contextmanager
+    def _pytest_scope_manager(
+            self,
+            pytest_scope: PytestScope,
+            request: pytest.FixtureRequest,
+    ) -> ta.Generator[None, None, None]:
+        ss = _SCOPES_BY_PYTEST_SCOPE[pytest_scope]
+        with inj.enter_seeded_scope(check.not_none(self._inj), ss, {
+            inj.Key(pytest.FixtureRequest, tag=pytest_scope): request,
+        }):
+            yield
+
+
+##
+
+
+@plugins.register
+class HarnessPlugin:
+
+    @pytest.fixture(scope='session', autouse=True)
+    def _harness_scope_listener_session(self, harness, request):
+        with harness._pytest_scope_manager(PytestScope.SESSION, request):  # noqa
+            yield
+
+    @pytest.fixture(scope='package', autouse=True)
+    def _harness_scope_listener_package(self, harness, request):
+        with harness._pytest_scope_manager(PytestScope.PACKAGE, request):  # noqa
+            yield
+
+    @pytest.fixture(scope='module', autouse=True)
+    def _harness_scope_listener_module(self, harness, request):
+        with harness._pytest_scope_manager(PytestScope.MODULE, request):  # noqa
+            yield
+
+    @pytest.fixture(scope='class', autouse=True)
+    def _harness_scope_listener_class(self, harness, request):
+        with harness._pytest_scope_manager(PytestScope.CLASS, request):  # noqa
+            yield
+
+    @pytest.fixture(scope='function', autouse=True)
+    def _harness_scope_listener_function(self, harness, request):
+        with harness._pytest_scope_manager(PytestScope.FUNCTION, request):  # noqa
+            yield
+
+
+##
+
+
+_HARNESS_ELEMENTS_LIST: list[inj.Elements] = []
+
+
+@pytest.fixture(scope='session', autouse=True)
+def harness() -> ta.Generator[Harness, None, None]:
+    with Harness(inj.as_elements(*_HARNESS_ELEMENTS_LIST)).activate() as h:
+        yield h

omlish/testing/pytest/plugins/__init__.py

@@ -0,0 +1,20 @@
+from . import (  # noqa
+    logging,
+    pycharm,
+    repeat,
+    skips,
+    spacing,
+    switches,
+)
+from ._registry import (  # noqa
+    ALL,
+    register,
+)
+
+
+def addhooks(pluginmanager):
+    present_types = {type(p) for p in pluginmanager.get_plugins()}
+
+    for plugin in ALL:
+        if plugin not in present_types:
+            pluginmanager.register(plugin())  # noqa

omlish/testing/pytest/plugins/_registry.py

@@ -0,0 +1,6 @@
+ALL: list[type] = []
+
+
+def register(obj):
+    ALL.append(obj)
+    return obj

omlish/testing/pytest/plugins/logging.py

@@ -0,0 +1,13 @@
+from .... import logs
+from ._registry import register
+
+
+@register
+class LoggingPlugin:
+
+    def pytest_addoption(self, parser):
+        parser.addoption('--log', action='store', help='Configures logging with given log level')
+
+    def pytest_configure(self, config):
+        if config.option.log is not None:
+            logs.configure_standard_logging(config.option.log.upper())