Fix semiwrap tools

Author: virtuald

src/semiwrap/tool/__init__.py

@@ -0,0 +1 @@
+from .__main__ import main

src/semiwrap/tool/__main__.py

@@ -3,15 +3,12 @@
 
 from .build_dep import BuildDep
 from .create_gen import GenCreator
-from .create_imports import ImportCreator
-from .parse_maven import MavenParser
-from .platform_info import PlatformInfo
-from .show_override import ShowOverrides
+from .create_imports import ImportCreator, UpdateInit
 from .scan_headers import HeaderScanner
 
 
 def main():
-    parser = argparse.ArgumentParser(prog="robotpy-build")
+    parser = argparse.ArgumentParser(prog="semiwrap")
     parent_parser = argparse.ArgumentParser(add_help=False)
     subparsers = parser.add_subparsers(dest="cmd")
     subparsers.required = True
@@ -21,9 +18,7 @@ def main():
         GenCreator,
         HeaderScanner,
         ImportCreator,
-        PlatformInfo,
-        ShowOverrides,
-        MavenParser,
+        UpdateInit,
     ):
         cls.add_subparser(parent_parser, subparsers).set_defaults(cls=cls)
 
@@ -40,8 +35,8 @@ def main():
     else:
         retval = 0
 
-    return retval
+    sys.exit(retval)
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    main()

src/semiwrap/tool/build_dep.py

@@ -1,7 +1,6 @@
 import subprocess
 import sys
-
-from .util import get_setup
+import tomli
 
 
 class BuildDep:
@@ -21,10 +20,10 @@ def add_subparser(cls, parent_parser, subparsers):
         return parser
 
     def run(self, args):
