omlish 0.0.0.dev370__tar.gz → 0.0.0.dev371__tar.gz

{omlish-0.0.0.dev370/omlish.egg-info → omlish-0.0.0.dev371}/PKG-INFO

@@ -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 → omlish-0.0.0.dev371}/omlish/__about__.py

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

{omlish-0.0.0.dev370 → omlish-0.0.0.dev371}/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-0.0.0.dev370 → omlish-0.0.0.dev371}/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-0.0.0.dev371/omlish/testing/unittest/__init__.py

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

omlish-0.0.0.dev371/omlish/testing/unittest/__main__.py

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

omlish-0.0.0.dev371/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-0.0.0.dev371/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()