linkml 1.9.5rc1__py3-none-any.whl → 1.9.5rc2__py3-none-any.whl

linkml/cli/main.py

@@ -7,6 +7,7 @@ Gathers all the other linkml click entrypoints and puts them under ``linkml`` :)
 import click
 
 from linkml._version import __version__
+from linkml.converter.cli import cli as linkml_convert
 from linkml.generators.csvgen import cli as gen_csv
 from linkml.generators.dbmlgen import cli as gen_dbml
 from linkml.generators.docgen import cli as gen_doc
@@ -46,7 +47,6 @@ from linkml.generators.yamlgen import cli as gen_yaml
 from linkml.generators.yarrrmlgen import cli as gen_yarrrml
 from linkml.generators.yumlgen import cli as gen_yuml
 from linkml.linter.cli import main as linkml_lint
-from linkml.utils.converter import cli as linkml_convert
 from linkml.utils.execute_tutorial import cli as run_tutorial
 from linkml.utils.schema_fixer import main as linkml_schema_fixer
 from linkml.utils.sqlutils import main as linkml_sqldb

linkml/generators/owlgen.py

@@ -229,7 +229,7 @@ class OwlSchemaGenerator(Generator):
         data = self.graph.serialize(format="turtle" if self.format in ["owl", "ttl"] else self.format)
         return data
 
