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

linkml/generators/graphqlgen.py

@@ -24,6 +24,7 @@ class GraphqlGenerator(Generator):
 
     strict_naming: bool = False
     _permissible_value_valid_characters = re.compile("^[_A-Za-z][_0-9A-Za-z]*?$")
+    _types_any = []
 
     def __post_init__(self):
         self.name_compatiblity = NameCompatibility(profile=NamingProfiles.graphql, do_not_fix=self.strict_naming)
@@ -39,6 +40,10 @@ class GraphqlGenerator(Generator):
         return out
 
     def visit_class(self, cls: ClassDefinition) -> str:
+        # no type can be declared for subtypes of "Any"
+        if cls.class_uri == "linkml:Any":
+            self._types_any.append(cls.name)
+            return f"scalar {cls.name}"
         etype = "interface" if (cls.abstract or cls.mixin) and not cls.mixins else "type"
         mixins = ", ".join([camelcase(mixin) for mixin in cls.mixins])
         out = f"{etype} {camelcase(cls.name)}" + (f" implements {mixins}" if mixins else "")
@@ -46,14 +51,35 @@ class GraphqlGenerator(Generator):
         return out
 
     def end_class(self, cls: ClassDefinition) -> str:
-        return "\n  }\n\n"
+        if cls.name in self._types_any:
+            return "\n\n"
+        else:
+            return "\n  }\n\n"
 
     def visit_class_slot(self, cls: ClassDefinition, aliased_slot_name: str, slot: SlotDefinition) -> str:
-        slotrange = (
-            camelcase(slot.range)
-            if slot.range in self.schema.classes or slot.range in self.schema.types or slot.range in self.schema.enums
-            else "String"
-        )
+        if slot.range in self.schema.classes or slot.range in self.schema.slots or slot.range in self.schema.enums:
+            slotrange = camelcase(slot.range)
+        elif slot.range in self.schema.types:
+            if self.schema.types[slot.range].from_schema != "https://w3id.org/linkml/types":
+                slotrange = camelcase(slot.range)
+            else:
+                graphql_scalars = ["Int", "Float", "String", "Boolean", "ID"]
+                if slot.range == "integer":
+                    slotrange = "Int"
+                elif slot.range == "decimal":
+                    slotrange = "Float"
+                elif camelcase(slot.range) in graphql_scalars:
+                    slotrange = camelcase(slot.range)
+                else:
+                    if self.schema.types[slot.range].repr:
+                        python_type = self.schema.types[slot.range].repr
+                    elif self.schema.types[slot.range].base:
+                        python_type = self.schema.types[slot.range].base
+                    if str(python_type) == "float":
+                        slotrange = "Float"
+                    elif str(python_type) == "str":
+                        slotrange = "String"
+
         if slot.multivalued:
             slotrange = f"[{slotrange}]"
         if slot.required:

linkml/generators/jsonldcontextgen.py

@@ -1,11 +1,12 @@
 """
 Generate JSON-LD contexts
-
 """
 
+import json
 import os
 import re
 from dataclasses import dataclass, field
+from pathlib import Path
 from typing import Any, Optional, Union
 
 import click
@@ -50,6 +51,12 @@ class ContextGenerator(Generator):
     prefixes: Optional[bool] = True
     flatprefixes: Optional[bool] = False
 
+    # Framing (opt-in via CLI flag)
+    emit_frame: bool = False
+    embed_context_in_frame: bool = False
+    frame_body: dict = field(default_factory=lambda: dict())
+    frame_root: Optional[str] = None
+
     def __post_init__(self) -> None:
         super().__post_init__()
         if self.namespaces is None:
@@ -121,10 +128,40 @@ class ContextGenerator(Generator):
             for k, v in self.slot_class_maps.items():
                 context_content[k] = v
         context["@context"] = context_content
-        if output:
+        if output and not self.embed_context_in_frame:
             with open(output, "w", encoding="UTF-8") as outf:
                 outf.write(as_json(context))
 
