linkml 1.9.1rc2__py3-none-any.whl → 1.9.2rc1__py3-none-any.whl

linkml/cli/main.py

@@ -24,6 +24,7 @@ from linkml.generators.linkmlgen import cli as gen_linkml
 from linkml.generators.markdowngen import cli as gen_markdown
 from linkml.generators.namespacegen import cli as gen_namespaces
 from linkml.generators.owlgen import cli as gen_owl
+from linkml.generators.panderagen import cli as gen_pandera
 from linkml.generators.plantumlgen import cli as gen_plantuml
 from linkml.generators.prefixmapgen import cli as gen_prefix_map
 from linkml.generators.projectgen import cli as gen_project
@@ -110,6 +111,7 @@ generate.add_command(gen_plantuml, name="plantuml")
 generate.add_command(gen_proto, name="proto")
 generate.add_command(gen_python, name="python")
 generate.add_command(gen_pydantic, name="pydantic")
+generate.add_command(gen_pandera, name="pandera")
 generate.add_command(gen_rdf, name="rdf")
 generate.add_command(gen_shex, name="shex")
 generate.add_command(gen_shacl, name="shacl")

linkml/generators/__init__.py

@@ -8,6 +8,7 @@ from linkml.generators.jsonldcontextgen import ContextGenerator
 from linkml.generators.jsonldgen import JSONLDGenerator
 from linkml.generators.jsonschemagen import JsonSchemaGenerator
 from linkml.generators.owlgen import OwlSchemaGenerator
+from linkml.generators.panderagen import PanderaGenerator
 from linkml.generators.pydanticgen import PydanticGenerator
 from linkml.generators.pythongen import PythonGenerator
 from linkml.generators.rdfgen import RDFGenerator
