Add prefix-based inheritance to codegen

This commit adds th epossibility to specify a parent parser for
each prefix in a Schema SALAD specification. The idea is that each
extensions could come with a different namespace, and would define
its own parser for its classes.

With this commit, a user can leverage the `--codegen-parent` option
to explicitly map a prefix to a parent parser (e.g., a Python module)
with a "prefix=package" syntax. For example:

```bash
--codegen-parent "https://w3id.org/cwl/salad=schema_salad.metaschema"
```

Inheritance is not able to automatically reconstruct the whole class
hierarchy, meaning that if B inherits from A and C inherits from B,
the user must manually specify the mapping also for namespace A.
However, we do not expect huge parser hierarchies for schema SALAD
specifications.

Author: GlassOfWhiskey

schema_salad/codegen.py

@@ -31,6 +31,7 @@ def codegen(
     examples: str | None = None,
     package: str | None = None,
     copyright: str | None = None,
+    parents_map: dict[str, str] | None = None,
     spdx_copyright_text: list[str] | None = None,
     spdx_license_identifier: str | None = None,
     parser_info: str | None = None,
@@ -87,7 +88,11 @@ def codegen(
                     return
                 case "python":
                     gen = PythonCodeGen(
-                        dest, copyright=copyright, parser_info=info, salad_version=salad_version
+                        dest,
+                        copyright=copyright,
+                        parents_map=parents_map,
+                        parser_info=info,
+                        salad_version=salad_version,
                     )
         case "java":
             gen = JavaCodeGen(

schema_salad/main.py

@@ -29,6 +29,15 @@
 _logger: Final = logging.getLogger("salad")
 
 
+def parse_kv(pair: str) -> tuple[str, str]:
+    """Parse `key=value` arguments into a tuple of `key` and `value`."""
+    try:
+        k, v = pair.split("=", 1)
+        return k, v
+    except ValueError as e:
+        raise argparse.ArgumentTypeError(f"Invalid format: '{pair}', expected key=value") from e
+
+
 def printrdf(
     workflow: str,
     wf: CommentedMap | CommentedSeq,
@@ -147,6 +156,15 @@ def arg_parser() -> argparse.ArgumentParser:
         "from the base URL (Java/TypeScript/.Net/Dlang only).",
     )
 
+    codegen_opts.add_argument(
+        "--codegen-parent",
+        type=parse_kv,
+        metavar="PARENTS_MAP",
+        action="append",
+        default=None,
+        help="Optional mapping of prefix into parent package for generated classes (Python only).",
+    )
+
     codegen_opts.add_argument(
         "--codegen-copyright",
         type=str,
@@ -351,6 +369,7 @@ def main(argsl: list[str] | None = None) -> int:
             examples=args.codegen_examples,
             package=args.codegen_package,
             copyright=args.codegen_copyright,
+            parents_map=dict(args.codegen_parent or []),
             spdx_license_identifier=args.codegen_spdx_license_identifier,
             spdx_copyright_text=args.codegen_spdx_copyright_text,
             parser_info=args.codegen_parser_info,

schema_salad/python_codegen.py

@@ -88,6 +88,7 @@ def __init__(
         self,
         out: IO[str],
         copyright: str | None,
+        parents_map: dict[str, str] | None,
         parser_info: str,
         salad_version: str,
     ) -> None:
@@ -97,8 +98,10 @@ def __init__(
         self.serializer = StringIO()
         self.idfield = ""
         self.copyright: Final = copyright
+        self.parents_map: Final = parents_map or {}
         self.parser_info: Final = parser_info
         self.salad_version: Final = salad_version
+        self.inherited_classes: dict[str, str] = {}
 
     @staticmethod
     def safe_name(name: str) -> str:
@@ -126,6 +129,9 @@ def prologue(self) -> None:
 # The original schema is {copyright}.
 """.format(copyright=self.copyright))
 
+        for parent in self.parents_map.values():
+            self.out.write(f"import {parent}\n")
+
         python_codegen_support: Final = (
             files("schema_salad").joinpath("python_codegen_support.py").read_text("UTF-8")
         )
@@ -151,11 +157,15 @@ def begin_class(
         idfield: str,
         optional_fields: set[str],
     ) -> None:
-        classname = self.safe_name(classname)
+        if (classname := self.safe_name(classname)) in self.inherited_classes:
+            self.current_class_is_abstract = True
+            return
         self.current_class_is_abstract = abstract
 
         if extends:
-            ext = ", ".join(self.safe_name(e) for e in extends)
+            ext = ", ".join(
+                self.inherited_classes.get(self.safe_name(e), self.safe_name(e)) for e in extends
+            )
         else:
             ext = "Saveable"
 
@@ -447,11 +457,14 @@ def type_loader(
                 )
 
             case {"type": "record" | "https://w3id.org/cwl/salad#record", "name": name, **rest}:
+                classname = self.safe_name(name)
+                if (prefix := name.split("#")[0]) in self.parents_map:
+                    self.inherited_classes[classname] = f"{self.parents_map[prefix]}.{classname}"
                 return self.declare_type(
                     TypeDef(
-                        self.safe_name(name) + "Loader",
+                        classname + "Loader",
                         "_RecordLoader({}, {}, {})".format(
-                            self.safe_name(name),
+                            self.inherited_classes.get(classname, classname),
                             f"'{container}'" if container is not None else None,  # noqa: B907
                             no_link_check,
                         ),