+        if self.emit_frame and self.frame_body and output:
+            root_name = None
+            for cname, c in self.schema.classes.items():
+                if getattr(c, "tree_root", False):
+                    root_name = cname
+                    break
+            if root_name is None and self.schema.classes:
+                root_name = next(iter(self.schema.classes))
+
+            if self.embed_context_in_frame:
+                frame = {
+                    "@context": context["@context"],
+                    "@omitGraph": True,
+                }
+            else:
+                frame = {
+                    "@context": Path(output).name,
+                    "@omitGraph": True,
+                }
+            if root_name:
+                root_cls = self.schema.classes[root_name]
+                frame["@type"] = root_cls.class_uri or root_cls.name
+
+            for prop, rule in self.frame_body.items():
+                frame[prop] = rule
+
+            frame_path = Path(output).with_suffix(".frame.jsonld")
+            with open(frame_path, "w", encoding="UTF-8") as f:
+                json.dump(frame, f, indent=2, ensure_ascii=False)
+
         return str(as_json(context)) + "\n"
 
     def visit_class(self, cls: ClassDefinition) -> bool:
@@ -136,6 +173,10 @@ class ContextGenerator(Generator):
         if class_def:
             self.slot_class_maps[cn] = class_def
 
+        # prefer explicit tree_root for frame @type
+        if getattr(cls, "tree_root", False):
+            self.frame_root = cls.name
+
         # We don't bother to visit class slots - just all slots
         return True
 
@@ -146,13 +187,7 @@ class ContextGenerator(Generator):
             slot_def = {}
             if not slot.usage_slot_name:
                 any_of_ranges = [any_of_el.range for any_of_el in slot.any_of]
-                if slot.range in self.schema.classes:
-                    range_class_uri = self.schema.classes[slot.range].class_uri
-                    if range_class_uri and slot.inlined:
-                        slot_def["@type"] = range_class_uri
-                    else:
-                        slot_def["@type"] = "@id"
-                elif any(rng in self.schema.classes for rng in any_of_ranges):
+                if slot.range in self.schema.classes or any(rng in self.schema.classes for rng in any_of_ranges):
                     slot_def["@type"] = "@id"
                 elif slot.range in self.schema.enums:
                     slot_def["@context"] = ENUM_CONTEXT
@@ -174,7 +209,12 @@ class ContextGenerator(Generator):
                 self._build_element_id(slot_def, slot.slot_uri)
                 self.add_mappings(slot)
         if slot_def:
