omlish 0.0.0.dev1__py3-none-any.whl

omlish/testing/pytest/plugins/pycharm.py

@@ -0,0 +1,54 @@
+import threading
+
+from ... import pydevd as opd
+from ._registry import register
+
+
+@register
+class PycharmPlugin:
+
+    def pytest_addoption(self, parser):
+        parser.addoption('--no-pycharm-debug', action='store_true', default=False, help='Disables pycharm debugging')
+
+    def pytest_collection(self, session):
+        setup = opd.get_setup()
+        if setup is not None:
+            if hasattr(session.config, '_env_timeout'):
+                session.config._env_timeout = None
+
+    def pytest_exception_interact(self, node, call, report):
+        if node.session.config.option.no_pycharm_debug:
+            return report
+
+        try:
+            import pydevd
+            from pydevd import pydevd_tracing
+        except ImportError:
+            return report
+
+        exctype, value, traceback = call.excinfo._excinfo
+        frames = []
+        while traceback:
+            # FIXME: 3.12 DUPLICATE FRAME IDENTITIES!! prob same shit as greenlet/trio, need to 'pin'
+            # FIXME: uhh it happens in 3.11 too and that works lol
+            frames.append(traceback.tb_frame)
+            traceback = traceback.tb_next
+
+        thread = threading.current_thread()
+        frames_by_id = {id(frame): frame for frame in frames}
+        frame = frames[-1]
+        exception = (exctype, value, traceback)
+
+        if hasattr(thread, 'additional_info'):
+            thread.additional_info.pydev_message = 'test fail'
+        try:
+            debugger = pydevd.debugger
+        except AttributeError:
+            debugger = pydevd.get_global_debugger()
+
+        pydevd_tracing.SetTrace(None)
+
+        debugger.stop_on_unhandled_exception(thread, frame, frames_by_id, exception)
+        # debugger.handle_post_mortem_stop(thread, frame, frames_by_id, exception)
+
+        return report

omlish/testing/pytest/plugins/repeat.py

@@ -0,0 +1,19 @@
+from ._registry import register
+
+
+PARAM_NAME = '__repeat'
+
+
+@register
+class RepeatPlugin:
+
+    def pytest_addoption(self, parser):
+        parser.addoption('--repeat', action='store', type=int, help='Number of times to repeat each test')
+
+    def pytest_generate_tests(self, metafunc):
+        if metafunc.config.option.repeat is None:
+            return
+
+        n = metafunc.config.option.repeat
+        metafunc.fixturenames.append(PARAM_NAME)
+        metafunc.parametrize(PARAM_NAME, range(n))

omlish/testing/pytest/plugins/skips.py

@@ -0,0 +1,32 @@
+"""
+TODO:
+ - go-style tags: +slow,-ci, ...
+"""
+from _pytest.main import resolve_collection_argument  # noqa
+import pytest
+
+from ._registry import register
+
+
+@register
+class SkipsPlugin:
+
+    def pytest_collection_modifyitems(self, session, items):
+        dct: dict[str, set[str]] = {}
+        for arg in session.config.args:
+            ca = resolve_collection_argument(
+                session.config.invocation_params.dir,
+                arg,
+                as_pypath=session.config.option.pyargs,
+            )
+            if ca.path.is_file():
+                dct.setdefault(ca.path.as_posix(), set()).update(ca.parts)
+
+        skip = pytest.mark.skip(reason='skipped (not specified alone)')
+        for item in items:
+            if 'skip_unless_alone' in item.keywords:
+                if item.name not in dct.get(item.fspath.strpath, ()):
+                    item.add_marker(skip)
+
+    def pytest_configure(self, config):
+        config.addinivalue_line('markers', 'skip_unless_alone: mark test as skipped unless specified alone')

omlish/testing/pytest/plugins/spacing.py

@@ -0,0 +1,19 @@
+from ._registry import register
+
+
+@register
+class SpacingPlugin:
+
+    def pytest_addoption(self, parser):
+        parser.addoption('--newlines-before', action='store', type=int, help='Adds newlines before tests')
+        parser.addoption('--newlines-after', action='store', type=int, help='Adds newlines after tests')
+
+    def pytest_runtest_setup(self, item):
+        if item.session.config.option.newlines_before:
+            for _ in range(item.session.config.option.newlines_before):
+                print()
+
+    def pytest_runtest_teardown(self, item):
+        if item.session.config.option.newlines_after:
+            for _ in range(item.session.config.option.newlines_after):
+                print()

omlish/testing/pytest/plugins/switches.py

