omdev 0.0.0.dev39__tar.gz → 0.0.0.dev41__tar.gz

{omdev-0.0.0.dev39/omdev.egg-info → omdev-0.0.0.dev41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omdev
-Version: 0.0.0.dev39
+Version: 0.0.0.dev41
 Summary: omdev
 Author: wrmsr
 License: BSD-3-Clause
@@ -12,7 +12,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Operating System :: POSIX
 Requires-Python: ~=3.12
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev39
+Requires-Dist: omlish==0.0.0.dev41
 Provides-Extra: all
 Requires-Dist: pycparser~=2.22; extra == "all"
 Requires-Dist: cffi~=1.17; extra == "all"

{omdev-0.0.0.dev39 → omdev-0.0.0.dev41}/omdev/.manifests.json

@@ -35,18 +35,6 @@
       }
     }
   },
-  {
-    "module": ".cli._version",
-    "attr": "_CLI_MODULE",
-    "file": "omdev/cli/_version.py",
-    "line": 5,
-    "value": {
-      "$.cli.types.CliModule": {
-        "cmd_name": "version",
-        "mod_name": "omdev.cli._version"
-      }
-    }
-  },
   {
     "module": ".interp.__main__",
     "attr": "_CLI_MODULE",
@@ -83,6 +71,42 @@
       }
     }
   },
+  {
+    "module": ".scripts.execrss",
+    "attr": "_CLI_MODULE",
+    "file": "omdev/scripts/execrss.py",
+    "line": 11,
+    "value": {
+      "$.cli.types.CliModule": {
+        "cmd_name": "execrss",
+        "mod_name": "omdev.scripts.execrss"
+      }
+    }
+  },
+  {
+    "module": ".scripts.exectime",
+    "attr": "_CLI_MODULE",
+    "file": "omdev/scripts/exectime.py",
+    "line": 7,
+    "value": {
+      "$.cli.types.CliModule": {
+        "cmd_name": "exectime",
+        "mod_name": "omdev.scripts.exectime"
+      }
+    }
+  },
+  {
+    "module": ".scripts.importtrace",
+    "attr": "_CLI_MODULE",
+    "file": "omdev/scripts/importtrace.py",
+    "line": 481,
+    "value": {
+      "$.cli.types.CliModule": {
+        "cmd_name": "importtrace",
+        "mod_name": "omdev.scripts.importtrace"
+      }
+    }
+  },
   {
     "module": ".tools.dockertools",
     "attr": "_CLI_MODULE",
@@ -107,6 +131,18 @@
       }
     }
   },
