omlish 0.0.0.dev373__tar.gz → 0.0.0.dev375__tar.gz

{omlish-0.0.0.dev373/omlish.egg-info → omlish-0.0.0.dev375}/PKG-INFO

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

{omlish-0.0.0.dev373 → omlish-0.0.0.dev375}/README.md

@@ -123,34 +123,34 @@ Core utilities and foundational code. It's relatively large but completely self-
 
 # Lite code
 
-A subset of this codebase is written in a 'lite' style. While most of the code is written for python 3.13+, 'lite' code
-is written for 3.8+, and is written in a style conducive to
+A subset of this codebase is written in a 'lite' style (non-'lite' code is referred to as *standard* code). While
+standard code is written for python 3.13+, 'lite' code is written for 3.8+, and is written in a style conducive to
 [amalgamation](https://github.com/wrmsr/omlish/tree/master/omdev#amalgamation) in which multiple python source files are
 stitched together into one single self-contained python script.
 
 Code written in this style has notable differences from standard code, including (but not limited to):
 
 - No name mangling is done in amalgamation, which means (among other things) that code must be written expecting to be
-  all dumped into the same giant namespace. Where a non-lite class might be [`omlish.inject.keys.Key`](inject/keys.py),
+  all dumped into the same giant namespace. Where a standard class might be [`omlish.inject.keys.Key`](inject/keys.py),
   a lite equivalent might be [`omlish.lite.inject.InjectorKey`](lite/inject.py).
 - All internal imports `import` each individual item out of modules rather than importing the modules and referencing
-  their contents. Where non-lite code would `from .. import x; x.y`, lite code would `from ..x import y; y`. As a result
+  their contents. Where standard code would `from .. import x; x.y`, lite code would `from ..x import y; y`. As a result
   there are frequently 'api' non-instantiated namespace classes serving the purpose of modules - just handy bags of
   stuff with shortened names.
 - As lite code is tested in 3.8+ but core code requires 3.13+, packages containing lite code can't import anything
-  non-lite in their (and their ancestors') `__init__.py`'s. Furthermore, `__init__.py` files are omitted outright in
+  standard in their (and their ancestors') `__init__.py`'s. Furthermore, `__init__.py` files are omitted outright in
   amalgamation, so they effectively must be empty in any package containing any lite code. As a result there are
   frequently [`all.py`](configs/all.py) files in mixed-lite packages which serve the purpose of `__init__.py` for
-  non-lite usage - where importing non-lite packages from non-lite code would be done via `from .. import lang`,
-  importing mixed-lite packages from non-lite code would be done via `from ..configs import all as cfgs`.
+  standard usage - where importing standard packages from standard code would be done via `from .. import lang`,
+  importing mixed-lite packages from standard code would be done via `from ..configs import all as cfgs`.
 
 # Dependencies
 
 This library has no required dependencies of any kind, but there are numerous optional integrations - see
 [`__about__.py`](__about__.py) for a full list, but some specific examples are:
 
-- **anyio** - While lite code must use only asyncio, non-trivial async non-lite code prefers to be written to anyio.
-- **pytest** - What is used for all non-lite testing - as lite code has no dependencies of any kind its testing uses
+- **anyio** - While lite code must use only asyncio, non-trivial async standard code prefers to be written to anyio.
+- **pytest** - What is used for all standard testing - as lite code has no dependencies of any kind its testing uses
   stdlib's [unittest](https://docs.python.org/3/library/unittest.html).
 - **asttokens / executing** - For getting runtime source representations of function call arguments, an optional
   capability of [check](check.py).

{omlish-0.0.0.dev373 → omlish-0.0.0.dev375}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev373'
-__revision__ = '0a27e61ad530198ac027dde9d0b88d9bd995d0b5'
+__version__ = '0.0.0.dev375'
+__revision__ = '5e3b55f993cef1d0198721ee8b5d9f827c357fe9'
 
 
 #

{omlish-0.0.0.dev373 → omlish-0.0.0.dev375}/omlish/collections/__init__.py

@@ -37,10 +37,6 @@ from .coerce import (  # noqa
     seq_or_none,
 )
 
-from .errors import (  # noqa
-    DuplicateKeyError,
-)
-
 from .frozen import (  # noqa
     Frozen,
     FrozenDict,

{omlish-0.0.0.dev373 → omlish-0.0.0.dev375}/omlish/collections/mappings.py

@@ -66,9 +66,27 @@ class TypeMap(ta.Generic[T]):
     def get(self, ty: type[T]) -> T | None:
         return self._dct.get(ty)
 
-    def __getitem__(self, ty: type[T]) -> ta.Sequence[T]:
+    def __getitem__(self, ty: type[T]) -> T:
         return self._dct[ty]
 
+    _any_dct: dict[type | tuple[type, ...], tuple[T, ...]]
+
+    def get_any(self, cls: type | tuple[type, ...]) -> ta.Sequence[T]:
+        try:
+            any_dct = self._any_dct
+        except AttributeError:
+            any_dct = {}
+            self._any_dct = any_dct
+
+        try:
+            return any_dct[cls]
+        except KeyError:
+            pass
+
+        ret = tuple(tv for tv in self if isinstance(tv, cls))
+        any_dct[cls] = ret
+        return ret
+
 
 class DynamicTypeMap(ta.Generic[V]):
     def __init__(self, items: ta.Iterable[V] = (), *, weak: bool = False) -> None:

{omlish-0.0.0.dev373 → omlish-0.0.0.dev375}/omlish/collections/utils.py

@@ -1,7 +1,6 @@
 import typing as ta
 
 from .. import lang
-from .errors import DuplicateKeyError
 from .identity import IdentityKeyDict
 from .identity import IdentitySet
 
@@ -48,7 +47,7 @@ def unique(
         k = key(e)
         if k in seen:
             if strict:
-                raise DuplicateKeyError(k, e)
+                raise lang.DuplicateKeyError(k, e)
         else:
             seen.add(k)
             ret.append(e)
@@ -88,7 +87,7 @@ def make_map(
     for k, v in kvs:
         if k in d:
             if strict:
-                raise DuplicateKeyError(k)
+                raise lang.DuplicateKeyError(k)
         else:
             d[k] = v
     return d

omlish-0.0.0.dev375/omlish/funcs/builders.py

@@ -0,0 +1,162 @@
+# ruff: noqa: UP006 UP045
+# @omlish-lite
+import abc
+import io
+import os.path
+import sys
+import typing as ta
+
+from ..lite.cached import cached_nullary
+from ..lite.check import check
+from ..os.paths import is_path_in_dir
+
+
+##
+
+
+class FnBuilder(abc.ABC):
+    @abc.abstractmethod
+    def build_fn(
+            self,
+            name: str,
+            src: str,
+            ns: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+    ) -> ta.Callable:
+        ...
+
+
+#
+
+
+class SimpleFnBuilder(FnBuilder):
+    def build_fn(
+            self,
+            name: str,
+            src: str,
+            ns: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+    ) -> ta.Callable:
+        ns = dict(ns or {})
+        exec(src, ns)
+        return ns[name]
+
+
+build_fn = SimpleFnBuilder().build_fn
+
+
+#
+
+
+class DebugFnBuilder(FnBuilder):
+    def __init__(
+            self,
+            *,
+            mod_name_prefix: ta.Optional[str] = None,
+            src_dir: ta.Optional[str] = None,
+    ) -> None:
+        super().__init__()
+
+        if mod_name_prefix is None:
+            mod_name_prefix = f'_{self.__class__.__name__}_{id(self):x}_'
+        self._mod_name_prefix = mod_name_prefix
+
+        self._given_src_dir = src_dir
+
+        self._num_fns = 0
+        self._mod_names: ta.Set[str] = set()
+        self._installed_sys_path = False
+
+    @cached_nullary
+    def _src_dir(self) -> str:
+        if self._given_src_dir is not None:
+            return self._given_src_dir
+        else:
+            return __import__('tempfile').mkdtemp(prefix=f'_{self.__class__.__name__}_{os.getpid()}__')  # noqa
+
+    @cached_nullary
+    def _install_sys_path(self) -> None:
+        if (src_dir := self._src_dir()) not in sys.path:
+            self._installed_sys_path = True
+            sys.path.append(src_dir)
+
+    def uninstall_sys_path(self) -> None:
+        if self._installed_sys_path:
+            while True:
+                try:
+                    sys.path.remove(self._src_dir())
+                except ValueError:
+                    break
+            self._installed_sys_path = True
+
+    def _gen_mod_name(
+            self,
+            fn_num: int,
+            fn_name: str,
+            *,
+            suffix: ta.Optional[str] = None,
+    ) -> str:
+        mod_name = f'{self._mod_name_prefix}{fn_num}__{fn_name}{suffix or ""}'
+
+        check.not_in(mod_name, self._mod_names)
+        check.not_in(mod_name, sys.modules)
+
+        self._mod_names.add(mod_name)
+
+        return mod_name
+
+    def _build_mod(
+            self,
+            mod_name: str,
+            mod_src: str,
+    ) -> ta.Any:
+        self._install_sys_path()
+
+        src_dir = self._src_dir()
+        src_file = os.path.join(src_dir, f'{mod_name}.py')
+        check.state(is_path_in_dir(src_dir, src_file))
+
+        with open(src_file, 'w') as f:
+            f.write(mod_src)
+
+        mod = __import__(mod_name)
+
+        check.equal(mod.__file__, src_file)
+
+        return mod
+
+    def build_fn(
+            self,
+            name: str,
+            src: str,
+            ns: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+    ) -> ta.Callable:
+        fn_num = self._num_fns
+        self._num_fns += 1
+
+        mod_name = self._gen_mod_name(fn_num, name)
+
+        src_preamble: ta.List[str] = []
+
+        if ns:
+            ns_mod_name = self._gen_mod_name(fn_num, name, suffix='__ns')
+            ns_mod = self._build_mod(ns_mod_name, '')
+
+            for k, v in ns.items():
+                setattr(ns_mod, k, v)
+
+            src_preamble.append(f'from {ns_mod_name} import (')
+            for k in sorted(ns):
+                src_preamble.append(f'    {k},')
+            src_preamble.append(')')
+
+        src_sb = io.StringIO()
+        if src_preamble:
+            src_sb.write('\n'.join(src_preamble))
+            src_sb.write('\n\n')
+        src_sb.write(src)
+        if not src.endswith('\n'):
+            src_sb.write('\n')
+
+        mod = self._build_mod(mod_name, src_sb.getvalue())
+
+        fn = mod.__dict__[name]
+        return fn

{omlish-0.0.0.dev373 → omlish-0.0.0.dev375}/omlish/funcs/match.py

@@ -1,4 +1,6 @@
 """
+Analogous to scala's partial functions ( https://www.scala-lang.org/api/current/scala/PartialFunction.html ).
+
 TODO:
  - unify MatchFnClass with dispatch.method?
   - __call__ = mfs.method(); @__call__.register(lambda: ...) def _call_... ?

{omlish-0.0.0.dev373 → omlish-0.0.0.dev375}/omlish/lang/__init__.py

@@ -173,8 +173,11 @@ from .enums import (  # noqa
     enum_name_repr,
 )
 
+from .errors import (  # noqa
+    DuplicateKeyError,
+)
+
 from .functions import (  # noqa
-    Args,
     VoidError,
     as_async,
     call_with,
@@ -359,6 +362,10 @@ from .typing import (  # noqa
 
 ##
 
+from ..lite.args import (  # noqa
+    Args,
+)
+
 from ..lite.contextmanagers import (  # noqa
     AsyncExitStacked,
     ExitStacked,

{omlish-0.0.0.dev373 → omlish-0.0.0.dev375}/omlish/lang/functions.py

@@ -1,4 +1,3 @@
-import dataclasses as dc
 import functools
 import time
 import types
@@ -210,37 +209,6 @@ def periodically(
 ##
 
 
-@dc.dataclass(init=False)
-class Args:
-    args: ta.Sequence[ta.Any]
-    kwargs: ta.Mapping[str, ta.Any]
-
-    def __init__(self, *args: ta.Any, **kwargs: ta.Any) -> None:
-        super().__init__()
-
-        self.args = args
-        self.kwargs = kwargs
-
-    def __bool__(self) -> bool:
-        return bool(self.args) or bool(self.kwargs)
-
-    def update(self, *args: ta.Any, **kwargs: ta.Any) -> 'Args':
-        return Args(
-            *self.args,
-            *args,
-            **{
-                **self.kwargs,
-                **kwargs,
-            },
-        )
-
-    def __call__(self, fn: ta.Callable[..., T]) -> T:
-        return fn(*self.args, **self.kwargs)
-
-
-##
-
-
 def coalesce(*vs: T | None) -> T:
     for v in vs:
         if v is not None:

{omlish-0.0.0.dev373 → omlish-0.0.0.dev375}/omlish/lite/__init__.py

@@ -1,5 +1,5 @@
 # @omlish-lite
 """
-These are the 'core' lite modules. These generally have a 'full' equivalent, in which case non-lite code should prefer
+These are the 'core' lite modules. These generally have a 'full' equivalent, in which case standard code should prefer
 that.
 """

omlish-0.0.0.dev375/omlish/lite/args.py

@@ -0,0 +1,36 @@
+import dataclasses as dc
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@dc.dataclass(init=False)
+class Args:
+    args: ta.Sequence[ta.Any]
+    kwargs: ta.Mapping[str, ta.Any]
+
+    def __init__(self, *args: ta.Any, **kwargs: ta.Any) -> None:
+        super().__init__()
+
+        self.args = args
+        self.kwargs = kwargs
+
+    def __bool__(self) -> bool:
+        return bool(self.args) or bool(self.kwargs)
+
+    def update(self, *args: ta.Any, **kwargs: ta.Any) -> 'Args':
+        return Args(
+            *self.args,
+            *args,
+            **{
+                **self.kwargs,
+                **kwargs,
+            },
+        )
+
+    def __call__(self, fn: ta.Callable[..., T]) -> T:
+        return fn(*self.args, **self.kwargs)

{omlish-0.0.0.dev373 → omlish-0.0.0.dev375}/omlish/lite/json.py

@@ -12,7 +12,7 @@ JSON_PRETTY_KWARGS: ta.Mapping[str, ta.Any] = dict(
     indent=JSON_PRETTY_INDENT,
 )
 
-json_dump_pretty: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_PRETTY_KWARGS)  # type: ignore
+json_dump_pretty: ta.Callable[..., None] = functools.partial(json.dump, **JSON_PRETTY_KWARGS)
 json_dumps_pretty: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_PRETTY_KWARGS)
 
 
@@ -26,5 +26,5 @@ JSON_COMPACT_KWARGS: ta.Mapping[str, ta.Any] = dict(
     separators=JSON_COMPACT_SEPARATORS,
 )
 
-json_dump_compact: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_COMPACT_KWARGS)  # type: ignore
+json_dump_compact: ta.Callable[..., None] = functools.partial(json.dump, **JSON_COMPACT_KWARGS)
 json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)

{omlish-0.0.0.dev373 → omlish-0.0.0.dev375}/omlish/testing/unittest/loading.py

@@ -43,13 +43,13 @@ import types
 import typing as ta
 import unittest
 
-from .types import Test
+from .types import UnittestTest
 
 
 ##
 
 
-class TestTargetLoader:
+class UnittestTargetLoader:
     def __init__(
             self,
             *,
@@ -81,7 +81,7 @@ class TestTargetLoader:
         pattern: ta.Optional[str] = None
         top: ta.Optional[str] = None
 
-    def load(self, target: Target) -> Test:
+    def load(self, target: Target) -> UnittestTest:
         loader = self._loader
         if loader is None:
             loader = unittest.loader.TestLoader()
@@ -89,8 +89,8 @@ class TestTargetLoader:
         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(
+        if isinstance(target, UnittestTargetLoader.DiscoveryTarget):
+            return ta.cast(UnittestTest, loader.discover(
                 target.start,  # type: ignore[arg-type]
                 target.pattern,  # type: ignore[arg-type]
                 target.top,
@@ -102,11 +102,11 @@ class TestTargetLoader:
             for part in module.split('.')[1:]:
                 module = getattr(module, part)
 
-        if isinstance(target, TestTargetLoader.ModuleTarget):
-            return ta.cast(Test, loader.loadTestsFromModule(module))
+        if isinstance(target, UnittestTargetLoader.ModuleTarget):
+            return ta.cast(UnittestTest, loader.loadTestsFromModule(module))
 
-        elif isinstance(target, TestTargetLoader.NamesTarget):
-            return ta.cast(Test, loader.loadTestsFromNames(
+        elif isinstance(target, UnittestTargetLoader.NamesTarget):
+            return ta.cast(UnittestTest, loader.loadTestsFromNames(
                 target.test_names,  # type: ignore[arg-type]
                 module,
             ))

{omlish-0.0.0.dev373 → omlish-0.0.0.dev375}/omlish/testing/unittest/main.py

@@ -2,6 +2,9 @@
 """
 https://docs.python.org/3/library/unittest.html#command-line-interface
 ~ https://github.com/python/cpython/tree/f66c75f11d3aeeb614600251fd5d3fe1a34b5ff1/Lib/unittest
+
+TODO:
+ - giving it filenames doesn't work
 """
 # PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
 # --------------------------------------------
@@ -46,25 +49,14 @@ import sys
 import types
 import typing as ta
 
-from .loading import TestTargetLoader
-from .running import TestRunner
+from .loading import UnittestTargetLoader
+from .running import UnittestTestRunner
 
 
 ##
 
 
-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:
+class UnittestRunCli:
     def __init__(self) -> None:
         super().__init__()
 
@@ -192,9 +184,22 @@ class TestRunCli:
 
     #
 
+    @staticmethod
+    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
+        }
+
+    #
+
     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:
+    def _build_target(self, name: str, args: ParsedArgs) -> UnittestTargetLoader.Target:
         is_discovery = False
         if os.path.isdir(name):
             is_discovery = True
@@ -204,12 +209,12 @@ class TestRunCli:
                 is_discovery = True
 
         if not is_discovery:
-            return TestTargetLoader.NamesTarget([name])
+            return UnittestTargetLoader.NamesTarget([name])
 
         else:
-            return TestTargetLoader.DiscoveryTarget(
+            return UnittestTargetLoader.DiscoveryTarget(
                 start=name,
-                **_get_attr_dict(
+                **self._get_attr_dict(
                     args.args,
                     'pattern',
                     'top',
@@ -226,7 +231,7 @@ class TestRunCli:
             *,
             exit: bool = False,  # noqa
     ) -> None:
-        loader = TestTargetLoader(**_get_attr_dict(
+        loader = UnittestTargetLoader(**self._get_attr_dict(
             args.args,
             'test_name_patterns',
         ))
@@ -236,7 +241,7 @@ class TestRunCli:
             for target_arg in (args.args.target if args.args is not None else None) or []  # noqa
         ]
 
-        runner = TestRunner(TestRunner.Args(**_get_attr_dict(
+        runner = UnittestTestRunner(UnittestTestRunner.Args(**self._get_attr_dict(
             args.args,
             'verbosity',
             'failfast',
@@ -263,7 +268,7 @@ class TestRunCli:
 
 
 def _main() -> None:
-    cli = TestRunCli()
+    cli = UnittestRunCli()
     args = cli.parse_args(sys.argv[1:])
     cli.run(args, exit=True)