@@ -0,0 +1,70 @@
+"""
+TODO:
+ - inheritance
+ - dynamic registration
+ - dynamic switching (skip docker if not running, skip online if not online, ...)
+"""
+import typing as ta
+
+import pytest
+
+from .... import check
+from .... import collections as col
+from ._registry import register
+
+
+Configable = ta.Union[pytest.FixtureRequest, pytest.Config]
+
+
+SWITCHES = col.OrderedSet([
+    'online',
+    'slow',
+])
+
+
+def _get_obj_config(obj: Configable) -> pytest.Config:
+    if isinstance(obj, pytest.Config):
+        return obj
+    elif isinstance(obj, pytest.FixtureRequest):
+        return obj.config
+    else:
+        raise TypeError(obj)
+
+
+def is_disabled(obj: ta.Optional[Configable], name: str) -> bool:
+    check.isinstance(name, str)
+    check.in_(name, SWITCHES)
+    return obj is not None and _get_obj_config(obj).getoption(f'--no-{name}')
+
+
+def skip_if_disabled(obj: ta.Optional[Configable], name: str) -> None:
+    if is_disabled(obj, name):
+        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
+    }
+
+
+@register
+class SwitchesPlugin:
+
+    def pytest_addoption(self, parser):
+        for sw in SWITCHES:
+            parser.addoption(f'--no-{sw}', action='store_true', default=False, help=f'disable {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)
+
+    def pytest_configure(self, config):
+        for sw in SWITCHES:
+            config.addinivalue_line('markers', f'{sw}: mark test as {sw}')

omlish/testing/testing.py

@@ -0,0 +1,102 @@
+import functools
+import importlib
+import os
+import threading
+import time
+import traceback
+import typing as ta
+
+
+DEFAULT_TIMEOUT_S = 30
+
+T = ta.TypeVar('T')
+
+
+def call_many_with_timeout(
+        fns: ta.Iterable[ta.Callable[[], T]],
+        timeout_s: int | float | None = None,
+        timeout_exception: Exception = TimeoutError('Thread timeout'),
+) -> list[T]:
+    if timeout_s is None:
+        timeout_s = DEFAULT_TIMEOUT_S
+
+    fns = list(fns)
+    missing = object()
+    rets: list[ta.Any] = [missing] * len(fns)
+    thread_exception: ta.Optional[Exception] = None
+
+    def inner(fn, idx):
+        try:
+            nonlocal rets
+            rets[idx] = fn()
+        except Exception as e:
+            nonlocal thread_exception
+            thread_exception = e
+            raise
+
+    threads = [threading.Thread(target=inner, args=(fn, idx)) for idx, fn in enumerate(fns)]
+    for thread in threads:
+        thread.start()
+    for thread in threads:
+        thread.join(timeout_s)
+    for thread in threads:
+        if thread.is_alive():
+            raise timeout_exception
+
+    if thread_exception is not None:
+        raise thread_exception
+    for ret in rets:
+        if ret is missing:
+            raise ValueError
+
+    return ta.cast(list[T], rets)
+
+
+def run_with_timeout(
+        *fns: ta.Callable[[], None],
+        timeout_s: int | float | None = None,
+        timeout_exception: Exception = TimeoutError('Thread timeout'),
+) -> None:
+    call_many_with_timeout(fns, timeout_s, timeout_exception)
+
+
+def waitpid_with_timeout(
+        pid: int,
+        timeout_s: int | float | None = None,
+        timeout_exception: Exception = TimeoutError('waitpid timeout')
+) -> int:
+    if timeout_s is None:
+        timeout_s = DEFAULT_TIMEOUT_S
+
+    start_time = time.time()
+
+    while True:
+        wait_pid, status = os.waitpid(pid, os.WNOHANG)
+        if wait_pid != 0:
+            if wait_pid != pid:
+                raise ValueError(f'{wait_pid} != {pid}')
+            return status
+
+        elapsed_time = time.time() - start_time
+        if elapsed_time >= timeout_s:
+            raise timeout_exception
+
+
+def can_import(*args, **kwargs) -> bool:
+    try:
+        importlib.import_module(*args, **kwargs)
+    except ImportError:
+        return False
+    else:
+        return True
+
+
+def xfail(fn):
+    @functools.wraps(fn)
+    def inner(*args, **kwargs):
+        try:
+            fn(*args, **kwargs)
+        except Exception:  # noqa
+            traceback.print_exc()
+
+    return inner

omlish/text/delimit.py

@@ -0,0 +1,171 @@
+import io
+import typing as ta
+
+
+class DelimitedEscaping:
+
+    def __init__(
+            self,
+            delimit_char: str,
+            quote_char: str,
+            escape_char: str,
+            escaped_chars: ta.Iterable[str] = (),
+    ) -> None:
+        super().__init__()
+
+        self._delimit_char = delimit_char
+        self._quote_char = quote_char
+        self._escape_char = escape_char
+        self._escaped_chars = frozenset(escaped_chars)
+
+        for c in [delimit_char, quote_char, escape_char]:
+            if not isinstance(c, str) or len(c) != 1:
+                raise TypeError(c)
+        for c in self._escaped_chars:
+            if not isinstance(c, str):
+                raise TypeError(c)
+
+        self._all_escaped_chars = frozenset({delimit_char, quote_char, escape_char} | self._escaped_chars)
+
+    @property
+    def delimit_char(self) -> str:
+        return self._delimit_char
+
+    def quote_char(self) -> str:
+        return self._quote_char
+
+    def escape_char(self) -> str:
+        return self._escape_char
+
+    def escaped_chars(self) -> frozenset[str]:
+        return self._escaped_chars
+
+    def all_escaped_chars(self) -> frozenset[str]:
+        return self._all_escaped_chars
+
+    def is_control_char(self, c: str) -> bool:
+        if not len(c) == 1:
+            raise TypeError(c)
+        return c == self._delimit_char or c == self._quote_char or c == self._escape_char
+
+    def contains_escaped_char(self, s: str) -> bool:
+        return any(c in self._all_escaped_chars for c in s)
+
+    def escape(self, s: str) -> str:
+        buf = io.StringIO()
+        for c in s:
+            if c in self._all_escaped_chars:
+                buf.write(self._escape_char)
+            buf.write(c)
+        return buf.getvalue()
+
+    def unescape(self, s: str) -> str:
+        buf = io.StringIO()
+        i = 0
+        while i < len(s):
+            c = s[i]
+            if c == self._escape_char:
+                if i > (len(s) - 2):
+                    raise ValueError(s)
+                i += 1
+                buf.write(s[i])
+            else:
+                if c in self._all_escaped_chars:
+                    raise ValueError(s)
+                buf.write(c)
+            i += 1
+        return buf.getvalue()
+
+    def quote(self, s: str) -> str:
+        if self.contains_escaped_char(s):
+            return self._quote_char + self.escape(s) + self._quote_char
+        else:
+            return s
+
+    def unquote(self, s: str) -> str:
+        if s and s[0] == self._quote_char:
+            if len(s) < 2 or s[-1] != self._quote_char:
+                raise ValueError(s)
+            return self.unescape(s[1:-1])
+        else:
+            return s
+
+    def delimit_many(self, strs: ta.Iterable[str]) -> str:
+        if isinstance(strs, str):
+            raise TypeError(strs)
+        buf = io.StringIO()
+        count = 0
+        for s in strs:
+            if count:
+                buf.write(self._delimit_char)
+            count += 1
+            if self.contains_escaped_char(s):
+                buf.write(self.quote(s))
+            else:
+                buf.write(s)
+        return buf.getvalue()
+
+    def delimit(self, s: str) -> str:
+        if not isinstance(s, str):
+            raise TypeError(s)
+        return self.delimit_many([s])
+
+    def undelimit(self, s: str) -> list[str]:
+        ret = []
+        buf = io.StringIO()
+        count = 0
+        i = 0
+
+        while i < len(s):
+            c = s[i]
+
+            if count:
+                if c != self._delimit_char or i >= (len(s) - 1):
+                    raise ValueError(s)
+                i += 1
+                c = s[i]
+
+            quoted = c == self._quote_char
+            if quoted:
+                if i >= (len(s) - 1):
+                    raise ValueError(s)
+                i += 1
+                c = s[i]
+            unquoted = False
+
+            while True:
+                if c == self._delimit_char:
+                    if not quoted:
+                        break
+                    else:
+                        buf.write(c)
+                elif c == self._quote_char:
+                    if not quoted:
+                        raise ValueError(s)
+                    unquoted = True
+                    i += 1
+                    break
+                elif c == self._escape_char:
+                    if not quoted or i > (len(s) - 2):
+                        raise ValueError(s)
+                    i += 1
+                    buf.write(s[i])
+                else:
+                    if c in self._escaped_chars:
+                        raise ValueError(s)
+                    buf.write(c)
+
+                i += 1
+                if i == len(s):
+                    break
+                c = s[i]
+
+            if quoted and not unquoted:
+                raise ValueError(s)
+
+            ret.append(buf.getvalue())
+            buf.seek(0)
+            buf.truncate()
+            count += 1
+
+        return ret

omlish/text/indent.py

@@ -0,0 +1,50 @@
+import contextlib
+import io
+import typing as ta
+
+from .. import check
+
+
+class IndentWriter:
+
+    DEFAULT_INDENT = ' ' * 4
+
+    def __init__(
+            self,
+            *,
+            buf: io.StringIO | None = None,
+            indent: str | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._buf = buf if buf is not None else io.StringIO()
+        self._indent = check.isinstance(indent, str) if indent is not None else self.DEFAULT_INDENT
+        self._level = 0
+        self._has_indented = False
+
+    @contextlib.contextmanager
+    def indent(self, num: int = 1) -> ta.Iterator[None]:
+        self._level += num
+        try:
+            yield
+        finally:
+            self._level -= num
+
+    def write(self, s: str) -> None:
+        indent = self._indent * self._level
+        i = 0
+        while i < len(s):
+            if not self._has_indented:
+                self._buf.write(indent)
+                self._has_indented = True
+            try:
+                n = s.index('\n', i)
+            except ValueError:
+                self._buf.write(s[i:])
+                break
+            self._buf.write(s[i:n + 1])
+            self._has_indented = False
+            i = n + 2
+
+    def getvalue(self) -> str:
+        return self._buf.getvalue()