-        s = get_setup()
-        requirements = s.pyproject.get("build-system", {}).get("requires", [])
-        requirements.extend(s.setup_kwargs.get("install_requires", ""))
-        requirements.append("wheel")
+        with open("pyproject.toml", "rb") as fp:
+            pyproject = tomli.load(fp)
+        requirements = pyproject.get("build-system", {}).get("requires", [])
+        requirements.extend(pyproject.get("project", {}).get("dependencies", []))
 
         pipargs = [
             sys.executable,

src/semiwrap/tool/create_gen.py

@@ -1,7 +1,10 @@
-from os.path import exists
+import os
+import pathlib
+import typing as T
 
-from .util import get_setup
 from ..autowrap.generator_data import MissingReporter
+from ..cmd.header2dat import make_argparser, generate_wrapper
+from ..makeplan import InputFile, makeplan, BuildTarget
 
 
 class GenCreator:
@@ -15,35 +18,85 @@ def add_subparser(cls, parent_parser, subparsers):
         parser.add_argument(
             "--write", help="Write to files if they don't exist", action="store_true"
         )
-        parser.add_argument("--strip-prefixes", action="append")
 
         return parser
 
     def run(self, args):
-        pfx = ""
-        if args.strip_prefixes:
-            pfx = "strip_prefixes:\n- " + "\n- ".join(args.strip_prefixes) + "\n\n"
+        project_root = pathlib.Path.cwd()
+
+        # Problem: if another hatchling plugin sets PKG_CONFIG_PATH to include a .pc
+        # file, makeplan() will fail to find it, which prevents a semiwrap program
+        # from consuming those .pc files.
+        #
+        # We search for .pc files in the project root by default and add anything found
+        # to the PKG_CONFIG_PATH to allow that to work. Probably won't hurt anything?
+
+        pcpaths: T.Set[str] = set()
+        for pcfile in project_root.glob("**/*.pc"):
+            pcpaths.add(str(pcfile.parent))
+
+        if pcpaths:
+            # Add to PKG_CONFIG_PATH so that it can be resolved by other hatchling
+            # plugins if desired
+            pkg_config_path = os.environ.get("PKG_CONFIG_PATH")
+            if pkg_config_path is not None:
+                os.environ["PKG_CONFIG_PATH"] = os.pathsep.join(
+                    (pkg_config_path, *pcpaths)
+                )
+            else:
+                os.environ["PKG_CONFIG_PATH"] = os.pathsep.join(pcpaths)
+
+        plan = makeplan(project_root, missing_yaml_ok=True)
+
+        for item in plan:
+            if not isinstance(item, BuildTarget) or item.command != "header2dat":
+                continue
+
+            # convert args to string so we can parse it
+            # .. this is weird, but less annoying than other alternatives
+            #    that I can think of?
+            argv = []
+            for arg in item.args:
+                if isinstance(arg, str):
+                    argv.append(arg)
+                elif isinstance(arg, InputFile):
+                    argv.append(str(arg.path.absolute()))
+                elif isinstance(arg, pathlib.Path):
+                    argv.append(str(arg.absolute()))
+                else:
+                    # anything else shouldn't matter
+                    argv.append("ignored")
+
+            sparser = make_argparser()
+            sargs = sparser.parse_args(argv)
 
-        s = get_setup()
-        for wrapper in s.wrappers:
             reporter = MissingReporter()
-            wrapper.on_build_gen("", reporter)
-
-            nada = True
-            for name, report in reporter.as_yaml():
-                report = f"---\n\n{pfx}{report}"
-
-                nada = False
-                if args.write:
-                    if not exists(name):
-                        print("Writing", name)
-                        with open(name, "w") as fp:
-                            fp.write(report)
-                    else:
-                        print(name, "already exists!")
-
-                print("===", name, "===")
-                print(report)
-
-            if nada:
-                print("Nothing to do!")
+
+            generate_wrapper(
+                name=sargs.name,
+                src_yml=sargs.src_yml,
+                src_h=sargs.src_h,
+                src_h_root=sargs.src_h_root,
+                dst_dat=None,
+                dst_depfile=None,
+                include_paths=sargs.include_paths,
+                casters={},
+                pp_defines=sargs.pp_defines,
+                missing_reporter=reporter,
+                report_only=True,
+            )
+
+            if reporter:
+                for name, report in reporter.as_yaml():
+                    report = f"---\n\n{report}"
+
+                    if args.write:
+                        if not name.exists():
+                            print("Writing", name)
+                            with open(name, "w") as fp:
+                                fp.write(report)
+                        else:
+                            print(name, "already exists!")
+
+                    print("===", name, "===")
+                    print(report)

src/semiwrap/tool/create_imports.py

@@ -1,16 +1,19 @@
 import inspect
 import posixpath
 import subprocess
+import sys
 import typing
 import types
 
+from ..pyproject import PyProject
+
 
 class ImportCreator:
     @classmethod
     def add_subparser(cls, parent_parser, subparsers):
         parser = subparsers.add_parser(
             "create-imports",
-            help="Generate suitable imports for a module",
+            help="Generate suitable imports for a module. Prefer using update-init",
             parents=[parent_parser],
         )
         parser.add_argument("base", help="Ex: wpiutil")
@@ -35,11 +38,17 @@ def create(self, base: str, compiled: typing.Optional[str], write: bool):
         try:
             import black
         except:
-            print("Error, The following module is required to run this tool: black")
-            exit(1)
+            print(
+                "Error, The following module is required to run this tool: black",
+                file=sys.stderr,
+            )
+            return 1
 
         if not compiled:
             compiled = f"{base}._{base.split('.')[-1]}"
+            print(f"CHK base={base} compiled={compiled} (auto)")
+        else:
+            print(f"CHK base={base} compiled={compiled}")
 
         # TODO: could probably generate this from parsed code, but seems hard
         ctx = {}
@@ -51,7 +60,8 @@ def create(self, base: str, compiled: typing.Optional[str], write: bool):
         relimport = self._rel(base, compiled)
 
         stmt_compiled = "" if not compiled else f" {compiled}"
-        begin_stmt = f"# autogenerated by 'robotpy-build create-imports {base}"
+        begin_stmt = f"# autogenerated by 'semiwrap create-imports {base}"
+        old_begin_stmt = f"# autogenerated by 'robotpy-build create-imports {base}"
 
         stmt = inspect.cleandoc(
             f"""
@@ -77,6 +87,9 @@ def create(self, base: str, compiled: typing.Optional[str], write: bool):
 
             # Find the beginning statement
             idx = startidx = fcontent.find(begin_stmt)
+            if startidx == -1:
+                idx = startidx = fcontent.find(old_begin_stmt)
+
             if startidx != -1:
                 for to_find in ("from", "__all__", "[", "]", "\n"):
                     idx = fcontent.find(to_find, idx)
@@ -99,3 +112,32 @@ def create(self, base: str, compiled: typing.Optional[str], write: bool):
 
         else:
             print(content)
+
+
+class UpdateInit:
+    @classmethod
+    def add_subparser(cls, parent_parser, subparsers):
+        parser = subparsers.add_parser(
+            "update-init",
+            help="Updates __init__.py files using settings from tool.semiwrap.update_init",
+            parents=[parent_parser],
+        )
+        return parser
+
+    def run(self, args):
+        project = PyProject().project
+
+        if project.update_init is None:
+            print("[tool.semiwrap].update_init not set", file=sys.stderr)
+            return 1
+
+        ic = ImportCreator()
+
+        for to_update in project.update_init:
+            if " " in to_update:
+                base, compiled = to_update.split(" ", 1)
+            else:
+                base = to_update
+                compiled = None
+
+            ic.create(base, compiled, True)