omdev 0.0.0.dev7__py3-none-any.whl

omdev/pyproject/pkg.py

@@ -0,0 +1,196 @@
+"""
+TODO:
+ - ext scanning
+ - __revision__
+ - entry_points
+
+https://setuptools.pypa.io/en/latest/references/keywords.html
+https://packaging.python.org/en/latest/specifications/pyproject-toml
+
+How to build a C extension in keeping with PEP 517, i.e. with pyproject.toml instead of setup.py?
+https://stackoverflow.com/a/66479252
+
+https://github.com/pypa/sampleproject/blob/db5806e0a3204034c51b1c00dde7d5eb3fa2532e/setup.py
+
+https://pip.pypa.io/en/stable/cli/pip_install/#vcs-support
+vcs+protocol://repo_url/#egg=pkg&subdirectory=pkg_dir
+'git+https://github.com/wrmsr/omlish@master#subdirectory=.pip/omlish'
+"""
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import importlib
+import os.path
+import shutil
+import subprocess
+import sys
+import types
+import typing as ta
+
+from omlish.lite.cached import cached_nullary
+
+from ..toml.writer import TomlWriter
+
+
+class PyprojectPackageGenerator:
+    def __init__(
+            self,
+            dir_name: str,
+            build_root: str,
+    ) -> None:
+        super().__init__()
+        self._dir_name = dir_name
+        self._build_root = build_root
+
+    #
+
+    @cached_nullary
+    def about(self) -> types.ModuleType:
+        return importlib.import_module(f'{self._dir_name}.__about__')
+
+    @cached_nullary
+    def project_cls(self) -> type:
+        return self.about().Project
+
+    @cached_nullary
+    def setuptools_cls(self) -> type:
+        return self.about().Setuptools
+
+    #
+
+    @cached_nullary
+    def _build_dir(self) -> str:
+        build_dir: str = os.path.join(self._build_root, self._dir_name)
+        if os.path.isdir(build_dir):
+            shutil.rmtree(build_dir)
+        os.makedirs(build_dir)
+        return build_dir
+
+    #
+
+    def _write_git_ignore(self) -> None:
+        git_ignore = [
+            '/*.egg-info/',
+            '/dist',
+        ]
+        with open(os.path.join(self._build_dir(), '.gitignore'), 'w') as f:
+            f.write('\n'.join(git_ignore))
+
+    #
+
+    def _symlink_source_dir(self) -> None:
+        os.symlink(
+            os.path.relpath(self._dir_name, self._build_dir()),
+            os.path.join(self._build_dir(), self._dir_name),
+        )
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class FileContents:
+        pyproject_dct: ta.Mapping[str, ta.Any]
+        manifest_in: ta.Optional[ta.Sequence[str]]
+
+    @staticmethod
+    def _build_cls_dct(cls: type) -> ta.Dict[str, ta.Any]:  # noqa
+        dct = {}
+        for b in reversed(cls.__mro__):
+            for k, v in b.__dict__.items():
+                if k.startswith('_'):
+                    continue
+                dct[k] = v
+        return dct
+
+    @staticmethod
+    def _move_dict_key(
+            sd: ta.Dict[str, ta.Any],
+            sk: str,
+            dd: ta.Dict[str, ta.Any],
+            dk: str,
+    ) -> None:
+        if sk in sd:
+            dd[dk] = sd.pop(sk)
+
+    @cached_nullary
+    def file_contents(self) -> FileContents:
+        pyp_dct = {}
+
+        pyp_dct['build-system'] = {
+            'requires': ['setuptools'],
+            'build-backend': 'setuptools.build_meta',
+        }
+
+        prj = self._build_cls_dct(self.project_cls())
+        pyp_dct['project'] = prj
+        self._move_dict_key(prj, 'optional_dependencies', pyp_dct, 'project.optional-dependencies')
+
+        st = self._build_cls_dct(self.setuptools_cls())
+        pyp_dct['tool.setuptools'] = st
+        self._move_dict_key(st, 'find_packages', pyp_dct, 'tool.setuptools.packages.find')
+
+        mani_in = st.pop('manifest_in', None)
+
+        return self.FileContents(
+            pyp_dct,
+            mani_in,
+        )
+
+    def _write_file_contents(self) -> None:
+        fc = self.file_contents()
+
+        with open(os.path.join(self._build_dir(), 'pyproject.toml'), 'w') as f:
+            TomlWriter(f).write_root(fc.pyproject_dct)
+
+        if fc.manifest_in:
+            with open(os.path.join(self._build_dir(), 'MANIFEST.in'), 'w') as f:
+                f.write('\n'.join(fc.manifest_in))  # noqa
+
+    #
+
+    _STANDARD_FILES: ta.Sequence[str] = [
+        'LICENSE',
+        'README.rst',
+    ]
+
+    def _symlink_standard_files(self) -> None:
+        for fn in self._STANDARD_FILES:
+            if os.path.exists(fn):
+                os.symlink(os.path.relpath(fn, self._build_dir()), os.path.join(self._build_dir(), fn))
+
+    #
+
+    def _run_build(
+            self,
+            build_output_dir: ta.Optional[str] = None,
+    ) -> None:
+        subprocess.check_call(
+            [
+                sys.executable,
+                '-m',
+                'build',
+            ],
+            cwd=self._build_dir(),
+        )
+
+        if build_output_dir is not None:
+            dist_dir = os.path.join(self._build_dir(), 'dist')
+            for fn in os.listdir(dist_dir):
+                shutil.copyfile(os.path.join(dist_dir, fn), os.path.join(build_output_dir, fn))
+
+    #
+
+    def gen(
+            self,
+            *,
+            run_build: bool = False,
+            build_output_dir: ta.Optional[str] = None,
+    ) -> str:
+        self._build_dir()
+        self._write_git_ignore()
+        self._symlink_source_dir()
+        self._write_file_contents()
+        self._symlink_standard_files()
+
+        if run_build:
+            self._run_build(build_output_dir)
+
+        return self._build_dir()