@@ -42,6 +43,7 @@ __all__ = [
     "yumlgen",
     "OwlSchemaGenerator",
     "PydanticGenerator",
+    "PanderaGenerator",
     "PythonGenerator",
     "JavaGenerator",
     "ContextGenerator",

linkml/generators/docgen/class_diagram.md.jinja2

@@ -1,8 +1,10 @@
 {% macro slot_relationship(element, slot) %}
-    {% set range_element = gen.name(schemaview.get_element(slot.range)) %}
-    {% set relation_label = gen.name(slot) %}
-    {{ gen.name(element) }} --> "{{ gen.cardinality(slot) }}" {{ range_element }} : {{ relation_label }}
-    click {{ range_element }} href "../{{ range_element }}"
+    {% if slot.range is not none %}
+        {% set range_element = gen.name(schemaview.get_element(slot.range)) %}
+        {% set relation_label = gen.name(slot) %}
+        {{ gen.name(element) }} --> "{{ gen.cardinality(slot) }}" {{ range_element }} : {{ relation_label }}
+        click {{ range_element }} href "../{{ range_element }}"
+    {% endif %}
 {% endmacro %}
 
 {% if schemaview.class_parents(element.name) and schemaview.class_children(element.name) %}
@@ -22,7 +24,7 @@
       
       {% for s in schemaview.class_induced_slots(element.name)|sort(attribute='name') -%}
         {{ gen.name(element) }} : {{gen.name(s)}}
-        {% if s.range not in gen.all_type_object_names() %}
+        {% if s.range is not none and s.range not in gen.all_type_object_names() %}
           {{ slot_relationship(element, s) }}
         {% endif %}
       {% endfor %}
@@ -38,7 +40,7 @@
       {% endfor %}
       {% for s in schemaview.class_induced_slots(element.name)|sort(attribute='name') -%}
         {{ gen.name(element) }} : {{gen.name(s)}}
-        {% if s.range not in gen.all_type_object_names() %}
+        {% if s.range is not none and s.range not in gen.all_type_object_names() %}
           {{ slot_relationship(element, s) }}
         {% endif %}
       {% endfor %}
@@ -54,7 +56,7 @@
       {% endfor %}
       {% for s in schemaview.class_induced_slots(element.name)|sort(attribute='name') -%}
         {{ gen.name(element) }} : {{gen.name(s)}}
-        {% if s.range not in gen.all_type_object_names() %}
+        {% if s.range is not none and s.range not in gen.all_type_object_names() %}
           {{ slot_relationship(element, s) }}
         {% endif %}
       {% endfor %}
@@ -66,7 +68,7 @@
     click {{ gen.name(element) }} href "../{{gen.name(element)}}"
       {% for s in schemaview.class_induced_slots(element.name)|sort(attribute='name') -%}
         {{ gen.name(element) }} : {{gen.name(s)}}
-        {% if s.range not in gen.all_type_object_names() %}
+        {% if s.range is not none and s.range not in gen.all_type_object_names() %}
           {{ slot_relationship(element, s) }}
         {% endif %}
       {% endfor %}

linkml/generators/docgen/common_metadata.md.jinja2

@@ -62,7 +62,7 @@ Instances of this class *should* have identifiers with one of the following pref
 {% for a in element.annotations -%}
 {%- if a|string|first != '_' -%}
 | {{ a }} | {{ element.annotations[a].value }} |
-{%- endif -%}
+{% endif -%}
 {% endfor %}
 {% endif %}
 

linkml/generators/docgen/index.md.jinja2

@@ -21,7 +21,7 @@ Name: {{ schema.name }}
 | --- | --- |
 {% if gen.hierarchical_class_view -%}
 {% for u, v in gen.class_hierarchy_as_tuples() -%}
-| {{ " "|safe*u*8 }}{{ gen.link(schemaview.get_class(v), True) }} | {{ schemaview.get_class(v).description }} |
+| {{ " "|safe*u*8 }}{{ gen.link(schemaview.get_class(v), True) }} | {{ schemaview.get_class(v).description|enshorten }} |
 {% endfor %}
 {% else -%}
 {% for c in gen.all_class_objects()|sort(attribute=sort_by) -%}

linkml/generators/docgen.py

@@ -61,7 +61,7 @@ SUBSET_SUBFOLDER = "subsets"
 
 def enshorten(input):
     """
-    Custom filter to truncate any long text intended to go in a table,
+    Custom filters to truncate any long text intended to go in a table
     and to remove anything after a newline"""
     if input is None:
         return ""
@@ -76,8 +76,11 @@ def enshorten(input):
     return input
 
 
-def customize_environment(env: Environment):
-    env.filters["enshorten"] = enshorten
+def text_to_web(input) -> str:
+    """Custom filter to convert multi-line text strings into a suitable format for web/markdown output."""
+    if input is None:
+        return ""
+    return "<br>".join(input.strip().split("\n"))
 
 
 def _ensure_ranked(elements: Iterable[Element]):
@@ -155,6 +158,9 @@ class DocGenerator(Generator):
     subfolder_type_separation: bool = False
     """Whether each type (class, slot, etc.) should be put in separate subfolder for navigation purposes"""
 
+    truncate_descriptions: bool = True
+    """Whether to truncate long (multi-line) descriptions down to a single line."""
+
     example_directory: Optional[str] = None
     example_runner: ExampleRunner = field(default_factory=lambda: ExampleRunner())
 
@@ -314,7 +320,7 @@ class DocGenerator(Generator):
             # TODO: relative paths
             # loader = FileSystemLoader()
             env = Environment()
-            customize_environment(env)
+            self.customize_environment(env)
             return env.get_template(path)
         else:
             base_file_name = f"{element_type}.{self._file_suffix()}.jinja2"
@@ -332,7 +338,7 @@ class DocGenerator(Generator):
                 folder = os.path.join(package_dir, "docgen", "")
             loader = FileSystemLoader(folder)
             env = Environment(loader=loader)
-            customize_environment(env)
+            self.customize_environment(env)
             return env.get_template(base_file_name)
 
     def schema_title(self) -> str:
@@ -384,6 +390,10 @@ class DocGenerator(Generator):
         if isinstance(element, (EnumDefinition, SubsetDefinition)):
             # TODO: fix schema view to handle URIs for enums and subsets
             return self.name(element)
+
+        if self.subfolder_type_separation:
+            return self.schemaview.get_uri(element, expand=expand, use_element_type=True)
+
         return self.schemaview.get_uri(element, expand=expand)
 
     def uri_link(self, element: Union[Element, str]) -> str:
@@ -955,13 +965,19 @@ class DocGenerator(Generator):
                 objs.append((stem, f.read()))
         return objs
 
+    def customize_environment(self, env: Environment):
+        if self.truncate_descriptions:
+            env.filters["enshorten"] = enshorten
+        else:
+            env.filters["enshorten"] = text_to_web
+
 
 @shared_arguments(DocGenerator)
 @click.option(
     "--directory",
     "-d",
     required=True,
-    help="Folder to which document files are written",
+    help="Path to the directory where you want the Markdown files to be written to",
 )
 @click.option("--index-name", default="index", show_default=True, help="Name of the index document.")
 @click.option("--dialect", help="Dialect or 'flavor' of Markdown used.")
@@ -988,7 +1004,7 @@ class DocGenerator(Generator):
     show_default=True,
     help="Generating metamodel. Only use this for generating meta.py",
 )