+  {
+    "module": ".tools.importscan",
+    "attr": "_CLI_MODULE",
+    "file": "omdev/tools/importscan.py",
+    "line": 165,
+    "value": {
+      "$.cli.types.CliModule": {
+        "cmd_name": "importscan",
+        "mod_name": "omdev.tools.importscan"
+      }
+    }
+  },
   {
     "module": ".tools.piptools",
     "attr": "_CLI_MODULE",

{omdev-0.0.0.dev39 → omdev-0.0.0.dev41}/omdev/cli/install.py

@@ -46,7 +46,7 @@ class InstallMgr(abc.ABC):
         raise NotImplementedError
 
 
-class UvInstallMgr(InstallMgr):
+class UvxInstallMgr(InstallMgr):
     def is_available(self) -> bool:
         return bool(shutil.which('uv'))
 
@@ -110,7 +110,7 @@ class PipxInstallMgr(InstallMgr):
 
 
 INSTALL_MGRS = {
-    'uv': UvInstallMgr(),
+    'uvx': UvxInstallMgr(),
     'pipx': PipxInstallMgr(),
 }
 

omdev-0.0.0.dev41/omdev/cli/main.py

@@ -0,0 +1,100 @@
+"""
+TODO:
+ - cache ldr.discover() somehow if in uvx/pipx - very slow
+  - <venv-root>/.omdev-cli-manifest-cache.json - {pkg_name: manifests_json}
+ - allow manually specifying manifest packages
+ - https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#creating-executable-scripts
+ - https://packaging.python.org/en/latest/specifications/entry-points/#entry-points
+"""
+import argparse
+import os
+import runpy
+import sys
+
+from omlish import __about__
+from omlish import check
+
+from ..manifests.load import ManifestLoader
+from .types import CliCmd
+from .types import CliFunc
+from .types import CliModule
+
+
+##
+
+
+def _print_version() -> None:
+    print(__about__.__version__)
+
+
+def _print_revision() -> None:
+    print(__about__.__revision__)
+
+
+_CLI_FUNCS = [
+    CliFunc('version', _print_version),
+    CliFunc('revision', _print_revision),
+]
+
+
+##
+
+
+def _main() -> None:
+    ccs: list[CliCmd] = []
+
+    #
+
+    ldr = ManifestLoader.from_entry_point(globals())
+
+    pkgs = ldr.discover()
+
+    if not pkgs:
+        pkgs = []
+        for n in os.listdir(os.getcwd()):
+            if os.path.isdir(n) and os.path.exists(os.path.join(n, '__init__.py')):
+                pkgs.append(n)
+
+    for m in ldr.load(*pkgs, only=[CliModule]):
+        ccs.append(check.isinstance(m.value, CliModule))
+
+    #
+
+    ccs.extend(_CLI_FUNCS)
+
+    #
+
+    dct: dict[str, CliCmd] = {}
+    for cc in ccs:
+        if cc.cmd_name in dct:
+            raise NameError(cc)
+        dct[cc.cmd_name] = cc
+
+    #
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('cmd', nargs='?', choices=dct.keys())
+    parser.add_argument('args', nargs=argparse.REMAINDER)
+
+    args = parser.parse_args()
+    if not args.cmd:
+        parser.print_help()
+        return
+
+    #
+
+    cc = dct[args.cmd]
+
+    if isinstance(cc, CliModule):
+        sys.argv = [cc.cmd_name, *(args.args or ())]
+        runpy._run_module_as_main(cc.mod_name)  # type: ignore  # noqa
+
+    elif isinstance(cc, CliFunc):
+        cc.fn(*(args.args or ()))
+
+    else:
+        raise TypeError(cc)
+
+
+if __name__ == '__main__':
+    _main()

omdev-0.0.0.dev41/omdev/cli/types.py

@@ -0,0 +1,17 @@
+import dataclasses as dc
+import typing as ta
+
+
+@dc.dataclass(frozen=True)
+class CliCmd:
+    cmd_name: str
+
+
+@dc.dataclass(frozen=True)
+class CliModule(CliCmd):
+    mod_name: str
+
+
+@dc.dataclass(frozen=True)
+class CliFunc(CliCmd):
+    fn: ta.Callable

{omdev-0.0.0.dev39 → omdev-0.0.0.dev41}/omdev/git.py

@@ -73,11 +73,15 @@ def get_git_revision(
     if cwd is None:
         cwd = os.getcwd()
 
-    if subprocess.run([  # noqa
-        'git',
-        'rev-parse',
-        '--is-inside-work-tree',
-    ], stderr=subprocess.PIPE).returncode:
+    if subprocess.run(  # noqa
+        [
+            'git',
+            'rev-parse',
+            '--is-inside-work-tree',
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    ).returncode:
         return None
 
     has_untracked = bool(subprocess.check_output([

{omdev-0.0.0.dev39 → omdev-0.0.0.dev41}/omdev/manifests/load.py

@@ -1,7 +1,12 @@
+"""
+Should be kept somewhat lightweight - used in cli entrypoints.
+
+TODO:
+ - persisted caching support - {pkg_name: manifests}
+"""
 # ruff: noqa: UP006 UP007
 import dataclasses as dc
 import importlib.machinery
-import importlib.metadata
 import importlib.resources
 import json
 import typing as ta
@@ -74,19 +79,7 @@ class ManifestLoader:
         self._cls_cache[key] = cls
         return cls
 
-    def load_raw(self, pkg_name: str) -> ta.Optional[ta.Sequence[Manifest]]:
-        try:
-            return self._raw_cache[pkg_name]
-        except KeyError:
-            pass
-
-        t = importlib.resources.files(pkg_name).joinpath('.manifests.json')
-        if not t.is_file():
-            self._raw_cache[pkg_name] = None
-            return None
-
-        src = t.read_text('utf-8')
-        obj = json.loads(src)
+    def load_contents(self, obj: ta.Any, pkg_name: str) -> ta.Sequence[Manifest]:
         if not isinstance(obj, (list, tuple)):
             raise TypeError(obj)
 
@@ -105,6 +98,26 @@ class ManifestLoader:
 
             lst.append(m)
 
+        return lst
+
+    def load_raw(self, pkg_name: str) -> ta.Optional[ta.Sequence[Manifest]]:
+        try:
+            return self._raw_cache[pkg_name]
+        except KeyError:
+            pass
+
+        t = importlib.resources.files(pkg_name).joinpath('.manifests.json')
+        if not t.is_file():
+            self._raw_cache[pkg_name] = None
+            return None
+
+        src = t.read_text('utf-8')
+        obj = json.loads(src)
+        if not isinstance(obj, (list, tuple)):
+            raise TypeError(obj)
+
+        lst = self.load_contents(obj, pkg_name)
+
         self._raw_cache[pkg_name] = lst
         return lst
 
@@ -143,6 +156,9 @@ class ManifestLoader:
     ENTRY_POINT_GROUP = 'omlish.manifests'
 
     def discover(self) -> ta.Sequence[str]:
+        # This is a fat dep so do it late.
+        import importlib.metadata
+
         return [
             ep.value
             for ep in importlib.metadata.entry_points(group=self.ENTRY_POINT_GROUP)

{omdev-0.0.0.dev39 → omdev-0.0.0.dev41}/omdev/pyproject/cli.py

@@ -47,6 +47,7 @@ from ..toml.parser import toml_loads
 from .configs import PyprojectConfig
 from .configs import PyprojectConfigPreparer
 from .configs import VenvConfig
+from .pkg import BasePyprojectPackageGenerator
 from .pkg import PyprojectPackageGenerator
 from .reqs import RequirementsRewriter
 
@@ -338,25 +339,36 @@ def _pkg_cmd(args) -> None:
         if run_build:
             os.makedirs(build_output_dir, exist_ok=True)
 
-        num_threads = max(mp.cpu_count() // 2, 1)
+        pgs: ta.List[BasePyprojectPackageGenerator] = [
+            PyprojectPackageGenerator(
+                dir_name,
+                pkgs_root,
+            )
+            for dir_name in run.cfg().pkgs
+        ]
+        pgs = list(itertools.chain.from_iterable([pg, *pg.children()] for pg in pgs))
+
+        num_threads = args.jobs or max(mp.cpu_count() // 2, 1)
+        futs: ta.List[cf.Future]
         with cf.ThreadPoolExecutor(num_threads) as ex:
-            futs = [
-                ex.submit(functools.partial(
-                    PyprojectPackageGenerator(
-                        dir_name,
-                        pkgs_root,
-                    ).gen,
-                    PyprojectPackageGenerator.GenOpts(
-                        run_build=run_build,
-                        build_output_dir=build_output_dir,
-                        add_revision=add_revision,
-                    ),
-                ))
-                for dir_name in run.cfg().pkgs
-            ]
+            futs = [ex.submit(pg.gen) for pg in pgs]
             for fut in futs:
                 fut.result()
 
+            if run_build:
+                futs = [
+                    ex.submit(functools.partial(
+                        pg.build,
+                        build_output_dir,
+                        BasePyprojectPackageGenerator.BuildOpts(
+                            add_revision=add_revision,
+                        ),
+                    ))
+                    for pg in pgs
+                ]
+                for fut in futs:
+                    fut.result()
+
     else:
         raise Exception(f'unknown subcommand: {cmd}')
 
@@ -380,6 +392,7 @@ def _build_parser() -> argparse.ArgumentParser:
     parser_resolve = subparsers.add_parser('pkg')
     parser_resolve.add_argument('-b', '--build', action='store_true')
     parser_resolve.add_argument('-r', '--revision', action='store_true')
+    parser_resolve.add_argument('-j', '--jobs', type=int)
     parser_resolve.add_argument('cmd', nargs='?')
     parser_resolve.add_argument('args', nargs=argparse.REMAINDER)
     parser_resolve.set_defaults(func=_pkg_cmd)

{omdev-0.0.0.dev39 → omdev-0.0.0.dev41}/omdev/pyproject/pkg.py

@@ -186,12 +186,33 @@ class BasePyprojectPackageGenerator(abc.ABC):
 
     #
 
-    def _run_build(
+    def children(self) -> ta.Sequence['BasePyprojectPackageGenerator']:
+        return []
+
+    #
+
+    def gen(self) -> str:
+        log.info('Generating pyproject package: %s -> %s (%s)', self._dir_name, self._pkgs_root, self._pkg_suffix)
+
+        self._pkg_dir()
+        self._write_git_ignore()
+        self._symlink_source_dir()
+        self._write_file_contents()
+        self._symlink_standard_files()
+
+        return self._pkg_dir()
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class BuildOpts:
+        add_revision: bool = False
+        test: bool = False
+
+    def build(
             self,
-            build_output_dir: ta.Optional[str] = None,
-            *,
-            add_revision: bool = False,
-            test: bool = False,
+            output_dir: ta.Optional[str] = None,
+            opts: BuildOpts = BuildOpts(),
     ) -> None:
         subprocess_check_call(
             sys.executable,
@@ -202,10 +223,10 @@ class BasePyprojectPackageGenerator(abc.ABC):
 
         dist_dir = os.path.join(self._pkg_dir(), 'dist')
 
-        if add_revision:
+        if opts.add_revision:
             GitRevisionAdder().add_to(dist_dir)
 
-        if test:
+        if opts.test:
             for fn in os.listdir(dist_dir):
                 tmp_dir = tempfile.mkdtemp()
 
@@ -224,34 +245,9 @@ class BasePyprojectPackageGenerator(abc.ABC):
                     cwd=tmp_dir,
                 )
 
-        if build_output_dir is not None:
+        if output_dir is not None:
             for fn in os.listdir(dist_dir):
-                shutil.copyfile(os.path.join(dist_dir, fn), os.path.join(build_output_dir, fn))
-
-    #
-
-    @dc.dataclass(frozen=True)
-    class GenOpts:
-        run_build: bool = False
-        build_output_dir: ta.Optional[str] = None
-        add_revision: bool = False
-
-    def gen(self, opts: GenOpts = GenOpts()) -> str:
-        log.info('Generating pyproject package: %s -> %s (%s)', self._dir_name, self._pkgs_root, self._pkg_suffix)
-
-        self._pkg_dir()
-        self._write_git_ignore()
-        self._symlink_source_dir()
-        self._write_file_contents()
-        self._symlink_standard_files()
-
-        if opts.run_build:
-            self._run_build(
-                opts.build_output_dir,
-                add_revision=opts.add_revision,
-            )
-
-        return self._pkg_dir()
+                shutil.copyfile(os.path.join(dist_dir, fn), os.path.join(output_dir, fn))
 
 
 #
@@ -377,24 +373,25 @@ class PyprojectPackageGenerator(BasePyprojectPackageGenerator):
 
     #
 
-    def gen(self, opts: BasePyprojectPackageGenerator.GenOpts = BasePyprojectPackageGenerator.GenOpts()) -> str:
-        ret = super().gen(opts)
+    @cached_nullary
+    def children(self) -> ta.Sequence[BasePyprojectPackageGenerator]:
+        out: ta.List[BasePyprojectPackageGenerator] = []
 
         if self.build_specs().setuptools.get('cexts'):
-            _PyprojectCextPackageGenerator(
+            out.append(_PyprojectCextPackageGenerator(
                 self._dir_name,
                 self._pkgs_root,
                 pkg_suffix='-cext',
-            ).gen(opts)
+            ))
 
         if self.build_specs().pyproject.get('cli_scripts'):
-            _PyprojectCliPackageGenerator(
+            out.append(_PyprojectCliPackageGenerator(
                 self._dir_name,
                 self._pkgs_root,
                 pkg_suffix='-cli',
-            ).gen(opts)
+            ))
 
-        return ret
+        return out
 
 
 #

{omdev-0.0.0.dev39 → omdev-0.0.0.dev41}/omdev/scripts/execrss.py

@@ -8,6 +8,13 @@ def _get_rss() -> int:
     return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
 
 
+# @omlish-manifest
+_CLI_MODULE = {'$omdev.cli.types.CliModule': {
+    'cmd_name': 'execrss',
+    'mod_name': __name__,
+}}
+
+
 def _main() -> None:
     [src] = sys.argv[1:]
     start = _get_rss()

omdev-0.0.0.dev41/omdev/scripts/exectime.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+# @omlish-script
+import sys
+import time
+
+
+# @omlish-manifest
+_CLI_MODULE = {'$omdev.cli.types.CliModule': {
+    'cmd_name': 'exectime',
+    'mod_name': __name__,
+}}
+
+
+def _main() -> None:
+    [src] = sys.argv[1:]
+    co = compile(src, '<string>', 'exec')
+    start = time.time_ns()
+    exec(co)
+    end = time.time_ns()
+    print(end - start)
+
+
+if __name__ == '__main__':
+    _main()

{omdev-0.0.0.dev39/omdev/tools → omdev-0.0.0.dev41/omdev/scripts}/importtrace.py

@@ -478,6 +478,13 @@ class SqliteWriter:
 ##
 
 
+# @omlish-manifest
+_CLI_MODULE = {'$omdev.cli.types.CliModule': {
+    'cmd_name': 'importtrace',
+    'mod_name': __name__,
+}}
+
+
 def _main() -> None:
     if sys.version_info < REQUIRED_PYTHON_VERSION:
         raise EnvironmentError(f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa