Many fixes

Author: virtuald

src/semiwrap/autowrap/context.py

@@ -372,6 +372,9 @@ class ClassContext:
 
     parent: typing.Optional["ClassContext"]
 
+    #: lookup key for dat2trampoline
+    yml_id: str
+
     #: Namespace that this class lives in
     namespace: str
 

src/semiwrap/autowrap/cxxparser.py

@@ -721,6 +721,7 @@ def on_class_start(self, state: AWClassBlockState) -> typing.Optional[bool]:
 
         ctx = ClassContext(
             parent=parent_ctx,
+            yml_id=cls_key,
             namespace=cls_namespace,
             cpp_name=cls_name,
             full_cpp_name=cls_qualname,

src/semiwrap/casters.py

@@ -1,9 +1,10 @@
 import dataclasses
 import json
+import pathlib
 import typing as T
 
-from validobj.errors import ValidationError
-from validobj.validation import parse_input
+from .config.util import parse_input
+from .util import maybe_write_file
 
 PKGCONF_CASTER_EXT = ".pybind11.json"
 
@@ -23,15 +24,11 @@ class TypeCasterData:
 
 def load_typecaster_data(fname) -> TypeCasterData:
     with open(fname) as fp:
-        try:
-            return parse_input(json.load(fp), TypeCasterData)
-        except ValidationError as e:
-            raise ValidationError(f"Error processing {fname}")
+        return parse_input(json.load(fp), TypeCasterData, fname)
 
 
-def save_typecaster_data(fname, data: TypeCasterData):
-    with open(fname, "w") as fp:
-        json.dump(dataclasses.asdict(data), fp)
+def save_typecaster_data(fname: pathlib.Path, data: TypeCasterData):
+    maybe_write_file(fname, json.dumps(dataclasses.asdict(data)))
 
 
 #: content of pickle file

src/semiwrap/cmd_creategen.py

@@ -36,7 +36,9 @@ def main():
             if isinstance(arg, str):
                 argv.append(arg)
             elif isinstance(arg, InputFile):
-                argv.append(str(arg.path))
+                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")
@@ -50,6 +52,7 @@ def main():
             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,

src/semiwrap/cmd_dat2tmplcpp.py

@@ -1,5 +1,5 @@
 """
-Creates an output .hpp file from a .dat file created by parsing a header
+Creates a template instance .cpp file from a .dat file created by parsing a header
 """
 
 import inspect
@@ -8,36 +8,36 @@
 import sys
 
 from .autowrap.context import HeaderContext
-from .autowrap.render_cls_rpy_include import render_cls_rpy_include_hpp
+from .autowrap.render_tmpl_inst import render_template_inst_cpp
 from .util import maybe_write_file
 
 
 def _write_wrapper_cpp(
-    input_dat: pathlib.Path, class_name: str, output_hpp: pathlib.Path
+    input_dat: pathlib.Path, py_name: str, output_cpp: pathlib.Path
 ):
     with open(input_dat, "rb") as fp:
         hctx = pickle.load(fp)
 
     assert isinstance(hctx, HeaderContext)
 
-    for cls in hctx.classes:
-        if cls.full_cpp_name == class_name:
+    for tmpl in hctx.template_instances:
+        if tmpl.py_name == py_name:
             break
     else:
-        raise ValueError(f"internal error: cannot find {class_name}")
+        raise ValueError(f"internal error: cannot find {py_name}")
 
-    content = render_cls_rpy_include_hpp(hctx, cls)
-    maybe_write_file(output_hpp, content)
+    content = render_template_inst_cpp(hctx, tmpl)
+    maybe_write_file(output_cpp, content)
 
 
 def main():
     try:
-        _, input_dat, class_name, output_hpp = sys.argv
+        _, input_dat, py_name, output_cpp = sys.argv
     except ValueError:
         print(inspect.cleandoc(__doc__ or ""), file=sys.stderr)
         sys.exit(1)
 
-    _write_wrapper_cpp(pathlib.Path(input_dat), class_name, pathlib.Path(output_hpp))
+    _write_wrapper_cpp(pathlib.Path(input_dat), py_name, pathlib.Path(output_cpp))
 
 
 if __name__ == "__main__":

src/semiwrap/cmd_dat2trampoline.py

@@ -7,37 +7,51 @@
 import pickle
 import sys
 
-from .autowrap.context import HeaderContext
+from .autowrap.context import HeaderContext, ClassContext
 from .autowrap.render_cls_rpy_include import render_cls_rpy_include_hpp
 from .util import maybe_write_file
 
 
+def _get_classes(hctx: HeaderContext):
+    def _get_child_classes(c: ClassContext):
+        for c in c.child_classes:
+            yield c
+            _get_child_classes(c)
+
+    for cls in hctx.classes:
+        yield cls
+        yield from _get_child_classes(cls)
+
+
 def _write_wrapper_cpp(
-    input_dat: pathlib.Path, class_name: str, output_hpp: pathlib.Path
+    input_dat: pathlib.Path, yml_id: str, output_hpp: pathlib.Path
 ):
     with open(input_dat, "rb") as fp:
         hctx = pickle.load(fp)
 
     assert isinstance(hctx, HeaderContext)
 
-    for cls in hctx.classes:
-        if cls.full_cpp_name == class_name:
+    avail = []
+    for cls in _get_classes(hctx):
+        avail.append(cls.yml_id)
+        if cls.yml_id == yml_id:
             break
     else:
-        raise ValueError(f"internal error: cannot find {class_name}")
+        avail = ", ".join(avail)
+        raise ValueError(f"internal error: cannot find {yml_id} (found {avail})")
 
     content = render_cls_rpy_include_hpp(hctx, cls)
     maybe_write_file(output_hpp, content)
 
 
 def main():
     try:
-        _, input_dat, class_name, output_hpp = sys.argv
+        _, input_dat, yml_id, output_hpp = sys.argv
     except ValueError:
         print(inspect.cleandoc(__doc__ or ""), file=sys.stderr)
         sys.exit(1)
 
-    _write_wrapper_cpp(pathlib.Path(input_dat), class_name, pathlib.Path(output_hpp))
+    _write_wrapper_cpp(pathlib.Path(input_dat), yml_id, pathlib.Path(output_hpp))
 
 
 if __name__ == "__main__":

src/semiwrap/cmd_gen_libinit.py

@@ -24,10 +24,11 @@
 # TODO: this belongs in a separate script/api that can be used from multiple tools
 # .. maybe in dynamic-library
 def _write_libinit_py(
-    project: PyProject,
+    # project: PyProject,
     init_py: pathlib.Path,
-    libs: T.List[pathlib.Path],
-    requires: T.List[str],
+    modules: T.List[str],
+    # libs: T.List[pathlib.Path],
+    # requires: T.List[str],
 ):
     """
     :param init_py: the _init module for the library(ies) that is written out
@@ -38,22 +39,25 @@ def _write_libinit_py(
                      Their init_py will be looked up and imported first.
     """
 
-    platform = project.platform
+    # platform = project.platform
     r = RenderBuffer()
 
     r.writeln("# This file is automatically generated, DO NOT EDIT")
     r.writeln("# fmt: off")
     r.writeln()
 
+    for mod in modules:
+        r.writeln(f"import {mod}")
+
     need_space = False
-    for req in requires:
-        module = project.pkgconf.get(req).libinit_py
-        if module:
-            r.writeln(f"import {module}")
-            need_space = True
+    # for req in requires:
+    #     module = project.pkgconf.get(req).libinit_py
+    #     if module:
+    #         r.writeln(f"import {module}")
+    #         need_space = True
 
-    if need_space:
-        r.writeln()
+    # if need_space:
+    # r.writeln()
 
     # TODO: don't need this?
 
@@ -114,27 +118,28 @@ def _write_libinit_py(
 
 def main():
     try:
-        _, pyproject_toml, package_name, libinit_py = sys.argv
+        _, libinit_py = sys.argv[:2]
+        modules = sys.argv[2:]
     except ValueError:
         print(inspect.cleandoc(__doc__ or ""), file=sys.stderr)
         sys.exit(1)
 
-    pyproject = PyProject(pathlib.Path(pyproject_toml))
+    # pyproject = PyProject(pathlib.Path(pyproject_toml))
 
-    module = pyproject.get_extension(package_name)
-    depends = pyproject.get_extension_deps(module)
+    # module = pyproject.get_extension(package_name)
+    # depends = pyproject.get_extension_deps(module)
 
     # TODO: libs
     # .. oh, those were going to get created by the downloader hatch plugin
     #    so we don't need them? maybe
-    libs = []
+    # libs = []
 
     # need os, dependencies, section name
     _write_libinit_py(
-        pyproject,
+        # pyproject,
         pathlib.Path(libinit_py),
-        libs,
-        depends,
+        modules,
+        # depends,
     )