-@click.option("--template-directory", help="Folder in which custom templates are kept")
+@click.option("--template-directory", help="Path to the directory with custom jinja2 templates")
 @click.option(
     "--use-slot-uris/--no-use-slot-uris",
     default=False,
@@ -1027,6 +1043,14 @@ YAML, and including it when necessary but not by default (e.g. in documentation
     default=False,
     help="Separate type (class, slot, etc.) outputs in different subfolders for navigation purposes",
 )
+@click.option(
+    "--truncate-descriptions",
+    default=True,
+    show_default=True,
+    help="""
+Whether to truncate long (potentially spanning multiple lines) descriptions of classes, slots, etc., in the docs.
+Set to true for truncated descriptions, and false to display full descriptions.""",
+)
 @click.version_option(__version__, "-V", "--version")
 @click.command(name="doc")
 def cli(
@@ -1040,6 +1064,7 @@ def cli(
     hierarchical_class_view,
     subfolder_type_separation,
     render_imports,
+    truncate_descriptions,
     **args,
 ):
     """Generate documentation folder from a LinkML YAML schema
@@ -1072,6 +1097,7 @@ def cli(
         index_name=index_name,
         subfolder_type_separation=subfolder_type_separation,
         render_imports=render_imports,
+        truncate_descriptions=truncate_descriptions,
         **args,
     )
     print(gen.serialize())

linkml/generators/jsonldgen.py

@@ -162,7 +162,7 @@ class JSONLDGenerator(Generator):
             # model_context = self.schema.source_file.replace('.yaml', '.prefixes.context.jsonld')
             # context = [METAMODEL_CONTEXT_URI, f'file://./{model_context}']
             # TODO: The _visit function above alters the schema in situ
-            add_prefixes = ContextGenerator(self.original_schema, model=False, metadata=False).serialize()
+            add_prefixes = ContextGenerator(self.original_schema, model=False, emit_metadata=False).serialize()
             add_prefixes_json = loads(add_prefixes)
             context = [METAMODEL_CONTEXT_URI, add_prefixes_json["@context"]]
         elif isinstance(context, str):  # Some of the older code doesn't do multiple contexts

linkml/generators/markdowngen.py

@@ -18,6 +18,7 @@ from linkml_runtime.utils.formatutils import be, camelcase, underscore
 
 from linkml._version import __version__
 from linkml.generators.yumlgen import YumlGenerator
+from linkml.utils.deprecation import deprecation_warning
 from linkml.utils.generator import Generator, shared_arguments
 from linkml.utils.typereferences import References
 
@@ -31,8 +32,24 @@ class MarkdownGenerator(Generator):
     additionally, an index.md is generated that links everything together.
 
     The markdown is suitable for deployment as a MkDocs or Sphinx site
+
+    .. admonition:: Deprecated
+        :class: warning
+
+            The MarkdownGenerator class is being deprecated in favor of DocGenerator which can
+            be found at the following path – `linkml/generators/docgen.py`. Going forward, DocGenerator
+            which can be invoked using the `gen-doc` command will be the preferred way to generate
+            Markdown documentation files for LinkML schemas.
+
+            .. deprecated:: v1.9.1
+
+            Recommendation: Update to use `gen-doc`
     """
 
+    def __post_init__(self) -> None:
+        deprecation_warning("gen-markdown")
+        super().__post_init__()
+
     # ClassVars
     generatorname = os.path.basename(__file__)
     generatorversion = "0.2.1"
@@ -799,7 +816,13 @@ def pad_heading(text: str) -> str:
 @click.option("--warnonexist", is_flag=True, help="Warn if output file already exists")
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, map_fields, dir, img, index_file, notypesdir, warnonexist, **kwargs):
-    """Generate markdown documentation of a LinkML model"""
+    """Generate markdown documentation of a LinkML model.
+
+    .. warning::
+        `gen-markdown` is deprecated. Please use `gen-doc` instead.
+    """
+    deprecation_warning("gen-markdown")
+
     gen = MarkdownGenerator(yamlfile, no_types_dir=notypesdir, warn_on_exist=warnonexist, **kwargs)
     if map_fields is not None:
         gen.metamodel_name_map = {}

linkml/generators/mermaidclassdiagramgen.py

@@ -10,7 +10,7 @@ from jinja2 import Environment, FileSystemLoader
 from linkml_runtime.linkml_model.meta import Element, SlotDefinition
 from linkml_runtime.utils.schemaview import SchemaView
 
-from linkml.generators.docgen import DocGenerator, customize_environment
+from linkml.generators.docgen import DocGenerator
 from linkml.utils.generator import Generator, shared_arguments
 
 
@@ -59,7 +59,8 @@ class MermaidClassDiagramGenerator(Generator):
         template_name = os.path.basename(self.template_file)
         loader = FileSystemLoader(template_folder)
         env = Environment(loader=loader)
-        customize_environment(env)
+        temp_doc_gen = DocGenerator(self.schema, mergeimports=self.mergeimports)
+        temp_doc_gen.customize_environment(env)
 
         template = env.get_template(template_name)
 

linkml/generators/panderagen/__init__.py

@@ -0,0 +1,9 @@
+from .panderagen import (
+    PanderaGenerator,
+    cli,
+)
+
+__all__ = [
+    "cli",
+    "PanderaGenerator",
+]

linkml/generators/panderagen/class_generator_mixin.py

@@ -0,0 +1,20 @@
+from linkml_runtime.linkml_model import ClassDefinitionName
+
+
+class ClassGeneratorMixin:
+    def ordered_classes(self):
+        return [self.schemaview.get_class(cn, strict=True) for cn in self.order_classes_by_hierarchy()]
+
+    def order_classes_by_hierarchy(self) -> list[ClassDefinitionName]:
+        sv = self.schemaview
+        olist = sv.class_roots()
+        unprocessed = [cn for cn in sv.all_classes() if cn not in olist]
+
+        while len(unprocessed) > 0:
+            ext_list = [cn for cn in unprocessed if not any(p for p in sv.class_parents(cn) if p not in olist)]
+            if len(ext_list) == 0:
+                raise ValueError(f"Cycle in hierarchy, cannot process: {unprocessed}")
+            olist += ext_list
+            unprocessed = [cn for cn in unprocessed if cn not in olist]
+
+        return olist

linkml/generators/panderagen/enum_generator_mixin.py

@@ -0,0 +1,17 @@
+from linkml_runtime.linkml_model.meta import PermissibleValue, PermissibleValueText
+
+
+class EnumGeneratorMixin:
+    def escape_permissible_value_text(self, pv_text):
+        return pv_text.replace("'", "\\'").replace('"', '\\"')
+
+    def extract_permissible_text(self, pv):
+        if isinstance(pv, str) or isinstance(pv, PermissibleValueText):
+            return self.escape_permissible_value_text(pv)
+        elif isinstance(pv, PermissibleValue):
+            return pv.text.code
+        else:
+            raise ValueError(f"Invalid permissible value in enum : {pv}")
+
+    def get_enum_permissible_values(self, enum):
+        return list(map(self.extract_permissible_text, enum.permissible_values or []))

linkml/generators/panderagen/panderagen.py

@@ -0,0 +1,216 @@
+import logging
+import os
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import PurePosixPath
+from types import ModuleType
+from typing import Optional
+
+import click
+from jinja2 import Environment, PackageLoader
+from linkml_runtime.linkml_model.meta import TypeDefinition
+from linkml_runtime.utils.compile_python import compile_python
+from linkml_runtime.utils.formatutils import camelcase
+from linkml_runtime.utils.schemaview import SchemaView
+
+from linkml._version import __version__
+from linkml.generators.oocodegen import OOClass, OOCodeGenerator, OODocument
+
+from .class_generator_mixin import ClassGeneratorMixin
+from .enum_generator_mixin import EnumGeneratorMixin
+from .slot_generator_mixin import SlotGeneratorMixin
+
+logger = logging.getLogger(__name__)
+
+
+# keys are template_path
+TYPEMAP = {
+    "panderagen_class_based": {
+        "xsd:string": "str",
+        "xsd:integer": "int",
+        "xsd:float": "float",
+        "xsd:double": "float",
+        "xsd:boolean": "bool",
+        "xsd:dateTime": "DateTime",
+        "xsd:date": "Date",
+        "xsd:time": "Time",
+        "xsd:anyURI": "str",
+        "xsd:decimal": "float",
+    },
+}
+
+
+class TemplateEnum(Enum):
+    CLASS_BASED = "panderagen_class_based"
+
+
+@dataclass
+class PanderaGenerator(OOCodeGenerator, EnumGeneratorMixin, ClassGeneratorMixin, SlotGeneratorMixin):
+    """
+    Generates Pandera python classes from a LinkML schema.
+
+    Status: incompletely implemented
+
+    One styles is supported:
+
+    - panderagen_class_based
+    """
+
+    DEFAULT_TEMPLATE_PATH = "panderagen_class_based"
+    DEFAULT_TEMPLATE_FILE = "pandera.jinja2"
+
+    # ClassVars
+    generatorname = os.path.basename(__file__)
+    generatorstem = PurePosixPath(generatorname).stem
+    generatorversion = "0.0.1"
+    valid_formats = ["python"]
+    file_extension = "py"
+    java_style = False
+
+    # ObjectVars
+    template_file: Optional[str] = None
+    template_path: str = DEFAULT_TEMPLATE_PATH
+
+    gen_classvars: bool = True
+    gen_slots: bool = True
+    genmeta: bool = False
+    emit_metadata: bool = True
+    coerce: bool = False
+
+    def default_value_for_type(self, typ: str) -> str:
+        """Allow underlying framework to handle default if not specified."""
+        return None
+
+    @staticmethod
+    def make_multivalued(range: str) -> str:
+        return f"List[{range}]"
+
+    def uri_type_map(self, xsd_uri: str, template: str = None):
+        if template is None:
+            template = self.template_path
+
+        return TYPEMAP[template].get(xsd_uri)
+
+    def map_type(self, t: TypeDefinition) -> str:
+        if t.uri:
+            typ = self.uri_type_map(t.uri)
+            return typ
+        elif t.typeof:
+            typ = self.map_type(self.schemaview.get_type(t.typeof))
+            return typ
+        else:
+            raise ValueError(f"{t} cannot be mapped to a type")
+
+    def load_template(self, template_filename):
+        jinja_env = Environment(loader=PackageLoader("linkml.generators.panderagen", self.template_path))
+        return jinja_env.get_template(template_filename)
+
+    def compile_pandera(self) -> ModuleType:
+        """
+        Generates and compiles Pandera model
+        """
+        pandera_code = self.serialize()
+
+        return compile_python(pandera_code)
+
+    def serialize(self, rendered_module: Optional[OODocument] = None) -> str:
+        """
+        Serialize the schema to a Pandera module as a string
+        """
+        if self.template_path is None:
+            self.template_path = PanderaGenerator.DEFAULT_TEMPLATE_PATH
+
+        if rendered_module is not None:
+            module = rendered_module
+        else:
+            module = self.render()
+
+        if self.template_file is None:
+            self.template_file = PanderaGenerator.DEFAULT_TEMPLATE_FILE
+        template_file = self.template_file
+
+        template_obj = self.load_template(template_file)
+
+        code = template_obj.render(
+            doc=module,
+            metamodel_version=self.schema.metamodel_version,
+            model_version=self.schema.version,
+            coerce=self.coerce,
+            type_map=TYPEMAP,
+            template_path=self.template_path,
+        )
+        return code
+
+    def render(self) -> OODocument:
+        """
+        Create a data structure ready to pass to the serialization templates.
+        """
+        sv: SchemaView = self.schemaview
+
+        module_name = camelcase(sv.schema.name)
+
+        oodoc = OODocument(name=module_name, package=self.package, source_schema=sv.schema)
+
+        classes = []
+
+        for c in self.ordered_classes():
+            cn = c.name
+            safe_cn = camelcase(cn)
+            ooclass = OOClass(
+                name=safe_cn,
+                description=c.description,
+                package=self.package,
+                fields=[],
+                source_class=c,
+            )
+            classes.append(ooclass)
+            if c.mixin:
+                ooclass.mixin = c.mixin
+            if c.mixins:
+                ooclass.mixins = [(x) for x in c.mixins]
+            if c.is_a:
+                ooclass.is_a = self.get_class_name(c.is_a)
+                parent_slots = sv.class_slots(c.is_a)
+            else:
+                parent_slots = []
+            for sn in sv.class_slots(cn):
+                oofield = self.handle_slot(cn, sn)
+                if sn not in parent_slots:
+                    ooclass.fields.append(oofield)
+                ooclass.all_fields.append(oofield)
+
+        oodoc.classes = classes
+
+        return oodoc
+
+
+@click.option("--package", help="Package name where relevant for generated class files")
+@click.option("--template-path", help="Optional jinja2 template directory within module")
+@click.option("--template-file", help="Optional jinja2 template to use for class generation")
+@click.version_option(__version__, "-V", "--version")
+@click.argument("yamlfile")
+@click.command(name="gen-pandera")
+def cli(
+    yamlfile,
+    package=None,
+    template_path=None,
+    template_file=None,
+    **args,
+):
+    if template_path is not None and template_path not in TYPEMAP:
+        raise Exception(f"Template {template_path} not supported")
+
+    """Generate Pandera classes to represent a LinkML model"""
+    gen = PanderaGenerator(
+        yamlfile,
+        package=package,
+        template_path=template_path,
+        template_file=template_file,
+        **args,
+    )
+
+    print(gen.serialize())
+
+
+if __name__ == "__main__":
+    cli()

linkml/generators/panderagen/panderagen_class_based/class.jinja2

@@ -0,0 +1,26 @@
+{#-
+  Jinja2 Template for a Pandera class-based model
+  Details at https://pandera.readthedocs.io/en/stable/dataframe_models.html
+-#}
+{%- import 'slots.jinja2' as slot_macros -%}
+
+{%- macro render_class(cls) %}
+class {{cls.name}}(
+        {%- if cls.is_a -%}
+            {{ cls.is_a }}
+        {%- else -%}
+            pla.DataFrameModel, _LinkmlPanderaValidator
+        {%- endif -%}
+):
+    {%- if cls.source_class.description %}
+    """
+    {{ cls.source_class.description }}
+    """
+    {% endif -%}
+    {%- if (cls.fields | length) == 0 %}
+    pass
+    {% endif -%}
+    {%- for field in cls.fields -%}
+        {{ slot_macros.render_slot(field) }}
+    {%- endfor -%}
+{% endmacro -%}

linkml/generators/panderagen/panderagen_class_based/enums.jinja2

@@ -0,0 +1,9 @@
+{%- macro enum_parameter(slot) -%}
+    {%- if slot.annotations['permissible_values']|length > 0 -%}
+        dtype_kwargs={"categories":(
+        {%- for pv in slot.annotations['permissible_values'] -%}
+            '{{ pv }}',
+        {%- endfor -%}
+        )}
+    {%- endif -%}
+{%- endmacro -%}

linkml/generators/panderagen/panderagen_class_based/header.jinja2

@@ -0,0 +1,21 @@
+{#-
+  Jinja2 Template for imports used for a Pandera model Python module
+-#}
+import pandera.polars as pla
+from pandera.api.polars.types import PolarsData
+import polars as pl
+from typing import Optional, List, Dict
+
+from pandera.typing import (
+    Index,
+    DataFrame,
+    Series
+)
+from pandera.engines.polars_engine import (
+    DateTime,
+    Date,
+    Time,
+    Enum,
+    Struct,
+    Object
+)

linkml/generators/panderagen/panderagen_class_based/mixins.jinja2

@@ -0,0 +1,26 @@
+{#-
+  Jinja2 Template for a mixin class used by the Linkml/Pandera class-based model
+  Inline generation avoids dependencies on LinkML in the generated code.
+
+-#}
+class _LinkmlPanderaValidator:
+
+    @classmethod
+    def generate_polars_schema(cls, object_to_validate) -> 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 = {}
+
+        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 == pl.Struct:
+                    pass
+                else:
+                    polars_schema[column_name] = dtype.type
+
+        return polars_schema

linkml/generators/panderagen/panderagen_class_based/pandera.jinja2

@@ -0,0 +1,16 @@
+{#-
+  Jinja2 Template for the top level of a Pandera class-based model
+  Details at https://pandera.readthedocs.io/
+-#}
+{%- import 'header.jinja2' as header -%}
+{%- import 'class.jinja2' as class_macros -%}
+{%- import 'mixins.jinja2' as mixins -%}
+{{ header }}
+
+{{ mixins }}
+
+{% if metamodel_version %}# metamodel_version: {{metamodel_version}}{% endif %}
+{% if model_version %}# version: {{model_version}}{% endif %}
+{%- for cls in doc.classes -%}
+    {{- class_macros.render_class(cls) -}}
+{%- endfor %}