-            self.context_body[underscore(aliased_slot_name)] = slot_def
+            key = underscore(aliased_slot_name)
+            self.context_body[key] = slot_def
+
+            # collect @embed only for object-valued slots (range is a class)
+            if slot.range in self.schema.classes and slot.inlined is not None:
+                self.frame_body[key] = {"@embed": "@always" if bool(slot.inlined) else "@never"}
 
     def _build_element_id(self, definition: Any, uri: str) -> None:
         """
@@ -227,10 +267,36 @@ class ContextGenerator(Generator):
     show_default=True,
     help="Emit non-JSON-LD compliant prefixes as an object (deprecated: use gen-prefix-map instead).",
 )
+@click.option(
+    "--emit-frame/--no-emit-frame",
+    default=False,
+    show_default=True,
+    help="Also emit a <schema>.frame.jsonld file with @embed rules for framing",
+)
+@click.option(
+    "--embed-context-in-frame/--no-embed-context-in-frame",
+    default=False,
+    show_default=True,
+    help="Emit a <schema>.frame.jsonld file with @context embedded directly (single file)",
+)
+@click.option(
+    "-o",
+    "--output",
+    type=click.Path(),
+    help="Output file name",
+)
 @click.version_option(__version__, "-V", "--version")
-def cli(yamlfile, **args):
+def cli(yamlfile, emit_frame, embed_context_in_frame, output, **args):
     """Generate jsonld @context definition from LinkML model"""
-    print(ContextGenerator(yamlfile, **args).serialize(**args))
+    if (emit_frame or embed_context_in_frame) and not output:
+        raise click.UsageError("--emit-frame/--embed-context-in-frame requires --output")
+    gen = ContextGenerator(yamlfile, **args)
+    if embed_context_in_frame:
+        gen.emit_frame = True
+        gen.embed_context_in_frame = True
+    else:
+        gen.emit_frame = emit_frame
+    print(gen.serialize(output=output, **args))
 
 
 if __name__ == "__main__":

linkml/generators/jsonschemagen.py

@@ -49,13 +49,14 @@ json_schema_types: dict[str, tuple[str, Optional[str]]] = {
 
 class JsonSchema(dict):
     OPTIONAL_IDENTIFIER_SUFFIX = "__identifier_optional"
+    PRESERVE_NAMES: bool = False
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._lax_forward_refs = {}
 
     def add_def(self, name: str, subschema: "JsonSchema") -> None:
-        canonical_name = camelcase(name)
+        canonical_name = name if self.PRESERVE_NAMES else camelcase(name)
 
         if "$defs" not in self:
             self["$defs"] = {}
@@ -78,7 +79,7 @@ class JsonSchema(dict):
             names = [names]
 
         for name in names:
-            canonical_name = camelcase(name)
+            canonical_name = name if self.PRESERVE_NAMES else camelcase(name)
 
             if "$defs" not in self or canonical_name not in self["$defs"]:
                 self._lax_forward_refs[canonical_name] = identifier_name
@@ -90,7 +91,7 @@ class JsonSchema(dict):
     def add_property(
         self, name: str, subschema: "JsonSchema", *, value_required: bool = False, value_disallowed: bool = False
     ) -> None:
-        canonical_name = underscore(name)
+        canonical_name = name if self.PRESERVE_NAMES else underscore(name)
 
         if "properties" not in self:
             self["properties"] = {}
@@ -149,7 +150,7 @@ class JsonSchema(dict):
     @classmethod
     def ref_for(cls, class_name: Union[str, list[str]], identifier_optional: bool = False, required: bool = True):
         def _ref(class_name):
-            def_name = camelcase(class_name)
+            def_name = class_name if cls.PRESERVE_NAMES else camelcase(class_name)
             def_suffix = cls.OPTIONAL_IDENTIFIER_SUFFIX if identifier_optional else ""
             return JsonSchema({"$ref": f"#/$defs/{def_name}{def_suffix}"})
 
@@ -169,8 +170,8 @@ class JsonSchema(dict):
         return ref
 
     @classmethod
-    def array_of(cls, subschema: "JsonSchema", required: bool = True) -> "JsonSchema":
-        if required:
+    def array_of(cls, subschema: "JsonSchema", include_null: bool, required: bool = True) -> "JsonSchema":
+        if required or not include_null:
             typ = "array"
         else:
             typ = ["array", "null"]
@@ -265,6 +266,9 @@ class JsonSchemaGenerator(Generator, LifecycleMixin):
     include_null: bool = True
     """Whether to include a "null" type in optional slots"""
 
+    preserve_names: bool = False
+    """If true, preserve LinkML element names in JSON Schema output (e.g., for $defs, properties, $ref targets)."""
+
     def __post_init__(self):
         if self.topClass:
             logger.warning("topClass is deprecated - use top_class")
@@ -272,6 +276,9 @@ class JsonSchemaGenerator(Generator, LifecycleMixin):
 
         super().__post_init__()
 
+        # Set the class variable for JsonSchema to use
+        JsonSchema.PRESERVE_NAMES = self.preserve_names
+
         if self.top_class:
             if self.schemaview.get_class(self.top_class) is None:
                 logger.warning(f"No class in schema named {self.top_class}")
@@ -372,9 +379,13 @@ class JsonSchemaGenerator(Generator, LifecycleMixin):
 
         self.top_level_schema.add_def(cls.name, class_subschema)
 
-        if (self.top_class is not None and camelcase(self.top_class) == camelcase(cls.name)) or (
-            self.top_class is None and cls.tree_root
-        ):
+        if (
+            self.top_class is not None
+            and (
+                (self.preserve_names and self.top_class == cls.name)
+                or (not self.preserve_names and camelcase(self.top_class) == camelcase(cls.name))
+            )
+        ) or (self.top_class is None and cls.tree_root):
             for key, value in class_subschema.items():
                 # check this first to ensure we don't overwrite things like additionalProperties
                 # or description on the root. But we do want to copy over properties, required,
@@ -534,7 +545,7 @@ class JsonSchemaGenerator(Generator, LifecycleMixin):
                     "additionalProperties": True,
                 }
             )
-            return JsonSchema.array_of(prop, required=slot.required)
+            return JsonSchema.array_of(prop, include_null, required=slot.required)
         slot_is_multivalued = "multivalued" in slot and slot.multivalued
         slot_is_inlined = self.schemaview.is_inlined(slot)
         slot_is_boolean = any([slot.any_of, slot.all_of, slot.exactly_one_of, slot.none_of])
@@ -579,7 +590,7 @@ class JsonSchemaGenerator(Generator, LifecycleMixin):
                         prop = JsonSchema({"type": typ, "additionalProperties": additionalProps})
                         self.top_level_schema.add_lax_def(reference, self.aliased_slot_name(range_id_slot))
                     else:
-                        prop = JsonSchema.array_of(JsonSchema.ref_for(reference), required=slot.required)
+                        prop = JsonSchema.array_of(JsonSchema.ref_for(reference), include_null, required=slot.required)
                 else:
                     prop = JsonSchema.ref_for(reference, required=slot.required or not include_null)
 
@@ -592,7 +603,7 @@ class JsonSchemaGenerator(Generator, LifecycleMixin):
                     prop = JsonSchema({"type": typ, "format": fmt})
 
                 if slot_is_multivalued:
-                    prop = JsonSchema.array_of(prop, required=slot.required)
+                    prop = JsonSchema.array_of(prop, include_null, required=slot.required)
                 else:
                     # handle optionals - bools like any_of, etc. below as they call this method recursively
                     if not slot.required and not slot_is_boolean and include_null:
@@ -763,6 +774,12 @@ YAML, and including it when necessary but not by default (e.g. in documentation
     show_default=True,
     help="If set, patterns will be materialized in the generated JSON Schema.",
 )
+@click.option(
+    "--preserve-names/--normalize-names",
+    default=False,
+    show_default=True,
+    help="Preserve original LinkML names in JSON Schema output (e.g., for $defs, properties, $ref targets).",
+)
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, **kwargs):
     """Generate JSON Schema representation of a LinkML model"""

linkml/generators/mermaidclassdiagramgen.py

@@ -8,6 +8,7 @@ from typing import Optional
 import click
 from jinja2 import Environment, FileSystemLoader
 from linkml_runtime.linkml_model.meta import Element, SlotDefinition
+from linkml_runtime.utils.formatutils import camelcase, underscore
 from linkml_runtime.utils.schemaview import SchemaView
 
 from linkml.generators.docgen import DocGenerator
@@ -34,6 +35,7 @@ class MermaidClassDiagramGenerator(Generator):
     directory: Optional[str] = None  # output directory with generated markdown files
     template_file: Optional[str] = None  # custom/default jinja template for class diagrams
     classes: list[str] = field(default_factory=list)  # optional subset of classes
+    preserve_names: bool = False  # preserve original LinkML names in diagram output
 
     def __post_init__(self):
         super().__post_init__()
@@ -59,7 +61,7 @@ class MermaidClassDiagramGenerator(Generator):
         template_name = os.path.basename(self.template_file)
         loader = FileSystemLoader(template_folder)
         env = Environment(loader=loader)
-        temp_doc_gen = DocGenerator(self.schema, mergeimports=self.mergeimports)
+        temp_doc_gen = DocGenerator(self.schema, mergeimports=self.mergeimports, preserve_names=self.preserve_names)
         temp_doc_gen.customize_environment(env)
 
         template = env.get_template(template_name)
@@ -74,7 +76,8 @@ class MermaidClassDiagramGenerator(Generator):
         for cn, class_def in class_items:
             self.logger.info(f"Generating Mermaid diagram for class: {cn}")
             rendered = template.render(gen=self, element=class_def, schemaview=self.schemaview)
-            outfile = self.output_directory / f"{cn}.md"
+            filename = self.name(class_def) if self.preserve_names else cn
+            outfile = self.output_directory / f"{filename}.md"
             with open(outfile, "w", encoding="utf-8") as f:
                 f.write(rendered)
 
@@ -88,7 +91,16 @@ class MermaidClassDiagramGenerator(Generator):
 
     def name(self, element: Element) -> str:
         """Returns the canonical name for an element."""
-        return element.name
+        if element is None:
+            return ""
+        if self.preserve_names:
+            return element.name
+        elif type(element).class_name == "slot_definition":
+            return underscore(element.name)
+        elif type(element).class_name == "class_definition":
+            return camelcase(element.name)
+        else:
+            return camelcase(element.name)
 
     def link_mermaid(self, element):
         """Generates a link for the given element."""
@@ -121,6 +133,12 @@ class MermaidClassDiagramGenerator(Generator):
     help="One or more classes in the schema for which to generate diagrams. "
     "If omitted, diagrams for all classes are generated.",
 )
+@click.option(
+    "--preserve-names/--normalize-names",
+    default=False,
+    show_default=True,
+    help="Preserve original LinkML names in Mermaid diagram output (e.g., for class names, slot names, file names).",
+)
 @click.version_option(click.__version__, "-V", "--version")
 def cli(yamlfile, template_file, directory, classes, **args):
     logging.basicConfig(level=logging.INFO)

linkml/generators/owlgen.py

@@ -1250,7 +1250,10 @@ class OwlSchemaGenerator(Generator):
         if pv.meaning:
             return URIRef(self.schemaview.expand_curie(pv.meaning))
         else:
-            return URIRef(enum_uri + self.enum_iri_separator + pv.text.replace(" ", "+"))
+            from urllib.parse import quote
+
+            encoded_text = quote(pv.text.strip(), safe="", encoding="utf-8")
+            return URIRef(enum_uri + self.enum_iri_separator + encoded_text)
 
     def slot_owl_type(self, slot: SlotDefinition) -> URIRef:
         sv = self.schemaview

linkml/generators/panderagen/dataframe_class.py

@@ -0,0 +1,13 @@
+from linkml.generators.oocodegen import OOClass
+
+
+class DataframeClass(OOClass):
+    """Serves as an adapter between the template that renders the form of the
+    dataframe schema and the LinkML model and schema view.
+
+    Currently a thin wrapper around OOClass
+    until the dataframe requirements are fully understood.
+    """
+
+    def identifier_key_slot(self):
+        return self.annotations.get("identifier_key_slot", None)

linkml/generators/panderagen/dataframe_field.py

@@ -0,0 +1,50 @@
+from contextlib import suppress
+
+from linkml.generators.oocodegen import OOField
+
+
+class DataframeField(OOField):
+    """Serves as an adapter between the template that renders the form of the
+    dataframe schema fields and the LinkML model and schema view.
+
+    Currently a thin wrapper around OOField
+    until the dataframe requirements are fully understood.
+    """
+
+    def inline_form(self):
+        return self.source_slot.annotations._get("inline_form", None)
+
+    def reference_class(self):
+        with suppress(AttributeError, KeyError):
+            return self.source_slot.annotations._get("reference_class", None)
+        return None
+
+    def maximum_value(self):
+        return self.source_slot.maximum_value
+
+    def minimum_value(self):
+        return self.source_slot.minimum_value
+
+    def pattern(self):
+        return self.source_slot.pattern
+
+    def minimum_cardinality(self):
+        return self.source_slot.minimum_cardinality
+
+    def maximum_cardinality(self):
+        return self.source_slot.maximum_cardinality
+
+    def permissible_values(self):
+        return self.source_slot.annotations._get("permissible_values", [])
+
+    def inline_details(self):
+        return self.source_slot.annotations._get("inline_details", None)
+
+    def required(self):
+        return self.source_slot.required
+
+    def identifier(self):
+        return self.source_slot.identifier
+
+    def description(self):
+        return self.source_slot.description

linkml/generators/panderagen/linkml_pandera_validator.py

@@ -0,0 +1,186 @@
+import inspect
+from functools import wraps
+
+import pandera
+import polars as pl
+from pandera.api.polars.types import PolarsData
+
+from linkml.generators.panderagen.transforms import (
+    CollectionDictModelTransform,
+    ListDictModelTransform,
+    NestedStructModelTransform,
+    SimpleDictModelTransform,
+)
+
+
+def handle_validation_exceptions(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except pl.exceptions.PanicException:
+            data = args[2] if len(args) > 2 else kwargs.get("data")
+            return data.lazyframe.select(pl.lit(False))
+        except pandera.errors.SchemaError as e:
+            raise e
+        except Exception:
+            data = args[2] if len(args) > 2 else kwargs.get("data")
+            return data.lazyframe.select(pl.lit(False))
+
+    return wrapper
+
+
+class LinkmlPanderaValidator:
+    @classmethod
+    def get_id_column_name(cls):
+        return cls._id_name
+
+    @classmethod
+    def _simple_dict_fields(cls, column_name):
+        details = cls._INLINE_DETAILS[column_name]  # <-- THESE ARE GOING ON THE OUTER CLASS
+
+        return (details["id"], details["other"])
+
+    @classmethod
+    def _prepare_simple_dict(cls, data: PolarsData):
+        """Returns just the simple dict column transformed to an inlined list form
+
+        note that this method uses collect and iter_rows so is very inefficient
+        """
+        column_name = data.key
+        polars_schema = cls.get_nested_range(column_name).to_schema()
+        (id_column, other_column) = cls._simple_dict_fields(column_name)
+
+        simple_dict_transformer = SimpleDictModelTransform(polars_schema, id_column, other_column)
+
+        one_column_df = data.lazyframe.select(pl.col(column_name)).collect()
+
+        list_of_structs = [simple_dict_transformer.transform(e) for [e] in one_column_df.iter_rows()]
+
+        return pl.DataFrame(pl.Series(list_of_structs).alias(column_name))
+
+    @classmethod
+    @handle_validation_exceptions
+    def _check_simple_dict(cls, data: PolarsData):
+        """
+        The 'simple dict' format, in which the key serves as a local identifier is not a good match for a PolaRS
+        DataFrame. At present the format is
+        """
+        df = cls._prepare_simple_dict(data)
+
+        column_name = data.key
+
+        polars_schema = cls.get_nested_range(column_name).to_schema()
+        simple_transform = SimpleDictModelTransform(polars_schema, *cls._simple_dict_fields(column_name))
+        df = simple_transform.explode_unnest_dataframe(df, column_name)
+
+        nested_cls = cls.get_nested_range(column_name)
+        nested_cls.validate(df)
+        return data.lazyframe.select(pl.lit(True))
+
+    @classmethod
+    @handle_validation_exceptions
+    def _check_collection_struct(cls, data: PolarsData):
+        column_name = data.key
+        nested_cls = cls.get_nested_range(column_name)
+
+        df = CollectionDictModelTransform.prepare_dataframe(data, column_name, nested_cls)
+
+        collection_transform = CollectionDictModelTransform(nested_cls.to_schema(), nested_cls.get_id_column_name())
+        df = collection_transform.explode_unnest_dataframe(df, column_name)
+
+        nested_cls.validate(df)
+        return data.lazyframe.select(pl.lit(True))
+
+    @classmethod
+    @handle_validation_exceptions
+    def _check_nested_list_struct(cls, data: PolarsData):
+        """Use this in a custom check. Pass the nested model as pandera_model."""
+        column_name = data.key
+        nested_cls = cls.get_nested_range(column_name)
+
+        df = ListDictModelTransform.prepare_dataframe(data, column_name, nested_cls)
+
+        list_transform = ListDictModelTransform(nested_cls.to_schema())
+        df = list_transform.explode_unnest_dataframe(df, column_name, data)
+
+        nested_cls.validate(df)
+        return data.lazyframe.select(pl.lit(True))
+
+    @classmethod
+    @handle_validation_exceptions
+    def _check_nested_struct(cls, data: PolarsData):
+        """Use this in a custom check. Pass the nested model as pandera_model."""
+        column_name = data.key
+        nested_cls = cls.get_nested_range(column_name)
+
+        df = NestedStructModelTransform.prepare_dataframe(data, column_name, nested_cls)
+        nested_transform = NestedStructModelTransform(nested_cls.to_schema())
+        df = nested_transform.explode_unnest_dataframe(df, column_name)
+
+        nested_cls.validate(df)
+        return data.lazyframe.select(pl.lit(True))
+
+    @classmethod
+    def get_nested_range(cls, column_name):
+        """Resolve a nested class range at runtime.
+
+        Nested classes are not stored in the pandera schema,
+        but rather in the _NESTED_RANGES dictionary as strings.
+        """
+        nested_cls_name = cls._NESTED_RANGES[column_name]
+        shared_model_module = inspect.getmodule(cls)
+        nested_cls = getattr(shared_model_module, nested_cls_name)
+
+        return nested_cls
+
+    @classmethod
+    def generate_polars_schema_simple(cls):
+        # This is not nesting or list aware, so needs to be aligned with the other method
+        return pl.Struct({k: v.dtype.type for k, v in cls.to_schema().columns.items()})
+
+    @classmethod
+    def generate_polars_schema(cls, object_to_validate, parser=False) -> dict:
+        """Creates a nested PolaRS schema suitable for loading the object_to_validate.
+        Optional columns that are not present in the data are omitted.
+        This approach is only suitable to enable the test fixtures.
+        """
+        polars_schema = {}
+
+        if isinstance(object_to_validate, list):
+            object_to_validate = object_to_validate[0]
+
+        for column_name, column in cls.to_schema().columns.items():
+            dtype = column.properties["dtype"]
+            required = column.properties["required"]
+
+            if required or column_name in object_to_validate:
+                if dtype.type in [pl.Struct, pl.List]:  # maybe use inline form directly here
+                    inline_form = cls._INLINE_FORM.get(column_name, "not_inline")
+                    if inline_form == "simple_dict":
+                        polars_schema[column_name] = pl.Object  # make this a struct and make the nested non-
+                    elif inline_form == "not_inline":
+                        polars_schema[column_name] = dtype.type
+                    else:
+                        nested_cls = cls.get_nested_range(column_name)
+                        if inline_form == "inlined_dict":
+                            if parser:
+                                nested_schema = nested_cls.generate_polars_schema(
+                                    object_to_validate[column_name], parser
+                                )
+                                polars_schema[column_name] = pl.Struct(nested_schema)
+                            else:
+                                polars_schema[column_name] = pl.Struct
+                        elif inline_form == "inlined_list_dict":
+                            if parser:
+                                nested_schema = nested_cls.generate_polars_schema(
+                                    object_to_validate[column_name], parser
+                                )
+                                polars_schema[column_name] = pl.List(pl.Struct(nested_schema))
+                            else:
+                                # transformed form
+                                polars_schema[column_name] = pl.List
+                else:
+                    polars_schema[column_name] = dtype.type
+
+        return polars_schema