omdev 0.0.0.dev403__py3-none-any.whl → 0.0.0.dev405__py3-none-any.whl

omdev/.manifests.json

@@ -236,7 +236,7 @@
     "module": ".py.scripts.execstat",
     "attr": "_CLI_MODULE",
     "file": "omdev/py/scripts/execstat.py",
-    "line": 84,
+    "line": 89,
     "value": {
       "$.cli.types.CliModule": {
         "cmd_name": "py/execstat",
@@ -404,7 +404,7 @@
     "module": ".tools.git.messages",
     "attr": "_TIMESTAMP_GIT_MESSAGE_GENERATOR_MANIFEST",
     "file": "omdev/tools/git/messages.py",
-    "line": 85,
+    "line": 81,
     "value": {
       "$.tools.git.messages.GitMessageGeneratorManifest": {
         "mod_name": "omdev.tools.git.messages",

omdev/cli/main.py

@@ -6,7 +6,6 @@ TODO:
 """
 import argparse
 import dataclasses as dc
-import os
 import runpy
 import sys
 import typing as ta
@@ -184,26 +183,24 @@ def _build_arg_parser() -> argparse.ArgumentParser:
 
 
 def _build_cmd_set(args: ta.Any) -> CliCmdSet:
-    ldr = ManifestLoader(
-        **ManifestLoader.kwargs_from_entry_point(
-            globals(),
-            **GlobalManifestLoader.default_kwargs(),
-        ),
-    )
+    ldr_cfg = GlobalManifestLoader.default_config()
 
-    #
+    ldr_cfg |= ManifestLoader.config_from_entry_point(globals())
+
+    if args.cli_pkg_root:
+        ldr_cfg |= ManifestLoader.Config(
+            package_scan_root_dirs=args.cli_pkg_root,
+            discover_packages=False,
+        )
 
-    pkgs = ldr.scan_or_discover_packages(
-        specified_root_dirs=args.cli_pkg_root,
-        fallback_root_dir=os.getcwd(),
-    )
+    GlobalManifestLoader.initialize(ldr_cfg)
 
     #
 
     lst: list[CliCmd] = []
 
-    for m in ldr.load(*pkgs, only=[CliModule]):
-        lst.append(check.isinstance(m.value(), CliModule))
+    for mv in GlobalManifestLoader.load_values_of(CliModule):
+        lst.append(check.isinstance(mv, CliModule))
 
     lst.extend(_CLI_FUNCS)
 

omdev/precheck/manifests.py

@@ -23,6 +23,6 @@ class ManifestsPrecheck(Precheck['ManifestsPrecheck.Config']):
     async def run(self) -> ta.AsyncGenerator[Precheck.Violation]:
         for src_root in sorted(self._context.src_roots):
             try:
-                GlobalManifestLoader.load(src_root)
+                GlobalManifestLoader.load(packages=[src_root])
             except Exception as e:  # noqa
                 yield Precheck.Violation(self, f'Error loading manifest for {src_root}: {e!r}')

omdev/py/scripts/execstat.py

@@ -1,11 +1,16 @@
 #!/usr/bin/env python3
+# ruff: noqa: UP045
+# @omlish-lite
 # @omlish-script
 import argparse
 import inspect
 import json
+import os.path
 import statistics
 import subprocess
 import sys
+import tempfile
+import typing as ta
 
 
 ##
@@ -14,7 +19,7 @@ import sys
 def _run(
         src: str,
         *,
-        setup: str | None = None,
+        setup: 'ta.Optional[str]' = None,
         time: bool = False,
         rss: bool = False,
         modules: bool = False,
@@ -31,8 +36,8 @@ def _run(
     if modules:
         import sys  # noqa
 
-        def get_modules() -> set[str]:
-            return set(sys.modules)
+        def get_modules() -> 'ta.Sequence[str]':
+            return list(sys.modules)
 
     #
 
@@ -49,7 +54,7 @@ def _run(
         start_rss = get_rss()  # noqa
 
     if modules:
-        start_modules = get_modules()  # noqa
+        start_modules = set(get_modules())  # noqa
 
     if time:
         start_time = get_time()  # noqa
@@ -74,7 +79,7 @@ def _run(
     return {
         **({'time': (end_time - start_time)} if time else {}),  # noqa
         **({'rss': (end_rss - start_rss)} if rss else {}),  # noqa
-        **({'modules': sorted(end_modules - start_modules)} if modules else {}),  # noqa
+        **({'modules': [m for m in end_modules if m not in start_modules]} if modules else {}),  # noqa
     }
 
 
@@ -97,11 +102,14 @@ def _main() -> None:
     parser.add_argument('-t', '--time', action='store_true')
     parser.add_argument('-r', '--rss', action='store_true')
     parser.add_argument('-m', '--modules', action='store_true')
+    parser.add_argument('-M', '--modules-ordered', action='store_true')
 
     parser.add_argument('-n', '--num-runs', type=int, default=1)
 
     parser.add_argument('-P', '--precision', type=int, default=3)
 
+    parser.add_argument('--out-dir')
+
     parser.add_argument('-x', '--exe')
 
     args = parser.parse_args()
@@ -116,8 +124,13 @@ def _main() -> None:
     if (exe := args.exe) is None:
         exe = sys.executable
 
+    if (out_dir := args.out_dir) is None:
+        out_dir = tempfile.mkdtemp()
+
     results = []
     for i in range(n):
+        out_file = os.path.join(out_dir, f'{str(i).zfill(len(str(n)))}.json')
+
         run_kw = dict(
             src=args.src,
             setup=args.setup,
@@ -127,17 +140,21 @@ def _main() -> None:
         if i == 0:
             run_kw.update(
                 rss=bool(args.rss),
-                modules=bool(args.modules),
+                modules=bool(args.modules) or bool(args.modules),
             )
 
         payload = '\n'.join([
             inspect.getsource(_run),
             f'dct = _run(**{run_kw!r})',
-            'import json',
-            'print(json.dumps(dct))',
+            f'import json',
+            f'with open({out_file!r}, "w") as f:',  # noqa
+            f'    print(f.write(json.dumps(dct)))',
         ])
 
-        result = json.loads(subprocess.check_output([exe, '-c', payload]))
+        subprocess.check_call([exe, '-c', payload])
+
+        with open(out_file) as f:
+            result = json.load(f)
 
         results.append(result)
 
@@ -170,7 +187,11 @@ def _main() -> None:
 
     if args.modules:
         out.update({
-            'modules': results[0]['modules'],
+            'modules': sorted(results[0]['modules']),
+        })
+    if args.modules_ordered:
+        out.update({
+            'modules_ordered': results[0]['modules'],
         })
 
     print(json.dumps(out, indent=2))

omdev/scripts/ci.py

@@ -99,6 +99,10 @@ CheckOnRaiseFn = ta.Callable[[Exception], None]  # ta.TypeAlias
 CheckExceptionFactory = ta.Callable[..., Exception]  # ta.TypeAlias
 CheckArgsRenderer = ta.Callable[..., ta.Optional[str]]  # ta.TypeAlias
 
+# ../../omlish/lite/contextmanagers.py
+ExitStackedT = ta.TypeVar('ExitStackedT', bound='ExitStacked')
+AsyncExitStackedT = ta.TypeVar('AsyncExitStackedT', bound='AsyncExitStacked')
+
 # ../../omlish/lite/maybes.py
 U = ta.TypeVar('U')
 
@@ -121,10 +125,6 @@ AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
 # ../../omlish/http/parsing.py
 HttpHeaders = http.client.HTTPMessage  # ta.TypeAlias
 
-# ../../omlish/lite/contextmanagers.py
-ExitStackedT = ta.TypeVar('ExitStackedT', bound='ExitStacked')
-AsyncExitStackedT = ta.TypeVar('AsyncExitStackedT', bound='AsyncExitStacked')
-
 # ../../omlish/lite/inject.py
 InjectorKeyCls = ta.Union[type, ta.NewType]
 InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
@@ -1026,6 +1026,201 @@ class Checks:
 check = Checks()
 
 
+########################################
+# ../../../omlish/lite/contextmanagers.py
+
+
+##
+
+
+class ExitStacked:
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        for a in ('__enter__', '__exit__'):
+            for b in cls.__bases__:
+                if b is ExitStacked:
+                    continue
+                try:
+                    fn = getattr(b, a)
+                except AttributeError:
+                    pass
+                else:
+                    if fn is not getattr(ExitStacked, a):
+                        raise TypeError(f'ExitStacked subclass {cls} must not not override {a} via {b}')
+
+    _exit_stack: ta.Optional[contextlib.ExitStack] = None
+
+    @contextlib.contextmanager
+    def _exit_stacked_init_wrapper(self) -> ta.Iterator[None]:
+        """
+        Overridable wrapper around __enter__ which deliberately does not have access to an _exit_stack yet. Intended for
+        things like wrapping __enter__ in a lock.
+        """
+
+        yield
+
+    @ta.final
+    def __enter__(self: ExitStackedT) -> ExitStackedT:
+        """
+        Final because any contexts entered during this init must be exited if any exception is thrown, and user
+        overriding would likely interfere with that. Override `_enter_contexts` for such init.
+        """
+
+        with self._exit_stacked_init_wrapper():
+            if self._exit_stack is not None:
+                raise RuntimeError
+            es = self._exit_stack = contextlib.ExitStack()
+            es.__enter__()
+            try:
+                self._enter_contexts()
+            except Exception:  # noqa
+                es.__exit__(*sys.exc_info())
+                raise
+            return self
+
+    @ta.final
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if (es := self._exit_stack) is None:
+            return None
+        try:
+            self._exit_contexts()
+        except Exception:  # noqa
+            es.__exit__(*sys.exc_info())
+            raise
+        return es.__exit__(exc_type, exc_val, exc_tb)
+
+    def _enter_contexts(self) -> None:
+        pass
+
+    def _exit_contexts(self) -> None:
+        pass
+
+    def _enter_context(self, cm: ta.ContextManager[T]) -> T:
+        if (es := self._exit_stack) is None:
+            raise RuntimeError
+        return es.enter_context(cm)
+
+
+class AsyncExitStacked:
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        for a in ('__aenter__', '__aexit__'):
+            for b in cls.__bases__:
+                if b is AsyncExitStacked:
+                    continue
+                try:
+                    fn = getattr(b, a)
+                except AttributeError:
+                    pass
+                else:
+                    if fn is not getattr(AsyncExitStacked, a):
+                        raise TypeError(f'AsyncExitStacked subclass {cls} must not not override {a} via {b}')
+
+    _exit_stack: ta.Optional[contextlib.AsyncExitStack] = None
+
+    @contextlib.asynccontextmanager
+    async def _async_exit_stacked_init_wrapper(self) -> ta.AsyncGenerator[None, None]:
+        yield
+
+    @ta.final
+    async def __aenter__(self: AsyncExitStackedT) -> AsyncExitStackedT:
+        async with self._async_exit_stacked_init_wrapper():
+            if self._exit_stack is not None:
+                raise RuntimeError
+            es = self._exit_stack = contextlib.AsyncExitStack()
+            await es.__aenter__()
+            try:
+                await self._async_enter_contexts()
+            except Exception:  # noqa
+                await es.__aexit__(*sys.exc_info())
+                raise
+            return self
+
+    @ta.final
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if (es := self._exit_stack) is None:
+            return None
+        try:
+            await self._async_exit_contexts()
+        except Exception:  # noqa
+            await es.__aexit__(*sys.exc_info())
+            raise
+        return await es.__aexit__(exc_type, exc_val, exc_tb)
+
+    async def _async_enter_contexts(self) -> None:
+        pass
+
+    async def _async_exit_contexts(self) -> None:
+        pass
+
+    def _enter_context(self, cm: ta.ContextManager[T]) -> T:
+        if (es := self._exit_stack) is None:
+            raise RuntimeError
+        return es.enter_context(cm)
+
+    async def _enter_async_context(self, cm: ta.AsyncContextManager[T]) -> T:
+        if (es := self._exit_stack) is None:
+            raise RuntimeError
+        return await es.enter_async_context(cm)
+
+
+##
+
+
+@contextlib.contextmanager
+def defer(fn: ta.Callable, *args: ta.Any, **kwargs: ta.Any) -> ta.Generator[ta.Callable, None, None]:
+    if args or kwargs:
+        fn = functools.partial(fn, *args, **kwargs)
+    try:
+        yield fn
+    finally:
+        fn()
+
+
+@contextlib.asynccontextmanager
+async def adefer(fn: ta.Awaitable) -> ta.AsyncGenerator[ta.Awaitable, None]:
+    try:
+        yield fn
+    finally:
+        await fn
+
+
+##
+
+
+@contextlib.contextmanager
+def attr_setting(obj, attr, val, *, default=None):  # noqa
+    not_set = object()
+    orig = getattr(obj, attr, not_set)
+    try:
+        setattr(obj, attr, val)
+        if orig is not not_set:
+            yield orig
+        else:
+            yield default
+    finally:
+        if orig is not_set:
+            delattr(obj, attr)
+        else:
+            setattr(obj, attr, orig)
+
+
+##
+
+
+class aclosing(contextlib.AbstractAsyncContextManager):  # noqa
+    def __init__(self, thing):
+        self.thing = thing
+
+    async def __aenter__(self):
+        return self.thing
+
+    async def __aexit__(self, *exc_info):
+        await self.thing.aclose()
+
+
 ########################################
 # ../../../omlish/lite/dataclasses.py
 
@@ -2721,53 +2916,251 @@ class OciDataRefInfo:
 
 
 ########################################
-# ../../../omlish/argparse/cli.py
-"""
-FIXME:
- - exit_on_error lol
-
-TODO:
- - default command
- - auto match all underscores to hyphens
- - pre-run, post-run hooks
- - exitstack?
- - suggestion - difflib.get_close_matches
-"""
+# ../../oci/pack/unpacking.py
 
 
 ##
 
 
-@dc.dataclass(eq=False)
-class ArgparseArg:
-    args: ta.Sequence[ta.Any]
-    kwargs: ta.Mapping[str, ta.Any]
-    dest: ta.Optional[str] = None
-
-    def __get__(self, instance, owner=None):
-        if instance is None:
-            return self
-        return getattr(instance.args, self.dest)  # type: ignore
-
+class OciLayerUnpacker(ExitStacked):
+    def __init__(
+            self,
+            input_files: ta.Sequence[ta.Union[str, tarfile.TarFile]],
+            output_file_path: str,
+    ) -> None:
+        super().__init__()
 
-def argparse_arg(*args, **kwargs) -> ArgparseArg:
-    return ArgparseArg(args, kwargs)
+        self._input_files = list(input_files)
+        self._output_file_path = output_file_path
 
+    #
 
-def argparse_arg_(*args, **kwargs) -> ta.Any:
-    return argparse_arg(*args, **kwargs)
+    @contextlib.contextmanager
+    def _open_input_file(self, input_file: ta.Union[str, tarfile.TarFile]) -> ta.Iterator[tarfile.TarFile]:
+        if isinstance(input_file, tarfile.TarFile):
+            yield input_file
 
+        elif isinstance(input_file, str):
+            with tarfile.open(input_file) as tar_file:
+                yield tar_file
 
-#
+        else:
+            raise TypeError(input_file)
 
+    #
 
-@dc.dataclass(eq=False)
-class ArgparseCmd:
-    name: str
-    fn: ArgparseCmdFn
-    args: ta.Sequence[ArgparseArg] = ()  # noqa
+    class _Entry(ta.NamedTuple):
+        file: ta.Union[str, tarfile.TarFile]
+        info: tarfile.TarInfo
 
-    # _: dc.KW_ONLY
+    def _build_input_file_sorted_entries(self, input_file: ta.Union[str, tarfile.TarFile]) -> ta.Sequence[_Entry]:
+        dct: ta.Dict[str, OciLayerUnpacker._Entry] = {}
+
+        with self._open_input_file(input_file) as input_tar_file:
+            for info in input_tar_file.getmembers():
+                check.not_in(info.name, dct)
+                dct[info.name] = self._Entry(
+                    file=input_file,
+                    info=info,
+                )
+
+        return sorted(dct.values(), key=lambda entry: entry.info.name)
+
+    @cached_nullary
+    def _entries_by_name(self) -> ta.Mapping[str, _Entry]:
+        root: dict = {}
+
+        def find_dir(dir_name: str) -> dict:  # noqa
+            if dir_name:
+                dir_parts = dir_name.split('/')
+            else:
+                dir_parts = []
+
+            cur = root  # noqa
+            for dir_part in dir_parts:
+                cur = cur[dir_part]  # noqa
+
+            return check.isinstance(cur, dict)
+
+        #
+
+        for input_file in self._input_files:
+            sorted_entries = self._build_input_file_sorted_entries(input_file)
+
+            wh_names = set()
+            wh_opaques = set()
+
+            #
+
+            for entry in sorted_entries:
+                info = entry.info
+                name = check.non_empty_str(info.name)
+                base_name = os.path.basename(name)
+                dir_name = os.path.dirname(name)
+
+                if base_name == '.wh..wh..opq':
+                    wh_opaques.add(dir_name)
+                    continue
+
+                if base_name.startswith('.wh.'):
+                    wh_base_name = os.path.basename(base_name[4:])
+                    wh_name = os.path.join(dir_name, wh_base_name)
+                    wh_names.add(wh_name)
+                    continue
+
+                cur = find_dir(dir_name)
+
+                if info.type == tarfile.DIRTYPE:
+                    try:
+                        ex = cur[base_name]
+                    except KeyError:
+                        cur[base_name] = {'': entry}
+                    else:
+                        ex[''] = entry
+
+                else:
+                    cur[base_name] = entry
+
+            #
+
+            for wh_name in reversed(sorted(wh_names)):  # noqa
+                wh_dir_name = os.path.dirname(wh_name)
+                wh_base_name = os.path.basename(wh_name)
+
+                cur = find_dir(wh_dir_name)
+                rm = cur[wh_base_name]
+
+                if isinstance(rm, dict):
+                    # Whiteouts wipe out whole directory:
+                    # https://github.com/containerd/containerd/blob/59c8cf6ea5f4175ad512914dd5ce554942bf144f/pkg/archive/tar_test.go#L648
+                    # check.equal(set(rm), '')
+                    del cur[wh_base_name]
+
+                elif isinstance(rm, self._Entry):
+                    del cur[wh_base_name]
+
+                else:
+                    raise TypeError(rm)
+
+            if wh_opaques:
+                raise NotImplementedError
+
+        #
+
+        out: ta.Dict[str, OciLayerUnpacker._Entry] = {}
+
+        def rec(cur):  # noqa
+            for _, child in sorted(cur.items(), key=lambda t: t[0]):
+                if isinstance(child, dict):
+                    rec(child)
+
+                elif isinstance(child, self._Entry):
+                    check.not_in(child.info.name, out)
+                    out[child.info.name] = child
+
+                else:
+                    raise TypeError(child)
+
+        rec(root)
+
+        return out
+
+    #
+
+    @cached_nullary
+    def _output_tar_file(self) -> tarfile.TarFile:
+        return self._enter_context(tarfile.open(self._output_file_path, 'w'))
+
+    #
+
+    def _add_unpacked_entry(
+            self,
+            input_tar_file: tarfile.TarFile,
+            info: tarfile.TarInfo,
+    ) -> None:
+        base_name = os.path.basename(info.name)
+        check.state(not base_name.startswith('.wh.'))
+
+        if info.type in tarfile.REGULAR_TYPES:
+            with check.not_none(input_tar_file.extractfile(info)) as f:
+                self._output_tar_file().addfile(info, f)
+
+        else:
+            self._output_tar_file().addfile(info)
+
+    def _unpack_file(
+            self,
+            input_file: ta.Union[str, tarfile.TarFile],
+    ) -> None:
+        entries_by_name = self._entries_by_name()
+
+        with self._open_input_file(input_file) as input_tar_file:
+            info: tarfile.TarInfo
+            for info in input_tar_file.getmembers():
+                try:
+                    entry = entries_by_name[info.name]
+                except KeyError:
+                    continue
+
+                if entry.file != input_file:
+                    continue
+
+                self._add_unpacked_entry(input_tar_file, info)
+
+    @cached_nullary
+    def write(self) -> None:
+        for input_file in self._input_files:
+            self._unpack_file(input_file)
+
+
+########################################
+# ../../../omlish/argparse/cli.py
+"""
+FIXME:
+ - exit_on_error lol
+
+TODO:
+ - default command
+ - auto match all underscores to hyphens
+ - pre-run, post-run hooks
+ - exitstack?
+ - suggestion - difflib.get_close_matches
+"""
+
+
+##
+
+
+@dc.dataclass(eq=False)
+class ArgparseArg:
+    args: ta.Sequence[ta.Any]
+    kwargs: ta.Mapping[str, ta.Any]
+    dest: ta.Optional[str] = None
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        return getattr(instance.args, self.dest)  # type: ignore
+
+
+def argparse_arg(*args, **kwargs) -> ArgparseArg:
+    return ArgparseArg(args, kwargs)
+
+
+def argparse_arg_(*args, **kwargs) -> ta.Any:
+    return argparse_arg(*args, **kwargs)
+
+
+#
+
+
+@dc.dataclass(eq=False)
+class ArgparseCmd:
+    name: str
+    fn: ArgparseCmdFn
+    args: ta.Sequence[ArgparseArg] = ()  # noqa
+
+    # _: dc.KW_ONLY
 
     aliases: ta.Optional[ta.Sequence[str]] = None
     parent: ta.Optional['ArgparseCmd'] = None
@@ -3447,239 +3840,49 @@ class HttpRequestParser:
             return ParseHttpRequestError(
                 code=http.HTTPStatus.REQUEST_HEADER_FIELDS_TOO_LARGE,
                 message=('Line too long', str(err)),
-                **result_kwargs(),
-            )
-
-        except http.client.HTTPException as err:
-            return ParseHttpRequestError(
-                code=http.HTTPStatus.REQUEST_HEADER_FIELDS_TOO_LARGE,
-                message=('Too many headers', str(err)),
-                **result_kwargs(),
-            )
-
-        # Check for connection directive
-
-        conn_type = headers.get('Connection', '')
-        if conn_type.lower() == 'close':
-            close_connection = True
-        elif (
-                conn_type.lower() == 'keep-alive' and
-                version >= HttpProtocolVersions.HTTP_1_1
-        ):
-            close_connection = False
-
-        # Check for expect directive
-
-        expect = headers.get('Expect', '')
-        if (
-                expect.lower() == '100-continue' and
-                version >= HttpProtocolVersions.HTTP_1_1
-        ):
-            expects_continue = True
-        else:
-            expects_continue = False
-
-        # Return
-
-        return ParsedHttpRequest(
-            method=method,
-            path=path,
-            expects_continue=expects_continue,
-            **result_kwargs(),
-        )
-
-    def parse(self, read_line: ta.Callable[[int], bytes]) -> ParseHttpRequestResult:
-        return self._run_read_line_coro(self.coro_parse(), read_line)
-
-
-########################################
-# ../../../omlish/lite/contextmanagers.py
-
-
-##
-
-
-class ExitStacked:
-    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
-        super().__init_subclass__(**kwargs)
-
-        for a in ('__enter__', '__exit__'):
-            for b in cls.__bases__:
-                if b is ExitStacked:
-                    continue
-                try:
-                    fn = getattr(b, a)
-                except AttributeError:
-                    pass
-                else:
-                    if fn is not getattr(ExitStacked, a):
-                        raise TypeError(f'ExitStacked subclass {cls} must not not override {a} via {b}')
-
-    _exit_stack: ta.Optional[contextlib.ExitStack] = None
-
-    @contextlib.contextmanager
-    def _exit_stacked_init_wrapper(self) -> ta.Iterator[None]:
-        """
-        Overridable wrapper around __enter__ which deliberately does not have access to an _exit_stack yet. Intended for
-        things like wrapping __enter__ in a lock.
-        """
-
-        yield
-
-    @ta.final
-    def __enter__(self: ExitStackedT) -> ExitStackedT:
-        """
-        Final because any contexts entered during this init must be exited if any exception is thrown, and user
-        overriding would likely interfere with that. Override `_enter_contexts` for such init.
-        """
-
-        with self._exit_stacked_init_wrapper():
-            check.state(self._exit_stack is None)
-            es = self._exit_stack = contextlib.ExitStack()
-            es.__enter__()
-            try:
-                self._enter_contexts()
-            except Exception:  # noqa
-                es.__exit__(*sys.exc_info())
-                raise
-            return self
-
-    @ta.final
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if (es := self._exit_stack) is None:
-            return None
-        try:
-            self._exit_contexts()
-        except Exception:  # noqa
-            es.__exit__(*sys.exc_info())
-            raise
-        return es.__exit__(exc_type, exc_val, exc_tb)
-
-    def _enter_contexts(self) -> None:
-        pass
-
-    def _exit_contexts(self) -> None:
-        pass
-
-    def _enter_context(self, cm: ta.ContextManager[T]) -> T:
-        es = check.not_none(self._exit_stack)
-        return es.enter_context(cm)
-
-
-class AsyncExitStacked:
-    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
-        super().__init_subclass__(**kwargs)
-
-        for a in ('__aenter__', '__aexit__'):
-            for b in cls.__bases__:
-                if b is AsyncExitStacked:
-                    continue
-                try:
-                    fn = getattr(b, a)
-                except AttributeError:
-                    pass
-                else:
-                    if fn is not getattr(AsyncExitStacked, a):
-                        raise TypeError(f'AsyncExitStacked subclass {cls} must not not override {a} via {b}')
-
-    _exit_stack: ta.Optional[contextlib.AsyncExitStack] = None
-
-    @contextlib.asynccontextmanager
-    async def _async_exit_stacked_init_wrapper(self) -> ta.AsyncGenerator[None, None]:
-        yield
-
-    @ta.final
-    async def __aenter__(self: AsyncExitStackedT) -> AsyncExitStackedT:
-        async with self._async_exit_stacked_init_wrapper():
-            check.state(self._exit_stack is None)
-            es = self._exit_stack = contextlib.AsyncExitStack()
-            await es.__aenter__()
-            try:
-                await self._async_enter_contexts()
-            except Exception:  # noqa
-                await es.__aexit__(*sys.exc_info())
-                raise
-            return self
-
-    @ta.final
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        if (es := self._exit_stack) is None:
-            return None
-        try:
-            await self._async_exit_contexts()
-        except Exception:  # noqa
-            await es.__aexit__(*sys.exc_info())
-            raise
-        return await es.__aexit__(exc_type, exc_val, exc_tb)
-
-    async def _async_enter_contexts(self) -> None:
-        pass
-
-    async def _async_exit_contexts(self) -> None:
-        pass
-
-    def _enter_context(self, cm: ta.ContextManager[T]) -> T:
-        es = check.not_none(self._exit_stack)
-        return es.enter_context(cm)
-
-    async def _enter_async_context(self, cm: ta.AsyncContextManager[T]) -> T:
-        es = check.not_none(self._exit_stack)
-        return await es.enter_async_context(cm)
-
-
-##
-
-
-@contextlib.contextmanager
-def defer(fn: ta.Callable, *args: ta.Any, **kwargs: ta.Any) -> ta.Generator[ta.Callable, None, None]:
-    if args or kwargs:
-        fn = functools.partial(fn, *args, **kwargs)
-    try:
-        yield fn
-    finally:
-        fn()
-
-
-@contextlib.asynccontextmanager
-async def adefer(fn: ta.Awaitable) -> ta.AsyncGenerator[ta.Awaitable, None]:
-    try:
-        yield fn
-    finally:
-        await fn
-
-
-##
+                **result_kwargs(),
+            )
 
+        except http.client.HTTPException as err:
+            return ParseHttpRequestError(
+                code=http.HTTPStatus.REQUEST_HEADER_FIELDS_TOO_LARGE,
+                message=('Too many headers', str(err)),
+                **result_kwargs(),
+            )
 
-@contextlib.contextmanager
-def attr_setting(obj, attr, val, *, default=None):  # noqa
-    not_set = object()
-    orig = getattr(obj, attr, not_set)
-    try:
-        setattr(obj, attr, val)
-        if orig is not not_set:
-            yield orig
-        else:
-            yield default
-    finally:
-        if orig is not_set:
-            delattr(obj, attr)
-        else:
-            setattr(obj, attr, orig)
+        # Check for connection directive
 
+        conn_type = headers.get('Connection', '')
+        if conn_type.lower() == 'close':
+            close_connection = True
+        elif (
+                conn_type.lower() == 'keep-alive' and
+                version >= HttpProtocolVersions.HTTP_1_1
+        ):
+            close_connection = False
 
-##
+        # Check for expect directive
 
+        expect = headers.get('Expect', '')
+        if (
+                expect.lower() == '100-continue' and
+                version >= HttpProtocolVersions.HTTP_1_1
+        ):
+            expects_continue = True
+        else:
+            expects_continue = False
 
-class aclosing(contextlib.AbstractAsyncContextManager):  # noqa
-    def __init__(self, thing):
-        self.thing = thing
+        # Return
 
-    async def __aenter__(self):
-        return self.thing
+        return ParsedHttpRequest(
+            method=method,
+            path=path,
+            expects_continue=expects_continue,
+            **result_kwargs(),
+        )
 
-    async def __aexit__(self, *exc_info):
-        await self.thing.aclose()
+    def parse(self, read_line: ta.Callable[[int], bytes]) -> ParseHttpRequestResult:
+        return self._run_read_line_coro(self.coro_parse(), read_line)
 
 
 ########################################
@@ -7374,204 +7577,6 @@ def get_single_oci_image_manifest(image_index: OciImageIndex) -> OciImageManifes
     return check.isinstance(child_index, OciImageManifest)
 
 
-########################################
-# ../../oci/pack/unpacking.py
-
-
-##
-
-
-class OciLayerUnpacker(ExitStacked):
-    def __init__(
-            self,
-            input_files: ta.Sequence[ta.Union[str, tarfile.TarFile]],
-            output_file_path: str,
-    ) -> None:
-        super().__init__()
-
-        self._input_files = list(input_files)
-        self._output_file_path = output_file_path
-
-    #
-
-    @contextlib.contextmanager
-    def _open_input_file(self, input_file: ta.Union[str, tarfile.TarFile]) -> ta.Iterator[tarfile.TarFile]:
-        if isinstance(input_file, tarfile.TarFile):
-            yield input_file
-
-        elif isinstance(input_file, str):
-            with tarfile.open(input_file) as tar_file:
-                yield tar_file
-
-        else:
-            raise TypeError(input_file)
-
-    #
-
-    class _Entry(ta.NamedTuple):
-        file: ta.Union[str, tarfile.TarFile]
-        info: tarfile.TarInfo
-
-    def _build_input_file_sorted_entries(self, input_file: ta.Union[str, tarfile.TarFile]) -> ta.Sequence[_Entry]:
-        dct: ta.Dict[str, OciLayerUnpacker._Entry] = {}
-
-        with self._open_input_file(input_file) as input_tar_file:
-            for info in input_tar_file.getmembers():
-                check.not_in(info.name, dct)
-                dct[info.name] = self._Entry(
-                    file=input_file,
-                    info=info,
-                )
-
-        return sorted(dct.values(), key=lambda entry: entry.info.name)
-
-    @cached_nullary
-    def _entries_by_name(self) -> ta.Mapping[str, _Entry]:
-        root: dict = {}
-
-        def find_dir(dir_name: str) -> dict:  # noqa
-            if dir_name:
-                dir_parts = dir_name.split('/')
-            else:
-                dir_parts = []
-
-            cur = root  # noqa
-            for dir_part in dir_parts:
-                cur = cur[dir_part]  # noqa
-
-            return check.isinstance(cur, dict)
-
-        #
-
-        for input_file in self._input_files:
-            sorted_entries = self._build_input_file_sorted_entries(input_file)
-
-            wh_names = set()
-            wh_opaques = set()
-
-            #
-
-            for entry in sorted_entries:
-                info = entry.info
-                name = check.non_empty_str(info.name)
-                base_name = os.path.basename(name)
-                dir_name = os.path.dirname(name)
-
-                if base_name == '.wh..wh..opq':
-                    wh_opaques.add(dir_name)
-                    continue
-
-                if base_name.startswith('.wh.'):
-                    wh_base_name = os.path.basename(base_name[4:])
-                    wh_name = os.path.join(dir_name, wh_base_name)
-                    wh_names.add(wh_name)
-                    continue
-
-                cur = find_dir(dir_name)
-
-                if info.type == tarfile.DIRTYPE:
-                    try:
-                        ex = cur[base_name]
-                    except KeyError:
-                        cur[base_name] = {'': entry}
-                    else:
-                        ex[''] = entry
-
-                else:
-                    cur[base_name] = entry
-
-            #
-
-            for wh_name in reversed(sorted(wh_names)):  # noqa
-                wh_dir_name = os.path.dirname(wh_name)
-                wh_base_name = os.path.basename(wh_name)
-
-                cur = find_dir(wh_dir_name)
-                rm = cur[wh_base_name]
-
-                if isinstance(rm, dict):
-                    # Whiteouts wipe out whole directory:
-                    # https://github.com/containerd/containerd/blob/59c8cf6ea5f4175ad512914dd5ce554942bf144f/pkg/archive/tar_test.go#L648
-                    # check.equal(set(rm), '')
-                    del cur[wh_base_name]
-
-                elif isinstance(rm, self._Entry):
-                    del cur[wh_base_name]
-
-                else:
-                    raise TypeError(rm)
-
-            if wh_opaques:
-                raise NotImplementedError
-
-        #
-
-        out: ta.Dict[str, OciLayerUnpacker._Entry] = {}
-
-        def rec(cur):  # noqa
-            for _, child in sorted(cur.items(), key=lambda t: t[0]):
-                if isinstance(child, dict):
-                    rec(child)
-
-                elif isinstance(child, self._Entry):
-                    check.not_in(child.info.name, out)
-                    out[child.info.name] = child
-
-                else:
-                    raise TypeError(child)
-
-        rec(root)
-
-        return out
-
-    #
-
-    @cached_nullary
-    def _output_tar_file(self) -> tarfile.TarFile:
-        return self._enter_context(tarfile.open(self._output_file_path, 'w'))
-
-    #
-
-    def _add_unpacked_entry(
-            self,
-            input_tar_file: tarfile.TarFile,
-            info: tarfile.TarInfo,
-    ) -> None:
-        base_name = os.path.basename(info.name)
-        check.state(not base_name.startswith('.wh.'))
-
-        if info.type in tarfile.REGULAR_TYPES:
-            with check.not_none(input_tar_file.extractfile(info)) as f:
-                self._output_tar_file().addfile(info, f)
-
-        else:
-            self._output_tar_file().addfile(info)
-
-    def _unpack_file(
-            self,
-            input_file: ta.Union[str, tarfile.TarFile],
-    ) -> None:
-        entries_by_name = self._entries_by_name()
-
-        with self._open_input_file(input_file) as input_tar_file:
-            info: tarfile.TarInfo
-            for info in input_tar_file.getmembers():
-                try:
-                    entry = entries_by_name[info.name]
-                except KeyError:
-                    continue
-
-                if entry.file != input_file:
-                    continue
-
-                self._add_unpacked_entry(input_tar_file, info)
-
-    @cached_nullary
-    def write(self) -> None:
-        for input_file in self._input_files:
-            self._unpack_file(input_file)
-
-
 ########################################
 # ../../oci/repositories.py
 

omdev/tools/git/messages.py

@@ -1,5 +1,4 @@
 import abc
-import os
 import typing as ta
 
 from omlish import cached
@@ -54,10 +53,7 @@ class StaticGitMessageGeneratorManifest(StaticModAttrManifest, GitMessageGenerat
 
 @cached.function
 def load_message_generator_manifests() -> ta.Sequence[GitMessageGeneratorManifest]:
-    ldr = manifest_globals.GlobalManifestLoader.instance()
-    pkgs = ldr.scan_or_discover_packages(fallback_root_dir=os.getcwd())
-    mfs = ldr.load(*pkgs, only=[GitMessageGeneratorManifest])
-    return [mf.value() for mf in mfs]
+    return manifest_globals.GlobalManifestLoader.load_values_of(GitMessageGeneratorManifest)
 
 
 @cached.function

{omdev-0.0.0.dev403.dist-info → omdev-0.0.0.dev405.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdev
-Version: 0.0.0.dev403
+Version: 0.0.0.dev405
 Summary: omdev
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev403
+Requires-Dist: omlish==0.0.0.dev405
 Provides-Extra: all
 Requires-Dist: black~=25.1; extra == "all"
 Requires-Dist: pycparser~=2.22; extra == "all"

{omdev-0.0.0.dev403.dist-info → omdev-0.0.0.dev405.dist-info}/RECORD

@@ -1,4 +1,4 @@
-omdev/.manifests.json,sha256=oCm2YooCueFdF1vxjY3VXUVdcdJSUf7j5PxXeB4rEgY,12453
+omdev/.manifests.json,sha256=1muOc0K_eLWBw9EE5ei6tFo4OkLFp43sSNnz9AF5m_s,12453
 omdev/__about__.py,sha256=fQNmzSa1MntcPSrzg_Vpo6JRU2RbXik2NqRz0oQCApE,1202
 omdev/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/cmake.py,sha256=9rfSvFHPmKDj9ngvfDB2vK8O-xO_ZwUm7hMKLWA-yOw,4578
@@ -113,7 +113,7 @@ omdev/cli/__main__.py,sha256=mOJpgc07o0r5luQ1DlX4tk2PqZkgmbwPbdzJ3KmtjgQ,138
 omdev/cli/_pathhack.py,sha256=UshIZX3oeXq0De-9X28gy2LgKMZDf_dzabdkUhZJdNA,2124
 omdev/cli/clicli.py,sha256=TZnQYHyyh97B6N_pVYYduYgt03s8Yp5mrJ7wblXWSWY,6308
 omdev/cli/install.py,sha256=oB34AOwu07sqEztW_z5mgorAFoP_Tw556XiTPj2WSM0,4904
-omdev/cli/main.py,sha256=eUvc64Wi6ROcSG7V_yzrmhpY2CgR12cyz9eJGXE0xlI,6885
+omdev/cli/main.py,sha256=nuRpsHB7W-Z0SU_wgEIHPFaMY2sOxiNkY9rnEek99Rs,6905
 omdev/cli/managers.py,sha256=BV98_n30Jj63OJrFgRoVZRfICxMLXEZKoEn4rMj9LV4,1160
 omdev/cli/types.py,sha256=zRSq-SVr43zhXs8dTgkpD9kot9iOFJB8KzfEUnNE7_0,500
 omdev/clipboard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -218,7 +218,7 @@ omdev/precheck/git.py,sha256=O8rNQZ_vlHec0pOFbK6LOkbly5ZIUYT_HXRMqQX8GaI,774
 omdev/precheck/imports.py,sha256=3loQxHMrpI0ce4-le77NCSxutLac_5vDW4UDX7KWWg8,2565
 omdev/precheck/lite.py,sha256=qd6nXWEVut8aBSRD_NxnxXGRNa9ue8mu8ND8rGLisE4,4710
 omdev/precheck/main.py,sha256=_1A5wiu9p2th1dn_17w1ZIFtMmCIOaTFpWyvK0jopEA,4374
-omdev/precheck/manifests.py,sha256=5Hlo_3BF5HbcLPxn93fhDS9yy9k6iL2vFsqFNfoU9q4,799
+omdev/precheck/manifests.py,sha256=dxl7GSJHKjQrR6mbwvj6j92XDGHOpxxEEQ6smJkBEe4,810
 omdev/precheck/scripts.py,sha256=6nb_lDgyX7u9kdF_BU6ubY01q_jGk96VH9q9gpOieng,1753
 omdev/precheck/unicode.py,sha256=VUNDCrlfUas_U8ugV_q0eFUXuBgKjS8YdCFm0FXREXo,2583
 omdev/ptk/__init__.py,sha256=4zhIfvhebFj4TJRRN1SQkcAe-7elizcfZLsD-fIlZsI,5198
@@ -252,7 +252,7 @@ omdev/py/docstrings/parser.py,sha256=umJEgQBkSXLwWIKZrBbFCfNrz847vpTNDqTTEwlvHpA
 omdev/py/docstrings/rest.py,sha256=c2xPYg_W01W9eYY_KLKX69E4qu4jpkgUshi5K5EyVv8,5221
 omdev/py/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/py/scripts/bumpversion.py,sha256=UDMtTd_wfkqsmrtHqTKDilWVzUBigzZAOCVND7t9jyw,1124
-omdev/py/scripts/execstat.py,sha256=eeOJ6LcNi-SS-EJKPubuHNvUbEnbqouliWvz6fjwjwM,3918
+omdev/py/scripts/execstat.py,sha256=a7KTmBW3IYgvcZR3u09_5LQcte6IgJaqzUN-LnaktIA,4577
 omdev/py/scripts/importtrace.py,sha256=Plh2ixN8NxTekrNoac6l9wg9B4x1647sEOvQTSy_Hbk,14256
 omdev/py/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/py/tools/importscan.py,sha256=4dCH0coX0OqNwesteKaTE8GxuSfLhgXYQlzNUXLiSNY,4640
@@ -270,7 +270,7 @@ omdev/pyproject/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 omdev/pyproject/resources/docker-dev.sh,sha256=DHkz5D18jok_oDolfg2mqrvGRWFoCe9GQo04dR1czcc,838
 omdev/pyproject/resources/python.sh,sha256=rFaN4SiJ9hdLDXXsDTwugI6zsw6EPkgYMmtacZeTbvw,749
 omdev/scripts/__init__.py,sha256=MKCvUAEQwsIvwLixwtPlpBqmkMXLCnjjXyAXvVpDwVk,91
-omdev/scripts/ci.py,sha256=9amwcmO6M05Ek8x8hZp8SQa2Wmn7p1PTRAkkcFzeLmI,362663
+omdev/scripts/ci.py,sha256=fqphFyV5xdBNC5QtxmGmCWL__na7c7E2ygWloRJBNZo,362813
 omdev/scripts/interp.py,sha256=8FR5-a95K1bL7YHNBiX1XVDPYhqw_jTWz8mVNDts6pI,158710
 omdev/scripts/pyproject.py,sha256=qgAW607OVKaeGma7XuxzyhuFyJLoKIcT9nZ52cl3KKU,270298
 omdev/scripts/slowcat.py,sha256=lssv4yrgJHiWfOiHkUut2p8E8Tq32zB-ujXESQxFFHY,2728
@@ -303,7 +303,7 @@ omdev/tools/git/__main__.py,sha256=gI87SBUgTkKUcUM-RtZWnei-UUDDqzbr5aPztb-gvbE,1
 omdev/tools/git/cli.py,sha256=I4AiCTz4OCzK6s8J2TJF1eYw9FH2JIK_CsdjQH_9UTE,16757
 omdev/tools/git/cloning.py,sha256=CNGBBMoWaTBJW4SZTf1VvhDFSm0yg7qDfNwZun_PFbU,891
 omdev/tools/git/consts.py,sha256=JuXivUNDkNhM4pe97icjRVAKM8cNRbrODquHINNKqOE,40
-omdev/tools/git/messages.py,sha256=ZZuDMDGnMo3se-EE2mJbRDOFlaIBUBT6fMX0DRG9yD8,2459
+omdev/tools/git/messages.py,sha256=a3E85r3uGbT0Puo6coBwmm7sj58k8_drYyxuxeH068U,2311
 omdev/tools/json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/tools/json/__main__.py,sha256=wqpkN_NsQyNwKW4qjVj8ADJ4_C98KhrFBtE-Z1UamfU,168
 omdev/tools/json/cli.py,sha256=8aXX3ijU3lvPZamkIyUOz-vlBmyIdaX7dCQq5rN7adE,10193
@@ -321,9 +321,9 @@ omdev/tools/jsonview/resources/jsonview.js,sha256=faDvXDOXKvEvjOuIlz4D3F2ReQXb_b
 omdev/tools/pawk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/tools/pawk/__main__.py,sha256=VCqeRVnqT1RPEoIrqHFSu4PXVMg4YEgF4qCQm90-eRI,66
 omdev/tools/pawk/pawk.py,sha256=ao5mdrpiSU4AZ8mBozoEaV3UVlmVTnRG9wD9XP70MZE,11429
-omdev-0.0.0.dev403.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omdev-0.0.0.dev403.dist-info/METADATA,sha256=ilWFWwezMzIvBE3z16V9e_7s9VSH7Q3LaJaX4YuRyrk,5094
-omdev-0.0.0.dev403.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omdev-0.0.0.dev403.dist-info/entry_points.txt,sha256=dHLXFmq5D9B8qUyhRtFqTGWGxlbx3t5ejedjrnXNYLU,33
-omdev-0.0.0.dev403.dist-info/top_level.txt,sha256=1nr7j30fEWgLYHW3lGR9pkdHkb7knv1U1ES1XRNVQ6k,6
-omdev-0.0.0.dev403.dist-info/RECORD,,
+omdev-0.0.0.dev405.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omdev-0.0.0.dev405.dist-info/METADATA,sha256=xCQhveQmUAKSQYqRtIyyyWfMmkpNxwaQkqhGVEy33L4,5094
+omdev-0.0.0.dev405.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omdev-0.0.0.dev405.dist-info/entry_points.txt,sha256=dHLXFmq5D9B8qUyhRtFqTGWGxlbx3t5ejedjrnXNYLU,33
+omdev-0.0.0.dev405.dist-info/top_level.txt,sha256=1nr7j30fEWgLYHW3lGR9pkdHkb7knv1U1ES1XRNVQ6k,6
+omdev-0.0.0.dev405.dist-info/RECORD,,