omdev/scripts/execrss.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+import resource
+import sys
+
+
+def _get_rss() -> int:
+    return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+
+
+def _main() -> None:
+    [src] = sys.argv[1:]
+    start = _get_rss()
+    exec(src)
+    end = _get_rss()
+    print(end - start)
+
+
+if __name__ == '__main__':
+    _main()

omdev/scripts/findimports.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+TODO:
+ - multiple commands:
+  - dumb cmp (a = set(sys.modules); import ...; print(set(sys.modules) - a)
+"""
+import ast
+import importlib.machinery
+import importlib.util
+import os.path
+import sys
+
+
+_BUILTIN_MODULE_NAMES = frozenset([*sys.builtin_module_names, *sys.stdlib_module_names])
+
+
+def _main() -> None:
+    def handle(fp: str) -> None:
+        def rec(n):
+            nodes.append(n)
+            for c in ast.iter_child_nodes(n):
+                rec(c)
+        # if not os.path.isfile(os.path.join(os.path.dirname(fp), '__init__.py')):
+        #     return
+        with open(fp, 'r') as f:
+            buf = f.read()
+        nodes: list[ast.AST] = []
+        rec(ast.parse(buf))
+        imps.update(na.name for i in nodes if isinstance(i, ast.Import) for na in i.names)
+        imps.update(i.module for i in nodes if isinstance(i, ast.ImportFrom) if i.module and not i.level)
+
+    imps: set[str] = set()
+    for rootp in sys.argv[1:]:
+        if os.path.isfile(rootp):
+            if rootp.endswith('.py'):
+                handle(os.path.join(os.path.dirname(rootp), os.path.basename(rootp)))
+        else:
+            for dp, dns, fns in os.walk(os.path.expanduser(rootp)):  # noqa
+                for fn in fns:
+                    if fn.endswith('.py'):
+                        handle(os.path.join(dp, fn))
+
+    def whichmod(i: str) -> str:
+        try:
+            l = importlib.util.find_spec(i)
+        except (ImportError, ValueError):
+            return 'bad'
+        if not isinstance(l, importlib.machinery.ModuleSpec) or not l.origin:
+            return 'bad'
+        # if l.origin.startswith(sys.base_prefix) or l.origin == 'frozen':
+        #     return 'builtin'
+        if i in _BUILTIN_MODULE_NAMES:
+            return 'builtin'
+        return 'dep'
+
+    eimps = {n for n in imps for n in [n.split('.')[0]] if n not in sys.builtin_module_names}
+    deps = {i for i in eimps if whichmod(i) != 'builtin'}
+    print(chr(10).join(sorted(deps)))
+
+
+if __name__ == '__main__':
+    _main()

omdev/scripts/findmagic.py

@@ -0,0 +1,70 @@
+import argparse
+import os.path
+import re
+import typing as ta
+
+
+def find_magic(
+        roots: ta.Sequence[str],
+        magics: ta.Sequence[str],
+        exts: ta.Sequence[str],
+        *,
+        py: bool = False,
+) -> ta.Iterator[str]:
+    if not magics:
+        raise Exception('Must specify magics')
+    if not exts:
+        raise Exception('Must specify extensions')
+
+    pats = [
+        re.compile('^' + re.escape(m) + r'($|(\s.*))')
+        for m in magics
+    ]
+
+    for root in roots:
+        for dp, dns, fns in os.walk(root):  # noqa
+            for fn in fns:
+                if not any(fn.endswith(f'.{x}') for x in exts):
+                    continue
+
+                fp = os.path.join(dp, fn)
+                with open(fp) as f:
+                    src = f.read()
+
+                if not any(
+                        any(pat.fullmatch(l) for pat in pats)
+                        for l in src.splitlines()
+                ):
+                    continue
+
+                if py:
+                    if fn == '__init__.py':
+                        out = dp.replace(os.sep, '.')
+                    elif fn.endswith('.py'):
+                        out = fp[:-3].replace(os.sep, '.')
+                    else:
+                        out = fp
+                else:
+                    out = fp
+                yield out
+
+
+def _main(argv=None) -> None:
+    arg_parser = argparse.ArgumentParser()
+    arg_parser.add_argument('--ext', '-x', dest='exts', action='append')
+    arg_parser.add_argument('--magic', '-m', dest='magics', action='append')
+    arg_parser.add_argument('--py', action='store_true')
+    arg_parser.add_argument('roots', nargs='*')
+    args = arg_parser.parse_args(argv)
+
+    for out in find_magic(
+        roots=args.roots,
+        magics=args.magics,
+        exts=args.exts,
+        py=args.py,
+    ):
+        print(out)
+
+
+if __name__ == '__main__':
+    _main()