omdev 0.0.0.dev13__py3-none-any.whl → 0.0.0.dev15__py3-none-any.whl

omdev/amalg/amalg.py

@@ -8,6 +8,7 @@ TODO:
  - more sanity checks lol
  - flake8 / ruff mgmt
  - typealias - support # noqa, other comments, and lamely support multiline by just stealing lines till it parses
+ - remove `if __name__ == '__main__':` blocks - thus, convention: no def _main() for these
 
 See:
  - https://github.com/xonsh/amalgamate - mine is for portability not speed, and doesn't try to work on unmodified code
@@ -27,6 +28,7 @@ import dataclasses as dc
 import io
 import logging
 import os.path
+import re
 import typing as ta
 
 import tokenize_rt as trt
@@ -35,6 +37,7 @@ from omlish import check
 from omlish import collections as col
 from omlish import logs
 
+from .. import findmagic
 from .. import tokens as tks
 
 
@@ -63,6 +66,47 @@ def split_header_lines(lines: ta.Iterable[Tokens]) -> tuple[list[Tokens], list[T
     return ws, nws
 
 
+#
+
+
+IF_MAIN_PAT = re.compile(r'if\s+__name__\s+==\s+[\'"]__main__[\'"]\s*:')
+
+
+def strip_main_lines(cls: ta.Sequence[Tokens]) -> list[Tokens]:
+    out = []
+
+    for l in (it := iter(cls)):
+        if IF_MAIN_PAT.fullmatch(tks.join_toks(l).strip()):
+            for l in it:
+                if l[0].name not in ('INDENT', 'UNIMPORTANT_WS') and tks.join_toks(l).strip():
+                    break
+        else:
+            out.append(l)
+
+    return out
+
+
+#
+
+
+STRIPPED_HEADER_MAGICS = [
+    '# @omlish-lite',
+]
+
+STRIPPED_HEADER_PATS = [findmagic.compile_magic_pat(m) for m in STRIPPED_HEADER_MAGICS]
+
+
+def strip_header_lines(hls: ta.Sequence[Tokens]) -> list[Tokens]:
+    if hls and tks.join_toks(hls[0]).startswith('#!'):
+        hls = hls[1:]
+    out = []
+    for l in hls:
+        ls = tks.join_toks(l)
+        if not any(p.fullmatch(ls) for p in STRIPPED_HEADER_PATS):
+            out.append(l)
+    return out
+
+
 ##
 
 
@@ -238,6 +282,8 @@ def make_src_file(
 
     hls, cls = split_header_lines(lines)
 
+    hls = strip_header_lines(hls)
+
     imps: list[Import] = []
     tys: list[Typing] = []
     ctls: list[Tokens] = []
@@ -328,10 +374,11 @@ def gen_amalg(
         else:
             ogf = os.path.basename(main_path)
         nhls = []
-        if hls[0].startswith('#!'):
-            nhls.append(hls.pop(0))
         nhls.extend([
+            '#!/usr/bin/env python3\n',
             '# noinspection DuplicatedCode\n',
+            '# @omlish-lite\n',
+            '# @omlish-script\n',
             f'{OUTPUT_COMMENT.strip()} {ogf}\n',
         ])
         hls = [*nhls, *hls]
@@ -398,7 +445,10 @@ def gen_amalg(
         if f is not mf and f.header_lines:
             out.write(tks.join_lines(f.header_lines))
         out.write(f'\n\n')
-        sf_src = tks.join_lines(f.content_lines)
+        cls = f.content_lines
+        if f is not mf:
+            cls = strip_main_lines(cls)
+        sf_src = tks.join_lines(cls)
         out.write(sf_src.strip())
         if i < len(sfs) - 1:
             out.write('\n\n\n')

omdev/{scripts/bracepy.py → bracepy.py}

@@ -1,4 +1,5 @@
-# !/usr/bin/env python3
+#!/usr/bin/env python3
+# @omlish-lite
 """
 https://github.com/umlet/pwk/blob/dc23b3400108a71947a695f1fa1df0f514b42528/pwk
 """
@@ -84,22 +85,21 @@ def translate_brace_python(
     return ret.getvalue()
 
 
-def _main(argv=None) -> None:
-    import argparse
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-x', '--exec', action='store_true')
-    parser.add_argument('cmd')
+if __name__ == '__main__':
+    def _main(argv=None) -> None:
+        import argparse
 
-    args = parser.parse_args(argv)
+        parser = argparse.ArgumentParser()
+        parser.add_argument('-x', '--exec', action='store_true')
+        parser.add_argument('cmd')
 
-    src = translate_brace_python(args.cmd)
+        args = parser.parse_args(argv)
 
-    if args.exec:
-        exec(src)
-    else:
-        print(src)
+        src = translate_brace_python(args.cmd)
 
+        if args.exec:
+            exec(src)
+        else:
+            print(src)
 
-if __name__ == '__main__':
     _main()

omdev/exts/cmake.py

@@ -1,4 +1,7 @@
 """
+FIXME:
+ - debug tables don't handle symlinks
+
 TODO:
  - symlink headers, included src files (hamt_impl, ...)
  - point / copy output to dst dirs
@@ -33,7 +36,7 @@ from omlish import lang
 from omlish import logs
 
 from .. import cmake
-from ..scripts import findmagic
+from .. import findmagic
 
 
 log = logging.getLogger(__name__)
@@ -64,10 +67,13 @@ class CmakeProjectGen:
             self,
             exts: ta.Sequence[str],
             prj_root: str | None = None,
+            *,
+            use_exe_realpath: bool = False,
     ) -> None:
         super().__init__()
         self._exts = check.not_isinstance(exts, str)
         self._prj_root = os.path.abspath(prj_root) if prj_root is not None else os.getcwd()
+        self._use_exe_realpath = use_exe_realpath
 
     #
 
@@ -238,11 +244,14 @@ class CmakeProjectGen:
                 f'{self.var_prefix}_INCLUDE_DIRECTORIES',
                 _sep_str_grps(
                     [f'{self.py.venv_root}/include'],
-                    [f'{self.py.root}/include/python{self.py.suffix}'],
-                    [
-                        # $ENV{HOME}/src/python/cpython
-                        # $ENV{HOME}/src/python/cpython/include
-                    ],
+                    (
+                        [
+                            (red := os.path.dirname(self.p.py_info().real_exe)),
+                            os.path.join(red, 'include'),
+                        ]
+                        if self.p._use_exe_realpath else  # noqa
+                        [f'{self.py.root}/include/python{self.py.suffix}']
+                    ),
                 ),
             ))
 
@@ -269,8 +278,11 @@ class CmakeProjectGen:
             self.g.write_var(cmake.Var(
                 f'{self.var_prefix}_LINK_DIRECTORIES',
                 _sep_str_grps(
-                    [f'{self.py.root}/lib'],
-                    # ['$ENV{HOME}/src/python/cpython'],
+                    (
+                        [os.path.dirname(self.p.py_info().real_exe)]
+                        if self.p._use_exe_realpath else  # noqa
+                        [f'{self.py.root}/lib']
+                    ),
                 ),
             ))
 
@@ -316,7 +328,10 @@ def _gen_cmd(args) -> None:
     if not args.exts:
         raise Exception('must specify exts')
 
-    cpg = CmakeProjectGen(args.exts)
+    cpg = CmakeProjectGen(
+        args.exts,
+        use_exe_realpath=bool(args.realpath),
+    )
     cpg.run()
 
 
@@ -328,6 +343,7 @@ def _main(argv=None) -> None:
     subparsers = parser.add_subparsers()
 
     parser_gen = subparsers.add_parser('gen')
+    parser_gen.add_argument('--realpath', action='store_true')
     parser_gen.add_argument('exts', nargs='*')
     parser_gen.set_defaults(func=_gen_cmd)
 

omdev/exts/importhook.py

@@ -1,20 +1,23 @@
 """
 TODO:
- - remove imp
  - whitelist packages
 """
-import dataclasses as dc
-import importlib
 import importlib.abc
 import importlib.machinery
+import importlib.util
 import os.path
 import sys
 import types
 import typing as ta
 
+from omlish import check
+
 from . import build
 
 
+##
+
+
 def load_dynamic(name: str, path: str) -> types.ModuleType:
     import importlib.machinery
     loader = importlib.machinery.ExtensionFileLoader(name, path)
@@ -26,63 +29,106 @@ def load_dynamic(name: str, path: str) -> types.ModuleType:
     return importlib._bootstrap._load(spec)  # noqa
 
 
-class CExtensionLoader(importlib.abc.Loader):
+##
 
-    def __init__(self, fullname: str, path: str) -> None:
-        super().__init__()
 
-        self._fullname = fullname
-        self._path = path
+class CextImportLoader(importlib.machinery.ExtensionFileLoader):
 
-    def load_module(self, fullname: str) -> types.ModuleType:
-        so_path = build.build_ext(fullname, self._path)
-        return load_dynamic(self._fullname, so_path)
+    def __init__(
+            self,
+            filename: str,
+    ) -> None:
+        module_name = os.path.splitext(os.path.basename(filename))[0]
+        super().__init__(module_name, filename)
 
+    def create_module(self, spec: importlib.machinery.ModuleSpec) -> types.ModuleType:
+        so_path = build.build_ext(spec.name, check.non_empty_str(spec.origin))
+        self.path = so_path  # noqa
+        spec.origin = so_path
+        return super().create_module(spec)
 
-LoaderDetails: ta.TypeAlias = tuple[type[importlib.abc.Loader], list[str]]
-loader_details = (CExtensionLoader, ['.c', '.cc', '.cpp', '.cxx'])
+    def exec_module(self, module):
+        return super().exec_module(module)
 
 
-##
+CEXT_EXTENSIONS = ['.c', '.cc', '.cpp', '.cxx']
 
 
-@dc.dataclass(frozen=True)
-class FileFinderPathHook:
-    lds: ta.Sequence[LoaderDetails]
+class CextImportMetaFinder(importlib.abc.MetaPathFinder):
 
-    def __call__(self, path: str) -> importlib.machinery.FileFinder:
+    def __init__(
+            self,
+            extensions: ta.AbstractSet[str] = frozenset(CEXT_EXTENSIONS),
+    ) -> None:
+        super().__init__()
+        self._extensions = extensions
+
+    def find_spec(
+            self,
+            fullname: str,
+            path: ta.Sequence[str] | None,
+            target: types.ModuleType | None = None,
+    ) -> importlib.machinery.ModuleSpec | None:
         if not path:
-            path = os.getcwd()
-        if not os.path.isdir(path):
-            raise ImportError('only directories are supported', path=path)
-        return importlib.machinery.FileFinder(path, *self.lds)
+            path = [os.getcwd(), *sys.path]  # top level import --
+        if '.' in fullname:
+            *parents, name = fullname.split('.')
+        else:
+            name = fullname
+
+        for entry in path:
+            for ext in self._extensions:
+                if os.path.isdir(os.path.join(entry, name)):
+                    # this module has child modules
+                    filename = os.path.join(entry, name, '__init__' + ext)
+                    submodule_locations = [os.path.join(entry, name)]
+                else:
+                    filename = os.path.join(entry, name + ext)
+                    submodule_locations = None
+                if not os.path.exists(filename):
+                    continue
 
+                return importlib.util.spec_from_file_location(
+                    fullname,
+                    filename,
+                    loader=CextImportLoader(filename),
+                    submodule_search_locations=submodule_locations,
+                )
 
-def _is_c_loader(h: ta.Any) -> bool:
-    return (
-        isinstance(h, FileFinderPathHook) and
-        h.lds == [loader_details]
-    )
+        return None  # we don't know how to import this
+
+
+#
+
+
+def _get_installed_importers() -> list[CextImportMetaFinder]:
+    return [i for i in sys.meta_path if isinstance(i, CextImportMetaFinder)]
 
 
 def is_installed() -> bool:
-    return any(h for h in sys.path_hooks if _is_c_loader(h))
+    return bool(_get_installed_importers())
+
 
+def install(*, flush: bool = True) -> bool:
+    if _get_installed_importers():
+        return False
+
+    sys.meta_path.append(CextImportMetaFinder())
 
-def _install(*, flush: bool = False) -> None:
-    sys.path_hooks.insert(0, FileFinderPathHook([loader_details]))
-    sys.path_importer_cache.clear()
     if flush:
         importlib.invalidate_caches()
 
+    return True
 
-def install(*, flush: bool = False) -> None:
-    if not is_installed():
-        _install(flush=flush)
 
+def uninstall(*, flush: bool = False) -> bool:
+    ret = False
 
-def uninstall(*, flush: bool = False) -> None:
-    sys.path_hooks = [h for h in sys.path_hooks if not _is_c_loader(h)]
-    sys.path_importer_cache.clear()
-    if flush:
+    for i in _get_installed_importers():
+        sys.meta_path.remove(i)
+        ret = True
+
+    if ret and flush:
         importlib.invalidate_caches()
+
+    return ret

omdev/findimports.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+# @omlish-script
+"""
+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
+import typing as ta
+
+
+_BUILTIN_MODULE_NAMES = frozenset([*sys.builtin_module_names, *sys.stdlib_module_names])
+
+
+def whichmod(i: str) -> ta.Literal['bad', 'builtin', 'dep']:
+    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'
+
+
+def yield_imports(fp: str) -> set[str]:
+    # if not os.path.isfile(os.path.join(os.path.dirname(fp), '__init__.py')):
+    #     return
+
+    with open(fp) as f:
+        buf = f.read()
+
+    nodes: list[ast.AST] = []
+
+    def rec(n):
+        nodes.append(n)
+        for c in ast.iter_child_nodes(n):
+            rec(c)
+
+    rec(ast.parse(buf))
+
+    return {
+        *(na.name for i in nodes if isinstance(i, ast.Import) for na in i.names),
+        *(i.module for i in nodes if isinstance(i, ast.ImportFrom) if i.module and not i.level),
+    }
+
+
+def find_imports(*rootps: str) -> set[str]:
+    imps: set[str] = set()
+
+    for rootp in rootps:
+        if os.path.isfile(rootp):
+            if rootp.endswith('.py'):
+                imps.update(yield_imports(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'):
+                        imps.update(yield_imports(os.path.join(dp, fn)))
+
+    return imps
+
+
+def get_import_deps(imps: set[str]) -> set[str]:
+    eimps = {n for n in imps for n in [n.split('.')[0]] if n not in sys.builtin_module_names}
+    return {i for i in eimps if whichmod(i) != 'builtin'}
+
+
+def _main() -> None:
+    imps = find_imports(*sys.argv[1:])
+    deps = get_import_deps(imps)
+    print(chr(10).join(sorted(deps)))
+
+
+if __name__ == '__main__':
+    _main()

omdev/{scripts/findmagic.py → findmagic.py}

@@ -1,9 +1,15 @@
-import argparse
+#!/usr/bin/env python3
+# @omlish-lite
+# @omlish-script
 import os.path
 import re
 import typing as ta
 
 
+def compile_magic_pat(m: str) -> re.Pattern:
+    return re.compile('^' + re.escape(m) + r'($|(\s.*))')
+
+
 def find_magic(
         roots: ta.Sequence[str],
         magics: ta.Sequence[str],
@@ -16,10 +22,7 @@ def find_magic(
     if not exts:
         raise Exception('Must specify extensions')
 
-    pats = [
-        re.compile('^' + re.escape(m) + r'($|(\s.*))')
-        for m in magics
-    ]
+    pats = [compile_magic_pat(m) for m in magics]
 
     for root in roots:
         for dp, dns, fns in os.walk(root):  # noqa
@@ -52,22 +55,23 @@ def find_magic(
                 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)
+if __name__ == '__main__':
+    def _main(argv=None) -> None:
+        import argparse
 
-    for out in find_magic(
-        roots=args.roots,
-        magics=args.magics,
-        exts=args.exts,
-        py=args.py,
-    ):
-        print(out)
+        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()

omdev/precheck/__main__.py

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