omlish 0.0.0.dev370__py3-none-any.whl → 0.0.0.dev371__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev370'
-__revision__ = '4f5d5deabcef292ee9186fec6530569e82d0c387'
+__version__ = '0.0.0.dev371'
+__revision__ = 'c37d96ddcd83d914205dd76b0f859b9ca93b0397'
 
 
 #

omlish/reflect/types.py

@@ -1,9 +1,17 @@
 """
+This is all gross, but this business always tends to be, and it at least centralizes and abstracts away all the
+grossness and hides it behind a small and stable interface. It supports exactly as much as is needed by the codebase at
+any given moment. It is 90% of why the codebase is strictly 3.13+ - I've tried to maintain backwards compat with this
+kind of thing many times before and it's not worth my time, especially with lite code as an alternative.
+
+I'm exploring extracting and distilling down mypy's type system to replace all of this, both to add some formalism /
+give it some guiding North Star to make all of its decisions for it, and to add some long sought capabilities (infer,
+meet, join, solve, ...), but it's quite a bit of work and not a priority at the moment.
+
 TODO:
  - visitor / transformer
  - uniform collection isinstance - items() for mappings, iter() for other
  - also check instance type in isinstance not just items lol
-TODO:
  - ta.Generic in mro causing trouble - omit? no longer 1:1
  - cache this shit, esp generic_mro shit
   - cache __hash__ in Generic/Union

omlish/testing/testing.py

@@ -1,3 +1,5 @@
+# ruff: noqa: UP006 UP007 UP045
+# @omlish-lite
 import functools
 import os
 import sys
@@ -27,16 +29,16 @@ DEFAULT_TIMEOUT_S = 30
 
 def call_many_with_timeout(
         fns: ta.Iterable[ta.Callable[[], T]],
-        timeout_s: float | None = None,
+        timeout_s: ta.Optional[float] = None,
         timeout_exception: Exception = TimeoutError('Thread timeout'),
-) -> list[T]:
+) -> ta.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: Exception | None = None
+    rets: ta.List[ta.Any] = [missing] * len(fns)
+    thread_exception: ta.Optional[Exception] = None
 
     def inner(fn, idx):
         try:
@@ -61,12 +63,12 @@ def call_many_with_timeout(
         if ret is missing:
             raise ValueError
 
-    return ta.cast(list[T], rets)
+    return ta.cast('ta.List[T]', rets)
 
 
 def run_with_timeout(
         *fns: ta.Callable[[], None],
-        timeout_s: float | None = None,
+        timeout_s: ta.Optional[float] = None,
         timeout_exception: Exception = TimeoutError('Thread timeout'),
 ) -> None:
     call_many_with_timeout(fns, timeout_s, timeout_exception)
@@ -74,7 +76,7 @@ def run_with_timeout(
 
 def waitpid_with_timeout(
         pid: int,
-        timeout_s: float | None = None,
+        timeout_s: ta.Optional[float] = None,
         timeout_exception: Exception = TimeoutError('waitpid timeout'),
 ) -> int:
     if timeout_s is None:
@@ -108,7 +110,7 @@ def xfail(fn):
     return inner
 
 
-def raise_in_thread(thr: threading.Thread, exc: BaseException | type[BaseException]) -> None:
+def raise_in_thread(thr: threading.Thread, exc: ta.Union[BaseException, ta.Type[BaseException]]) -> None:
     if sys.implementation.name != 'cpython':
         raise RuntimeError(sys.implementation.name)
 

omlish/testing/unittest/__init__.py

@@ -0,0 +1 @@
+# @omlish-lite

omlish/testing/unittest/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == '__main__':
+    from .main import _main
+
+    _main()

omlish/testing/unittest/loading.py

@@ -0,0 +1,115 @@
+# ruff: noqa: UP006 UP007 UP045
+"""
+https://docs.python.org/3/library/unittest.html#command-line-interface
+~ https://github.com/python/cpython/tree/f66c75f11d3aeeb614600251fd5d3fe1a34b5ff1/Lib/unittest
+"""
+# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+# --------------------------------------------
+#
+# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
+# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
+# documentation.
+#
+# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
+# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
+# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
+# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001-2024 Python Software Foundation; All Rights
+# Reserved" are retained in Python alone or in any derivative version prepared by Licensee.
+#
+# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
+# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
+# any such work a brief summary of the changes made to Python.
+#
+# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
+# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
+# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
+# RIGHTS.
+#
+# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
+# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
+# ADVISED OF THE POSSIBILITY THEREOF.
+#
+# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
+#
+# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
+# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
+# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
+#
+# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
+# License Agreement.
+import abc
+import dataclasses as dc
+import types
+import typing as ta
+import unittest
+
+from .types import Test
+
+
+##
+
+
+class TestTargetLoader:
+    def __init__(
+            self,
+            *,
+            test_name_patterns: ta.Optional[ta.Sequence[str]] = None,
+            module: ta.Union[str, types.ModuleType, None] = None,
+            loader: ta.Optional[unittest.loader.TestLoader] = None,
+    ) -> None:
+        super().__init__()
+
+        self._test_name_patterns = test_name_patterns
+        self._module = module
+        self._loader = loader
+
+    #
+
+    class Target(abc.ABC):  # noqa
+        pass
+
+    class ModuleTarget(Target):
+        pass
+
+    @dc.dataclass(frozen=True)
+    class NamesTarget(Target):
+        test_names: ta.Optional[ta.Sequence[str]] = None
+
+    @dc.dataclass(frozen=True)
+    class DiscoveryTarget(Target):
+        start: ta.Optional[str] = None
+        pattern: ta.Optional[str] = None
+        top: ta.Optional[str] = None
+
+    def load(self, target: Target) -> Test:
+        loader = self._loader
+        if loader is None:
+            loader = unittest.loader.TestLoader()
+
+        if self._test_name_patterns:
+            loader.testNamePatterns = self._test_name_patterns  # type: ignore[assignment]
+
+        if isinstance(target, TestTargetLoader.DiscoveryTarget):
+            return ta.cast(Test, loader.discover(
+                target.start,  # type: ignore[arg-type]
+                target.pattern,  # type: ignore[arg-type]
+                target.top,
+            ))
+
+        module: ta.Any = self._module
+        if isinstance(module, str):
+            module = __import__(module)
+            for part in module.split('.')[1:]:
+                module = getattr(module, part)
+
+        if isinstance(target, TestTargetLoader.ModuleTarget):
+            return ta.cast(Test, loader.loadTestsFromModule(module))
+
+        elif isinstance(target, TestTargetLoader.NamesTarget):
+            return ta.cast(Test, loader.loadTestsFromNames(
+                target.test_names,  # type: ignore[arg-type]
+                module,
+            ))
+
+        else:
+            raise TypeError(target)

omlish/testing/unittest/main.py

@@ -0,0 +1,272 @@
+# ruff: noqa: UP006 UP007 UP045
+"""
+https://docs.python.org/3/library/unittest.html#command-line-interface
+~ https://github.com/python/cpython/tree/f66c75f11d3aeeb614600251fd5d3fe1a34b5ff1/Lib/unittest
+"""
+# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+# --------------------------------------------
+#
+# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
+# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
+# documentation.
+#
+# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
+# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
+# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
+# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001-2024 Python Software Foundation; All Rights
+# Reserved" are retained in Python alone or in any derivative version prepared by Licensee.
+#
+# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
+# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
+# any such work a brief summary of the changes made to Python.
+#
+# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
+# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
+# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
+# RIGHTS.
+#
+# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
+# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
+# ADVISED OF THE POSSIBILITY THEREOF.
+#
+# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
+#
+# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
+# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
+# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
+#
+# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
+# License Agreement.
+import argparse
+import dataclasses as dc
+import importlib.util
+import os
+import re
+import sys
+import types
+import typing as ta
+
+from .loading import TestTargetLoader
+from .running import TestRunner
+
+
+##
+
+
+def _get_attr_dict(obj: ta.Optional[ta.Any], *attrs: str) -> ta.Dict[str, ta.Any]:
+    if obj is None:
+        return {}
+
+    return {
+        a: v
+        for a in attrs
+        if (v := getattr(obj, a, None)) is not None
+    }
+
+
+class TestRunCli:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._parser = self._get_arg_parser()
+
+    #
+
+    DEFAULT_DISCOVERY_START = '.'
+    DEFAULT_DISCOVERY_PATTERN = 'test*.py'
+
+    def _get_arg_parser(self) -> argparse.ArgumentParser:
+        parser = argparse.ArgumentParser(add_help=False)
+
+        parser.add_argument(
+            '-v',
+            '--verbose',
+            dest='verbosity',
+            action='store_const',
+            const=2,
+            help='Verbose output',
+        )
+
+        parser.add_argument(
+            '-q',
+            '--quiet',
+            dest='verbosity',
+            action='store_const',
+            const=0,
+            help='Quiet output',
+        )
+
+        parser.add_argument(
+            '--locals',
+            dest='tb_locals',
+            action='store_true',
+            help='Show local variables in tracebacks',
+        )
+
+        parser.add_argument(
+            '-f',
+            '--failfast',
+            dest='failfast',
+            action='store_true',
+            help='Stop on first fail or error',
+        )
+
+        parser.add_argument(
+            '-c',
+            '--catch',
+            dest='catchbreak',
+            action='store_true',
+            help='Catch Ctrl-C and display results so far',
+        )
+
+        parser.add_argument(
+            '-b',
+            '--buffer',
+            dest='buffer',
+            action='store_true',
+            help='Buffer stdout and stderr during tests',
+        )
+
+        def _convert_select_pattern(pattern: str) -> str:
+            if '*' not in pattern:
+                pattern = f'*{pattern}*'
+            return pattern
+
+        parser.add_argument(
+            '-k',
+            dest='test_name_patterns',
+            action='append',
+            type=_convert_select_pattern,
+            help='Only run tests which match the given substring',
+        )
+
+        #
+
+        parser.epilog = (
+            'For test discovery all test modules must be importable from the top level directory of the project.'
+        )
+
+        parser.add_argument(
+            '-s',
+            '--start-directory',
+            default=self.DEFAULT_DISCOVERY_START,
+            dest='start',
+            help="Directory to start discovery ('.' default)",
+        )
+
+        parser.add_argument(
+            '-p',
+            '--pattern',
+            default=self.DEFAULT_DISCOVERY_PATTERN,
+            dest='pattern',
+            help="Pattern to match tests ('test*.py' default)",
+        )
+
+        parser.add_argument(
+            '-t',
+            '--top-level-directory',
+            dest='top',
+            help='Top level directory of project (defaults to start directory)',
+        )
+
+        parser.add_argument(
+            'target',
+            nargs='*',
+            default=argparse.SUPPRESS,
+            help=argparse.SUPPRESS,
+        )
+
+        return parser
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class ParsedArgs:
+        args: ta.Optional[argparse.Namespace]
+        test_names: ta.Optional[ta.Sequence[str]] = None
+        module: ta.Union[str, types.ModuleType, None] = None
+
+    def parse_args(self, argv: ta.Sequence[str]) -> ParsedArgs:
+        args = self._parser.parse_args(argv)
+        return self.ParsedArgs(args)
+
+    #
+
+    IMPORT_PATH_PAT = re.compile(r'[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*')
+
+    def _build_target(self, name: str, args: ParsedArgs) -> TestTargetLoader.Target:
+        is_discovery = False
+        if os.path.isdir(name):
+            is_discovery = True
+        elif self.IMPORT_PATH_PAT.fullmatch(name):
+            spec = importlib.util.find_spec(name)
+            if spec is not None and spec.submodule_search_locations is not None:  # is a package, not a module
+                is_discovery = True
+
+        if not is_discovery:
+            return TestTargetLoader.NamesTarget([name])
+
+        else:
+            return TestTargetLoader.DiscoveryTarget(
+                start=name,
+                **_get_attr_dict(
+                    args.args,
+                    'pattern',
+                    'top',
+                ),
+            )
+
+    #
+
+    NO_TESTS_EXITCODE = 5
+
+    def run(
+            self,
+            args: ParsedArgs,
+            *,
+            exit: bool = False,  # noqa
+    ) -> None:
+        loader = TestTargetLoader(**_get_attr_dict(
+            args.args,
+            'test_name_patterns',
+        ))
+
+        tests = [
+            loader.load(self._build_target(target_arg, args))
+            for target_arg in (args.args.target if args.args is not None else None) or []  # noqa
+        ]
+
+        runner = TestRunner(TestRunner.Args(**_get_attr_dict(
+            args.args,
+            'verbosity',
+            'failfast',
+            'catchbreak',
+            'buffer',
+            'warnings',
+            'tb_locals',
+        )))
+
+        result = runner.run_many(tests)
+
+        runner.print(result)
+
+        if exit:
+            if not result.num_tests_run and not result.skipped:
+                sys.exit(self.NO_TESTS_EXITCODE)
+            elif result.was_successful:
+                sys.exit(0)
+            else:
+                sys.exit(1)
+
+
+##
+
+
+def _main() -> None:
+    cli = TestRunCli()
+    args = cli.parse_args(sys.argv[1:])
+    cli.run(args, exit=True)
+
+
+if __name__ == '__main__':
+    _main()

omlish/testing/unittest/running.py

@@ -0,0 +1,330 @@
+# ruff: noqa: UP006 UP007 UP045
+"""
+https://docs.python.org/3/library/unittest.html#command-line-interface
+~ https://github.com/python/cpython/tree/f66c75f11d3aeeb614600251fd5d3fe1a34b5ff1/Lib/unittest
+"""
+# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+# --------------------------------------------
+#
+# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
+# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
+# documentation.
+#
+# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
+# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
+# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
+# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001-2024 Python Software Foundation; All Rights
+# Reserved" are retained in Python alone or in any derivative version prepared by Licensee.
+#
+# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
+# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
+# any such work a brief summary of the changes made to Python.
+#
+# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
+# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
+# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
+# RIGHTS.
+#
+# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
+# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
+# ADVISED OF THE POSSIBILITY THEREOF.
+#
+# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
+#
+# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
+# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
+# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
+#
+# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
+# License Agreement.
+import contextlib
+import dataclasses as dc
+import sys
+import time
+import typing as ta
+import unittest
+import warnings
+
+from .types import Test
+
+
+##
+
+
+class _WritelnDecorator:
+    def __init__(self, stream):
+        super().__init__()
+
+        self.stream = stream
+
+    def __getattr__(self, attr):
+        if attr in ('stream', '__getstate__'):
+            raise AttributeError(attr)
+        return getattr(self.stream, attr)
+
+    def writeln(self, arg=None):
+        if arg:
+            self.write(arg)
+        self.write('\n')  # text-mode streams translate to \r\n if needed
+
+
+class TestRunner:
+    """
+    A test runner class that displays results in textual form.
+
+    It prints out the names of tests as they are run, errors as they occur, and a summary of the results at the end of
+    the test run.
+    """
+
+    @dc.dataclass(frozen=True)
+    class Args:
+        descriptions: bool = True
+        verbosity: int = 1
+        failfast: bool = False
+        buffer: bool = False
+        warnings: ta.Optional[str] = None
+        tb_locals: bool = False
+        catchbreak: bool = False
+
+    def __init__(
+            self,
+            args: Args = Args(),
+            *,
+            stream: ta.Optional[ta.Any] = None,
+    ):
+        super().__init__()
+
+        self._args = args
+
+        if stream is None:
+            stream = sys.stderr
+        self._stream = _WritelnDecorator(stream)
+
+    #
+
+    @contextlib.contextmanager
+    def _warnings_context(self) -> ta.Iterator[None]:
+        with warnings.catch_warnings():
+            w = self._args.warnings
+
+            if w is None and not sys.warnoptions:
+                # Even if DeprecationWarnings are ignored by default print them anyway unless other warnings settings
+                # are specified by the warnings arg or the -W python flag.
+                w = 'default'  # noqa
+            else:
+                # Here self.warnings is set either to the value passed to the warnings args or to None. If the user
+                # didn't pass a value self.warnings will be None. This means that the behavior is unchanged and depends
+                # on the values passed to -W.
+                w = self._args.warnings  # noqa
+
+            if w:
+                # If self.warnings is set, use it to filter all the warnings.
+                warnings.simplefilter(w)  # noqa
+
+                # If the filter is 'default' or 'always', special-case the warnings from the deprecated unittest methods
+                # to show them no more than once per module, because they can be fairly noisy.  The -Wd and -Wa flags
+                # can be used to bypass this only when self.warnings is None.
+                if w in ['default', 'always']:
+                    warnings.filterwarnings(
+                        'module',
+                        category=DeprecationWarning,
+                        message=r'Please use assert\w+ instead.',
+                    )
+
+            yield
+
+    #
+
+    def _make_result(self) -> unittest.TextTestResult:
+        return unittest.TextTestResult(
+            self._stream,  # type: ignore[arg-type]
+            self._args.descriptions,
+            self._args.verbosity,
+        )
+
+    #
+
+    class _InternalRunTestResult(ta.NamedTuple):
+        result: unittest.TextTestResult
+        time_taken: float
+
+    def _internal_run_test(self, test: ta.Callable[[unittest.TestResult], None]) -> _InternalRunTestResult:
+        result = self._make_result()
+        unittest.registerResult(result)
+        result.failfast = self._args.failfast
+        result.buffer = self._args.buffer
+        result.tb_locals = self._args.tb_locals
+
+        #
+
+        if self._args.catchbreak:
+            unittest.signals.installHandler()
+
+        with self._warnings_context():
+            start_time = time.perf_counter()
+
+            start_test_run = getattr(result, 'startTestRun', None)
+            if start_test_run is not None:
+                start_test_run()
+
+            try:
+                test(result)
+
+            finally:
+                stop_test_run = getattr(result, 'stopTestRun', None)
+                if stop_test_run is not None:
+                    stop_test_run()
+
+            stop_time = time.perf_counter()
+
+        time_taken = stop_time - start_time
+
+        return TestRunner._InternalRunTestResult(
+            result,
+            time_taken,
+        )
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class RunResult:
+        raw_results: ta.Sequence[unittest.TextTestResult]
+        time_taken: float
+
+        num_tests_run: int
+        was_successful: bool
+
+        class TestAndReason(ta.NamedTuple):
+            test: str
+            reason: str
+
+        skipped: ta.Sequence[TestAndReason]
+        errors: ta.Sequence[TestAndReason]
+        failures: ta.Sequence[TestAndReason]
+
+        expected_failures: ta.Sequence[TestAndReason]
+        unexpected_successes: ta.Sequence[str]
+
+        @classmethod
+        def merge(cls, results: ta.Iterable['TestRunner.RunResult']) -> 'TestRunner.RunResult':
+            def reduce_attr(fn, a):
+                return fn(getattr(r, a) for r in results)
+
+            def merge_list_attr(a):
+                return [rr for r in results for rr in getattr(r, a)]
+
+            return cls(
+                raw_results=merge_list_attr('raw_results'),
+                time_taken=reduce_attr(sum, 'time_taken'),
+
+                num_tests_run=reduce_attr(sum, 'num_tests_run'),
+                was_successful=reduce_attr(all, 'was_successful'),
+
+                skipped=merge_list_attr('skipped'),
+                errors=merge_list_attr('errors'),
+                failures=merge_list_attr('failures'),
+
+                expected_failures=merge_list_attr('expected_failures'),
+                unexpected_successes=merge_list_attr('unexpected_successes'),
+            )
+
+    def _build_run_result(self, internal_result: _InternalRunTestResult) -> RunResult:
+        result = internal_result.result
+
+        def as_test_and_reasons(l):
+            return [
+                TestRunner.RunResult.TestAndReason(result.getDescription(t), r)
+                for t, r in l
+            ]
+
+        return TestRunner.RunResult(
+            raw_results=[result],
+            time_taken=internal_result.time_taken,
+
+            num_tests_run=result.testsRun,
+            was_successful=result.wasSuccessful(),
+
+            skipped=as_test_and_reasons(result.skipped),
+            errors=as_test_and_reasons(result.errors),
+            failures=as_test_and_reasons(result.failures),
+
+            expected_failures=as_test_and_reasons(result.expectedFailures),
+            unexpected_successes=[result.getDescription(t) for t in result.unexpectedSuccesses],
+        )
+
+    #
+
+    def run(self, test: Test) -> RunResult:
+        return self._build_run_result(self._internal_run_test(test))
+
+    def run_many(self, tests: ta.Iterable[Test]) -> RunResult:
+        return TestRunner.RunResult.merge([self.run(t) for t in tests])
+
+    #
+
+    separator1 = unittest.TextTestResult.separator1
+    separator2 = unittest.TextTestResult.separator2
+
+    def print(self, result: RunResult) -> None:
+        if self._args.verbosity > 0:
+            self._stream.writeln()
+            self._stream.flush()
+
+        for t, r in result.errors:
+            self._stream.writeln(self.separator1)
+            self._stream.writeln(f'ERROR: {t}')
+            self._stream.writeln(self.separator2)
+            self._stream.writeln(f'{r}')
+            self._stream.flush()
+
+        for t, r in result.failures:
+            self._stream.writeln(self.separator1)
+            self._stream.writeln(f'FAIL: {t}')
+            self._stream.writeln(self.separator2)
+            self._stream.writeln(f'{r}')
+            self._stream.flush()
+
+        if result.unexpected_successes:
+            self._stream.writeln(self.separator1)
+            for t in result.unexpected_successes:
+                self._stream.writeln(f'UNEXPECTED SUCCESS: {t}')
+            self._stream.flush()
+
+        self._stream.writeln(self.separator2)
+
+        self._stream.writeln(
+            f'Ran {result.num_tests_run:d} '
+            f'test{"s" if result.num_tests_run != 1 else ""} '
+            f'in {result.time_taken:.3f}s',
+        )
+        self._stream.writeln()
+
+        expected_fails = len(result.expected_failures)
+        unexpected_successes = len(result.unexpected_successes)
+        skipped = len(result.skipped)
+
+        infos: ta.List[str] = []
+
+        if not result.was_successful:
+            self._stream.write('FAILED')
+            failed, errored = len(result.failures), len(result.errors)
+            if failed:
+                infos.append(f'failures={failed:d}')
+            if errored:
+                infos.append(f'errors={errored:d}')
+        else:
+            self._stream.write('OK')
+
+        if skipped:
+            infos.append(f'skipped={skipped:d}')
+
+        if expected_fails:
+            infos.append(f'expected failures={expected_fails:d}')
+
+        if unexpected_successes:
+            infos.append(f'unexpected successes={unexpected_successes:d}')
+
+        if infos:
+            self._stream.writeln(f' ({", ".join(infos)})')
+        else:
+            self._stream.write('\n')

omlish/testing/unittest/types.py

@@ -0,0 +1,5 @@
+import typing as ta
+import unittest
+
+
+Test = ta.Callable[[unittest.TestResult], None]  # ta.TypeAlias

{omlish-0.0.0.dev370.dist-info → omlish-0.0.0.dev371.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev370
+Version: 0.0.0.dev371
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev370.dist-info → omlish-0.0.0.dev371.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=aT8yZ-Zh-9wfHl5Ym5ouiWC1i0cy7Q7RlhzavB6VLPI,8587
-omlish/__about__.py,sha256=ppW6ebyCL8_ZT4j16N88-VXSlgE7mfjsGTbuhlNYrDw,3478
+omlish/__about__.py,sha256=IuPF6dQwqBF37vj4nM3a2rfw3IW2B0qdP0SrL4-B5BI,3478
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=rer-TPOFDU6fYq_AWio_AmA-ckZ8JDY5shIzQ_yXfzA,8414
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -586,7 +586,7 @@ omlish/reflect/__init__.py,sha256=9pzXLXXNMHkLhhI79iUr-o0SMOtR6HMUmAEUplZkIdE,85
 omlish/reflect/inspect.py,sha256=WCo2YpBYauKw6k758FLlZ_H4Q05rgVPs96fEv9w6zHQ,1538
 omlish/reflect/ops.py,sha256=F77OTaw0Uw020cJCWX_Q4kL3wvxlJ8jV8wz7BctGL_k,2619
 omlish/reflect/subst.py,sha256=0bnbWPbSbabu47BVnZtCQAZFim4CNC6azEDCmJES32w,3696
-omlish/reflect/types.py,sha256=2LJjaa2SuyhmeMh4Vmrgq-pdqQ-diKGAJJv9ln-wKrg,11244
+omlish/reflect/types.py,sha256=uMcxUHVJWYYcmF9ODeJ9WfcQ0DejsqsEVIX5K0HjJSM,12018
 omlish/secrets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/secrets/all.py,sha256=gv_d9SfyMxso30HsrSz9XmIrSZOdl3rLA5MSH0ZXfgM,486
 omlish/secrets/crypto.py,sha256=9D21lnvPhStwu8arD4ssT0ih0bDG-nlqIRdVgYL40xA,3708
@@ -759,7 +759,7 @@ omlish/term/vt100/c.py,sha256=93HARU6Dd1rVF-n8cAyXqkEqleYLcofuLgSUNd6-GbU,3537
 omlish/term/vt100/states.py,sha256=OxPUxfFTcfz56MhtDgIigEApChOtN6XO1g6R2H08mu4,8303
 omlish/term/vt100/terminal.py,sha256=KUlg331ele7P6SHsBKdbpdQFDKsxSply1Ds27NkppTs,9359
 omlish/testing/__init__.py,sha256=M_BQrcCHkoL-ZvE-UpQ8XxXNYRRawhjUz4rCJnAqM2A,152
-omlish/testing/testing.py,sha256=zmBHw5gw1ZUUcDYC0uonSThjhRn0HNuorjpo0jLvju8,2885
+omlish/testing/testing.py,sha256=XOZTPjL8pggx2v5TUHUDjSgaU6lMnuPJ58hWoFQyzPY,2979
 omlish/testing/pytest/__init__.py,sha256=i4ti6Q2rVYJ-XBk9UYDfUUagCrEDTC5jOeSykBjYYZQ,234
 omlish/testing/pytest/helpers.py,sha256=HxiKvpJQ4b6WCiQXOqQTqKbmr7CMAgCF6hViT6pfIuw,202
 omlish/testing/pytest/marks.py,sha256=g0RgdvFAd3xog3kKYyb9QtiUVPrEG3JX_abhDNrHJy0,285
@@ -789,6 +789,12 @@ omlish/testing/pytest/plugins/asyncs/backends/trio_asyncio.py,sha256=LCB8Yts5mLY
 omlish/testing/pytest/plugins/switches/__init__.py,sha256=KTdm9xe8AYQvNT-IKSGr9O8q_hgRGEqhK3zcto0EbWk,43
 omlish/testing/pytest/plugins/switches/plugin.py,sha256=RBxjefl9RDJuSmT_W0lTSd9DlAT-nkyy_U2fBYzdWNs,5835
 omlish/testing/pytest/plugins/switches/switches.py,sha256=lj8S9RMwUAW7a93ZqqTjoD4dRVkeGts2sl8Cn-H17hc,1890
+omlish/testing/unittest/__init__.py,sha256=Y3l4WY4JRi2uLG6kgbGp93fuGfkxkKwZDvhsa0Rwgtk,15
+omlish/testing/unittest/__main__.py,sha256=d23loR_cKfTYZwYiqpt_CmKI7dd5WcYFgIYzqMep75E,68
+omlish/testing/unittest/loading.py,sha256=DT6vIZwXBkbEXocaxhrbWj8SqsoP7pyxD5K3bZlAE34,4764
+omlish/testing/unittest/main.py,sha256=OrebAhWqlfNOx5LF-ZIu2KvclneJgBAi13LkvDiZ_yw,8408
+omlish/testing/unittest/running.py,sha256=sifL1gjhn1VR965T9fdZy8NbJpVtpEQety8ngh5Fw7A,11821
+omlish/testing/unittest/types.py,sha256=RvQwU9l2amH2mKv3W3QyPBFg0eXkQ8wWnIJeRXeDdi0,102
 omlish/text/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/text/asdl.py,sha256=AS3irh-sag5pqyH3beJif78PjCbOaFso1NeKq-HXuTs,16867
 omlish/text/decoding.py,sha256=sQWGckWzRslRHYKpj1SBeoo6AVqXm5HFlWFRARN1QpM,1286
@@ -882,9 +888,9 @@ omlish/typedvalues/marshal.py,sha256=AtBz7Jq-BfW8vwM7HSxSpR85JAXmxK2T0xDblmm1HI0
 omlish/typedvalues/of_.py,sha256=UXkxSj504WI2UrFlqdZJbu2hyDwBhL7XVrc2qdR02GQ,1309
 omlish/typedvalues/reflect.py,sha256=PAvKW6T4cW7u--iX80w3HWwZUS3SmIZ2_lQjT65uAyk,1026
 omlish/typedvalues/values.py,sha256=ym46I-q2QJ_6l4UlERqv3yj87R-kp8nCKMRph0xQ3UA,1307
-omlish-0.0.0.dev370.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev370.dist-info/METADATA,sha256=WQMJ4AZLxaxumd_FFL5iHiJ-yJ_PafoYdFF3vSKd15Y,4416
-omlish-0.0.0.dev370.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omlish-0.0.0.dev370.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev370.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev370.dist-info/RECORD,,
+omlish-0.0.0.dev371.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev371.dist-info/METADATA,sha256=oPFYGURgWGkPAhtJkRCmiXVNzNFuNn8sXTBZAHZh1TI,4416
+omlish-0.0.0.dev371.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omlish-0.0.0.dev371.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev371.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev371.dist-info/RECORD,,