-    def add_metadata(self, e: Definition, uri: URIRef) -> None:
+    def add_metadata(self, e: Union[Definition, PermissibleValue], uri: URIRef) -> None:
         """
         Add annotation properties.
 
@@ -866,6 +866,10 @@ class OwlSchemaGenerator(Generator):
             if impl.startswith("rdfs:"):
                 return RDFS[impl.split(":")[1]]
         if isinstance(default_value, str):
+            if default_value.startswith("owl:"):
+                return OWL[default_value.split(":")[1]]
+            if default_value.startswith("rdfs:"):
+                return RDFS[default_value.split(":")[1]]
             return URIRef(default_value)
         return default_value
 
@@ -873,6 +877,8 @@ class OwlSchemaGenerator(Generator):
         g = self.graph
         enum_uri = self._enum_uri(e.name)
         g.add((enum_uri, RDF.type, OWL.Class))
+
+        self.add_metadata(e, enum_uri)
         has_parent = False
         if e.is_a:
             self.graph.add((enum_uri, RDFS.subClassOf, self._enum_uri(e.is_a)))
@@ -916,6 +922,7 @@ class OwlSchemaGenerator(Generator):
                 )
             )
             if not isinstance(pv_node, Literal):
+                self.add_metadata(pv, pv_node)
                 g.add((pv_node, RDF.type, pv_owl_type))
                 g.add((pv_node, RDFS.label, Literal(pv.text)))
                 # TODO: make this configurable
@@ -936,6 +943,7 @@ class OwlSchemaGenerator(Generator):
                 if not has_parent and self.add_root_classes:
                     self.graph.add((pv_node, RDFS.subClassOf, URIRef(PermissibleValue.class_class_uri)))
         if all([pv is not None for pv in pv_uris]):
+            # every single PV in the enum is not-null
             all_is_class = all([owl_type == OWL.Class for owl_type in owl_types])
             all_is_individual = all([owl_type == OWL.NamedIndividual for owl_type in owl_types])
             all_is_literal = all([owl_type == RDFS.Literal for owl_type in owl_types])

linkml/generators/rustgen/build.py

@@ -1,3 +1,5 @@
+from pydantic import Field
+
 from linkml.generators.common.build import (
     BuildResult,
     SchemaResult,
@@ -84,6 +86,7 @@ class CrateResult(RustBuildResult, SchemaResult):
     file: RustFile
     extra_files: dict[str, RustTemplateModel]
     pyproject: RustPyProject
+    bin_files: dict[str, RustTemplateModel] = Field(default_factory=dict)
 
 
 class FileResult(RustBuildResult, SchemaResult):

linkml/generators/rustgen/cli.py

@@ -40,6 +40,14 @@ from linkml.utils.generator import shared_arguments
         "this flag only enables the crate feature by default."
     ),
 )
+@click.option(
+    "--handwritten-lib/--no-handwritten-lib",
+    default=False,
+    help=(
+        "When enabled, place generated sources under src/generated and create a shim lib.rs for handwritten code. "
+        "The shim is only created on first run and left untouched on subsequent regenerations."
+    ),
+)
 @click.option("-n", "--crate-name", type=str, default=None, help="Name of the generated crate/module")
 @click.option(
     "-o",
@@ -56,10 +64,20 @@ def cli(
     pyo3: bool = False,
     serde: bool = False,
     crate_name: Optional[str] = None,
+    handwritten_lib: bool = False,
     output: Optional[Path] = None,
     **kwargs,
 ):
-    gen = RustGenerator(yamlfile, mode=mode, pyo3=pyo3, serde=serde, output=output, crate_name=crate_name, **kwargs)
+    gen = RustGenerator(
+        yamlfile,
+        mode=mode,
+        pyo3=pyo3,
+        serde=serde,
+        output=output,
+        crate_name=crate_name,
+        handwritten_lib=handwritten_lib,
+        **kwargs,
+    )
     serialized = gen.serialize(force=force)
     if output is None:
         print(serialized)

linkml/generators/rustgen/rustgen.py

@@ -44,6 +44,7 @@ from linkml.generators.rustgen.template import (
     RustEnum,
     RustEnumItem,
     RustFile,
+    RustLibShim,
     RustProperty,
     RustPyProject,
     RustRange,
@@ -53,6 +54,8 @@ from linkml.generators.rustgen.template import (
     RustTypeAlias,
     SerdeUtilsFile,
     SlotRangeAsUnion,
+    StubGenBin,
+    StubUtilsFile,
 )
 from linkml.utils.generator import Generator
 
@@ -143,6 +146,22 @@ PYTHON_IMPORTS = Imports(
     ]
 )
 
+STUBGEN_IMPORTS = Imports(
+    imports=[
+        Import(
+            module="pyo3-stub-gen",
+            version="0.13.1",
+            objects=[
+                ObjectImport(name="define_stub_info_gatherer"),
+                ObjectImport(name="derive::gen_stub_pyclass"),
+                ObjectImport(name="derive::gen_stub_pymethods"),
+            ],
+            feature_flag="stubgen",
+            feature_dependencies=["pyo3"],
+        ),
+    ]
+)
+
 
 class SlotContainerMode(Enum):
     SINGLE_VALUE = "single_value"
@@ -369,6 +388,10 @@ class RustGenerator(Generator, LifecycleMixin):
     pyo3_version: str = ">=0.21.1"
     serde: bool = True
     """Generate serde derive serialization/deserialization attributes"""
+    stubgen: bool = True
+    """Generate pyo3-stub-gen instrumentation alongside PyO3 bindings"""
+    handwritten_lib: bool = False
+    """Place generated sources under src/generated and leave src/lib.rs for user code"""
     mode: RUST_MODES = "crate"
     """Generate a cargo.toml file"""
     output: Optional[Path] = None
@@ -386,12 +409,33 @@ class RustGenerator(Generator, LifecycleMixin):
         self.schemaview: SchemaView = SchemaView(self.schema)
         super().__post_init__()
 
+    def _select_root_class(self, class_defs: list[ClassDefinition]) -> Optional[ClassDefinition]:
+        """Return the schema-local class marked ``tree_root`` if present."""
+
+        schema_id = getattr(self.schemaview.schema, "id", None)
+
+        def is_local(cls: ClassDefinition) -> bool:
+            if schema_id is None:
+                return cls.from_schema is None
+            return cls.from_schema == schema_id
+
+        local_classes = [cls for cls in class_defs if is_local(cls) and not getattr(cls, "mixin", False)]
+
+        for cls in local_classes:
+            if getattr(cls, "tree_root", False):
+                return cls
+
+        return None
+
     def generate_type(self, type_: TypeDefinition) -> TypeResult:
         type_ = self.before_generate_type(type_, self.schemaview)
         res = TypeResult(
             source=type_,
             type_=RustTypeAlias(
-                name=get_name(type_), type_=get_rust_type(type_.base, self.schemaview, self.pyo3), pyo3=self.pyo3
+                name=get_name(type_),
+                type_=get_rust_type(type_.base, self.schemaview, self.pyo3),
+                pyo3=self.pyo3,
+                stubgen=self.stubgen,
             ),
             imports=self.get_imports(type_),
         )
@@ -414,6 +458,7 @@ class RustGenerator(Generator, LifecycleMixin):
                 items=items,
                 pyo3=self.pyo3,
                 serde=self.serde,
+                stubgen=self.stubgen,
             ),
         )
         res = self.after_generate_enum(res, self.schemaview)
@@ -435,6 +480,7 @@ class RustGenerator(Generator, LifecycleMixin):
                 multivalued=slot.multivalued,
                 pyo3=self.pyo3,
                 class_range=class_range,
+                stubgen=self.stubgen,
             ),
             imports=self.get_imports(slot),
         )
@@ -466,6 +512,7 @@ class RustGenerator(Generator, LifecycleMixin):
                     SlotRangeAsUnion(
                         slot_name=get_name(a),
                         ranges=[get_rust_type(r, self.schemaview, True) for r in ranges],
+                        stubgen=self.stubgen,
                     )
                 )
 
@@ -473,6 +520,7 @@ class RustGenerator(Generator, LifecycleMixin):
             class_name=get_name(cls),
             class_name_snakecase=underscore(uncamelcase(cls.name)),
             slot_ranges=slot_range_unions,
+            stubgen=self.stubgen,
         )
 
         attributes = [self.generate_attribute(attr, cls) for attr in induced_attrs]
@@ -489,6 +537,7 @@ class RustGenerator(Generator, LifecycleMixin):
                 unsendable=unsendable,
                 pyo3=self.pyo3,
                 serde=self.serde,
+                stubgen=self.stubgen,
                 as_key_value=self.generate_class_as_key_value(cls),
                 struct_or_subtype_enum=self.gen_struct_or_subtype_enum(cls),
                 class_module=cls_mod,
@@ -511,12 +560,17 @@ class RustGenerator(Generator, LifecycleMixin):
                 values = get_accepted_type_designator_values(self.schemaview, td, d_class)
                 td_mapping[d] = values
         if len(descendants) > 0:
+            key_type = "String"
+            key_slot = get_key_or_identifier_slot(cls, self.schemaview)
+            if key_slot is not None:
+                key_type = get_rust_type(key_slot.range, self.schemaview, self.pyo3)
             return RustStructOrSubtypeEnum(
                 enum_name=get_name(cls) + "OrSubtype",
                 struct_names=[get_name(self.schemaview.get_class(d)) for d in descendants],
                 type_designator_name=get_name(td) if td else None,
                 as_key_value=get_key_or_identifier_slot(cls, self.schemaview) is not None,
                 type_designators=td_mapping,
+                key_property_type=key_type,
             )
         return None
 
@@ -525,6 +579,7 @@ class RustGenerator(Generator, LifecycleMixin):
         key_attr = None
         value_attrs = []
         value_args_no_default = []
+        non_key_attrs = []
 
         for attr in induced_attrs:
             if attr.identifier:
@@ -538,6 +593,7 @@ class RustGenerator(Generator, LifecycleMixin):
                     return None
                 key_attr = attr
             else:
+                non_key_attrs.append(attr)
                 if not attr.multivalued:
                     value_attrs.append(attr)
                     if attr.required:
@@ -547,16 +603,27 @@ class RustGenerator(Generator, LifecycleMixin):
             # attribute to serve as the value, do not treat this as a key/value class.
             if len(value_attrs) == 0:
                 return None
+            value_attr = value_attrs[0]
+            simple_dict_possible = (
+                len(non_key_attrs) == 1
+                and not value_attr.multivalued
+                and (
+                    value_attr.range not in self.schemaview.all_classes()
+                    or not bool(getattr(value_attr, "inlined", False))
+                )
+            )
             return AsKeyValue(
                 name=get_name(cls),
                 key_property_name=get_name(key_attr),
                 key_property_type=get_rust_type(key_attr.range, self.schemaview, self.pyo3),
-                value_property_name=get_name(value_attrs[0]),
-                value_property_type=get_rust_type(value_attrs[0].range, self.schemaview, self.pyo3),
-                can_convert_from_primitive=len(value_args_no_default) <= 1,
+                value_property_name=get_name(value_attr),
+                value_property_type=get_rust_type(value_attr.range, self.schemaview, self.pyo3),
+                can_convert_from_primitive=simple_dict_possible,
                 can_convert_from_empty=len(value_args_no_default) == 0,
+                value_property_optional=not bool(value_attr.required),
                 serde=self.serde,
                 pyo3=self.pyo3,
+                stubgen=self.stubgen,
             )
         return None
 
@@ -583,6 +650,7 @@ class RustGenerator(Generator, LifecycleMixin):
                 and self.generate_class_as_key_value(self.schemaview.get_class(attr.range)) is not None,
                 pyo3=self.pyo3,
                 serde=self.serde,
+                stubgen=self.stubgen,
             ),
             imports=self.get_imports(attr),
         )
@@ -602,6 +670,7 @@ class RustGenerator(Generator, LifecycleMixin):
             pyo3_version=self.pyo3_version,
             pyo3=self.pyo3,
             serde=self.serde,
+            stubgen=self.stubgen,
         )
 
     def generate_pyproject(self) -> RustPyProject:
@@ -658,7 +727,10 @@ class RustGenerator(Generator, LifecycleMixin):
         slots = self.after_generate_slots(slots, sv)
 
         need_merge_crate = False
-        classes = list(sv.induced_class(c) for c in sv.all_classes(ordered_by=OrderedBy.INHERITANCE))
+        class_defs = [sv.induced_class(c) for c in sv.all_classes(ordered_by=OrderedBy.INHERITANCE)]
+        root_class_def = self._select_root_class(class_defs)
+        root_struct_name = get_name(root_class_def) if root_class_def is not None else None
+        classes = class_defs
         for c in classes:
             if MERGE_ANNOTATION in c.annotations:
                 need_merge_crate = True
@@ -673,6 +745,8 @@ class RustGenerator(Generator, LifecycleMixin):
         imports = DEFAULT_IMPORTS.model_copy()
         imports += PYTHON_IMPORTS
         imports += SERDE_IMPORTS
+        if self.stubgen:
+            imports += STUBGEN_IMPORTS
         if need_merge_crate:
             imports += MERGE_IMPORTS
         for result in [*enums, *slots, *classes]:
@@ -687,6 +761,9 @@ class RustGenerator(Generator, LifecycleMixin):
             structs=[c.cls for c in classes],
             pyo3=self.pyo3,
             serde=self.serde,
+            stubgen=self.stubgen,
+            handwritten_lib=self.handwritten_lib,
+            root_struct_name=root_struct_name,
         )
 
         if mode == "crate":
@@ -694,9 +771,21 @@ class RustGenerator(Generator, LifecycleMixin):
             extra_files["serde_utils"] = SerdeUtilsFile()
             extra_files["poly"] = PolyFile(imports=imports, traits=poly_traits)
             extra_files["poly_containers"] = PolyContainersFile()
+            if self.stubgen:
+                extra_files["stub_utils"] = StubUtilsFile()
             cargo = self.generate_cargo(imports)
             pyproject = self.generate_pyproject()
-            res = CrateResult(cargo=cargo, file=file, pyproject=pyproject, source=sv.schema, extra_files=extra_files)
+            bin_files = {}
+            if self.stubgen:
+                bin_files["bin/stub_gen"] = StubGenBin(crate_name=cargo.name, stubgen=self.stubgen)
+            res = CrateResult(
+                cargo=cargo,
+                file=file,
+                pyproject=pyproject,
+                source=sv.schema,
+                extra_files=extra_files,
+                bin_files=bin_files,
+            )
             return res
         else:
             # Single file: inline serde utils, and skip poly modules
@@ -973,33 +1062,54 @@ class RustGenerator(Generator, LifecycleMixin):
             rendered = self.render(mode="crate")
 
         cargo = rendered.cargo.render(self.template_environment)
-        # Normalize EOF: exactly one trailing newline
-        cargo = cargo.rstrip("\n") + "\n"
         cargo_file = output / "Cargo.toml"
-        with open(cargo_file, "w") as cfile:
-            cfile.write(cargo)
+        self._write_text_file(cargo_file, cargo, crate_root=output)
 
         pyproject = rendered.pyproject.render(self.template_environment)
-        pyproject = pyproject.rstrip("\n") + "\n"
         pyproject_file = output / "pyproject.toml"
-        with open(pyproject_file, "w") as pyfile:
-            pyfile.write(pyproject)
+        self._write_text_file(pyproject_file, pyproject, crate_root=output)
 
         rust_file = rendered.file.render(self.template_environment)
-        rust_file = rust_file.rstrip("\n") + "\n"
         src_dir = output / "src"
         src_dir.mkdir(exist_ok=True)
-        lib_file = src_dir / "lib.rs"
-        with open(lib_file, "w") as lfile:
-            lfile.write(rust_file)
+        if self.handwritten_lib:
+            generated_dir = src_dir / "generated"
+            generated_dir.mkdir(exist_ok=True)
+            lib_file = generated_dir / "mod.rs"
+        else:
+            generated_dir = src_dir
+            lib_file = src_dir / "lib.rs"
+        self._write_text_file(lib_file, rust_file, crate_root=output)
 
         for k, f in rendered.extra_files.items():
             extra_file = f.render(self.template_environment)
-            extra_file = extra_file.rstrip("\n") + "\n"
             extra_file_name = f"{k}.rs"
-            extra_file_path = src_dir / extra_file_name
-            with open(extra_file_path, "w") as ef:
-                ef.write(extra_file)
+            extra_file_path = self._safe_subpath(generated_dir, extra_file_name)
+            self._write_text_file(extra_file_path, extra_file, crate_root=output)
+
+        if getattr(rendered, "bin_files", None):
+            for rel_path, template in rendered.bin_files.items():
+                rendered_bin = template.render(self.template_environment)
+                safe_bin_base = self._safe_subpath(src_dir, rel_path)
+                bin_path = safe_bin_base.with_suffix(".rs")
+                self._write_text_file(bin_path, rendered_bin, crate_root=output)
+
+        if self.handwritten_lib:
+            shim_path = src_dir / "lib.rs"
+            if not shim_path.exists():
+                root_struct_name = getattr(rendered.file, "root_struct_name", None)
+                root_struct_fn_snake = underscore(uncamelcase(root_struct_name)) if root_struct_name else None
+                shim_template = RustLibShim(
+                    module_name=rendered.file.name,
+                    pyo3=self.pyo3,
+                    serde=self.serde,
+                    stubgen=self.stubgen,
+                    handwritten_lib=self.handwritten_lib,
+                    root_struct_name=root_struct_name,
+                    root_struct_fn_snake=root_struct_fn_snake,
+                )
+                shim = shim_template.render(self.template_environment)
+                self._write_text_file(shim_path, shim, crate_root=output)
 
         return rust_file
 
@@ -1031,6 +1141,44 @@ class RustGenerator(Generator, LifecycleMixin):
 
         return output
 
+    def _safe_subpath(self, base: Path, relative: Union[str, Path]) -> Path:
+        """Return a path nested under base, validating it does not escape."""
+
+        rel_path = Path(relative)
+        if rel_path.is_absolute():
+            raise ValueError(f"Relative path expected, got absolute path: {relative}")
+
+        if not rel_path.parts:
+            raise ValueError("Relative path must contain at least one segment")
+
+        for part in rel_path.parts:
+            if part in (".", ".."):
+                raise ValueError(f"Invalid path segment: {part}")
+            if "/" in part or "\\" in part:
+                raise ValueError(f"Path segment must not contain separators: {part}")
+
+        candidate = base / rel_path
+        base_resolved = base.resolve()
+        try:
+            candidate.resolve().relative_to(base_resolved)
+        except ValueError as exc:  # pragma: no cover - defensive
+            raise ValueError(f"Path {candidate} escapes base directory {base}") from exc
+
+        return candidate
+
+    def _write_text_file(self, path: Path, content: str, *, crate_root: Path) -> None:
+        """Normalize trailing newline, ensure parent dirs, and write text."""
+
+        base_resolved = crate_root.resolve()
+        try:
+            path.resolve().relative_to(base_resolved)
+        except ValueError as exc:
+            raise ValueError(f"Path {path} escapes crate root {crate_root}") from exc
+
+        normalized = content.rstrip("\n") + "\n"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(normalized)
+
     @property
     def template_environment(self) -> Environment:
         if self._environment is None:

linkml/generators/rustgen/template.py

@@ -221,6 +221,12 @@ class RustTemplateModel(TemplateModel):
     """
     Whether serde serialization/deserialization annotations should be added.
     """
+    stubgen: bool = False
+    """
+    Whether pyo3-stub-gen instrumentation should be emitted.
+    """
+    handwritten_lib: bool = False
+    """Place generated sources under src/generated and leave lib.rs untouched for user code."""
     attributes: dict[str, str] = Field(default_factory=dict)
 
 
@@ -297,6 +303,8 @@ class Import(Import_, RustTemplateModel):
     """Features to require in Cargo.toml"""
     ## whether this import should be behind a feature flag
     feature_flag: Optional[str] = None
+    feature_dependencies: list[str] = Field(default_factory=list)
+    """Additional crate features to enable alongside the optional dependency."""
 
 
 class Imports(Imports_, RustTemplateModel):
@@ -362,6 +370,7 @@ class AsKeyValue(RustTemplateModel):
     value_property_type: str
     can_convert_from_primitive: bool = False
     can_convert_from_empty: bool = False
+    value_property_optional: bool = False
 
 
 class RustStructOrSubtypeEnum(RustTemplateModel):
@@ -371,6 +380,7 @@ class RustStructOrSubtypeEnum(RustTemplateModel):
     as_key_value: bool = False
     type_designator_field: Optional[str] = None
     type_designators: dict[str, str]
+    key_property_type: str = "String"
 
 
 class SlotRangeAsUnion(RustTemplateModel):
@@ -519,6 +529,26 @@ class SerdeUtilsFile(RustTemplateModel):
     template: ClassVar[str] = "serde_utils.rs.jinja"
 
 
+class StubUtilsFile(RustTemplateModel):
+    """Helper utilities shared by stub generation code."""
+
+    template: ClassVar[str] = "stub_utils.rs.jinja"
+
+
+class StubGenBin(RustTemplateModel):
+    """Binary entry point to orchestrate stub generation checks."""
+
+    template: ClassVar[str] = "stub_gen.rs.jinja"
+    crate_name: str
+    stubgen: bool
+
+    @computed_field
+    def crate_module(self) -> str:
+        """Crate identifier usable in Rust source."""
+
+        return self.crate_name.replace("-", "_")
+
+
 class PolyTraitProperty(RustTemplateModel):
     template: ClassVar[str] = "poly_trait_property.rs.jinja"
     name: str
@@ -763,6 +793,7 @@ class RustFile(RustTemplateModel):
     inline_serde_utils: bool = False
     emit_poly: bool = True
     serde_utils: Optional[SerdeUtilsFile] = None
+    root_struct_name: Optional[str] = None
 
     @computed_field
     def struct_names(self) -> list[str]:
@@ -814,14 +845,19 @@ class RustCargo(RustTemplateModel):
 
     @computed_field
     def cratefeatures(self) -> dict[str, list[str]]:
-        feature_flags = {}
+        feature_flags: dict[str, list[str]] = {}
         for i in self.imports.imports:
             assert isinstance(i, Import)
-            if i.feature_flag is not None:
-                if i.feature_flag not in feature_flags:
-                    feature_flags[i.feature_flag] = [i.module]
-                else:
-                    feature_flags[i.feature_flag].append(i.module)
+            if i.feature_flag is None:
+                continue
+            deps = feature_flags.setdefault(i.feature_flag, [])
+            module = i.module.split("::")[0]
+            dep_entry = f"dep:{module}"
+            if dep_entry not in deps:
+                deps.append(dep_entry)
+            for extra in i.feature_dependencies:
+                if extra not in deps:
+                    deps.append(extra)
         return feature_flags
 
     @field_validator("name", mode="after")
@@ -863,3 +899,12 @@ class RustPyProject(RustTemplateModel):
     @classmethod
     def snake_case_name(cls, value: str) -> str:
         return underscore(value)
+
+
+class RustLibShim(RustTemplateModel):
+    """Shim module that re-exports generated code and hosts the PyO3 entry point."""
+
+    template: ClassVar[str] = "lib_shim.rs.jinja"
+    module_name: str
+    root_struct_name: Optional[str] = None
+    root_struct_fn_snake: Optional[str] = None

linkml/generators/rustgen/templates/Cargo.toml.jinja

@@ -6,7 +6,7 @@ edition = "{{ edition }}"
 [lib]
 name = "{{ name }}"
 {% if pyo3 %}
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 {% else %}
 crate-type = ["lib"]
 {% endif %}
@@ -38,5 +38,5 @@ default = ["serde"]
 default = []
 {% endif %}
 {% for k,v in cratefeatures.items() %}
-{{ k }} = [{% for i in v %}"dep:{{ i }}"{% if not loop.last %}, {% endif %}{% endfor %}]
+{{ k }} = [{% for i in v %}"{{ i }}"{% if not loop.last %}, {% endif %}{% endfor %}]
 {% endfor %}

linkml/generators/rustgen/templates/anything.rs.jinja

@@ -5,6 +5,14 @@ pub struct Anything(
 );
 
 
+#[cfg(feature = "stubgen")]
+impl ::pyo3_stub_gen::PyStubType for Anything {
+    fn type_output() -> ::pyo3_stub_gen::TypeInfo {
+        ::pyo3_stub_gen::TypeInfo::any()
+    }
+}
+
+
 #[cfg(feature = "serde")]
 impl Serialize for Anything {
     fn serialize<S>(&self, to_ser: S) -> Result<S::Ok, S::Error>
@@ -91,7 +99,6 @@ impl<'py> IntoPyObject<'py> for Anything {
 
     fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         use pyo3::types::{PyAny, PyDict, PyList, PyString};
-        use pyo3::PyObject;
         use serde_value::Value;
 
         fn value_to_py<'py>(py: Python<'py>, v: &Value) -> pyo3::PyResult<Bound<'py, PyAny>> {