linkml 1.7.10__tar.gz → 1.8.0__tar.gz

{linkml-1.7.10 → linkml-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.7.10
+Version: 1.8.0
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink
@@ -36,7 +36,7 @@ Requires-Dist: jinja2 (>=3.1.0)
 Requires-Dist: jsonasobj2 (>=1.0.3,<2.0.0)
 Requires-Dist: jsonschema[format] (>=4.0.0)
 Requires-Dist: linkml-dataops
-Requires-Dist: linkml-runtime (>=1.7.4)
+Requires-Dist: linkml-runtime (==1.8.0)
 Requires-Dist: openpyxl
 Requires-Dist: parse
 Requires-Dist: prefixcommons (>=0.1.7)

{linkml-1.7.10 → linkml-1.8.0}/linkml/generators/docgen/class.md.jinja2

@@ -99,20 +99,6 @@ URI: {{ gen.uri_link(element) }}
 
 {% include "common_metadata.md.jinja2" %}
 
-
-{% if schemaview.get_mappings(element.name).items() -%}
-## Mappings
-
-| Mapping Type | Mapped Value |
-| ---  | ---  |
-{% for m, mt in schemaview.get_mappings(element.name).items() -%}
-{% if mt|length > 0 -%}
-| {{ m }} | {{ mt|join(', ') }} |
-{% endif -%}
-{% endfor %}
-
-{% endif -%}
-
 {% if gen.example_object_blobs(element.name) -%}
 ## Examples
 {% for name, blob in gen.example_object_blobs(element.name) -%}

{linkml-1.7.10 → linkml-1.8.0}/linkml/generators/docgen/common_metadata.md.jinja2

@@ -75,4 +75,17 @@ Instances of this class *should* have identifiers with one of the following pref
 {% if element.imported_from %}
 * imported from: {{ element.imported_from }}
 {% endif %}
-{% endif %}
+{% endif %}
+
+{% if schemaview.get_mappings(element.name).items() -%}
+## Mappings
+
+| Mapping Type | Mapped Value |
+| ---  | ---  |
+{% for m, mt in schemaview.get_mappings(element.name).items() -%}
+{% if mt|length > 0 -%}
+| {{ m }} | {{ mt|join(', ') }} |
+{% endif -%}
+{% endfor %}
+
+{% endif -%}

{linkml-1.7.10 → linkml-1.8.0}/linkml/generators/erdiagramgen.py

@@ -1,7 +1,7 @@
 import os
 from dataclasses import dataclass
 from enum import Enum
-from typing import List, Optional, Union
+from typing import List, Optional, Set, Union
 
 import click
 import pydantic
@@ -163,6 +163,7 @@ class ERDiagramGenerator(Generator):
         class_names: List[Union[str, ClassDefinitionName]],
         follow_references=False,
         max_hops: int = None,
+        include_upstream: bool = False,
     ) -> MERMAID_SERIALIZATION:
         """
         Serialize a list of classes as an ER Diagram.
@@ -195,6 +196,15 @@ class ERDiagramGenerator(Generator):
                     if follow_references or sv.is_inlined(slot):
                         if rng not in visited:
                             stack.append((rng, depth + 1))
+
+        # Now Add upstream classes if needed
+        if include_upstream:
+            for sn in sv.all_slots():
+                slot = sv.schema.slots.get(sn)
+                if slot and slot.range in set(class_names):
+                    for cl in sv.all_classes():
+                        if slot.name in sv.get_class(cl).slots and cl not in visited:
+                            self.add_upstream_class(cl, set(class_names), diagram)
         return self.serialize_diagram(diagram)
 
     def serialize_diagram(self, diagram: ERDiagram) -> str:
@@ -210,6 +220,15 @@ class ERDiagramGenerator(Generator):
         else:
             return er
 
+    def add_upstream_class(self, class_name: ClassDefinitionName, targets: Set[str], diagram: ERDiagram) -> None:
+        sv = self.schemaview
+        cls = sv.get_class(class_name)
+        entity = Entity(name=camelcase(cls.name))
+        diagram.entities.append(entity)
+        for slot in sv.class_induced_slots(class_name):
+            if slot.range in targets:
+                self.add_relationship(entity, slot, diagram)
+
     def add_class(self, class_name: ClassDefinitionName, diagram: ERDiagram) -> None:
         """
         Add a class to the ER Diagram.
@@ -291,9 +310,17 @@ class ERDiagramGenerator(Generator):
 )
 @click.option("--max-hops", default=None, type=click.INT, help="Maximum number of hops")
 @click.option("--classes", "-c", multiple=True, help="List of classes to serialize")
+@click.option("--include-upstream", is_flag=True, help="Include upstream classes")
 @click.version_option(__version__, "-V", "--version")
 @click.command()
-def cli(yamlfile, classes: List[str], max_hops: Optional[int], follow_references: bool, **args):
+def cli(
+    yamlfile,
+    classes: List[str],
+    max_hops: Optional[int],
+    follow_references: bool,
+    include_upstream: bool = False,
+    **args,
+):
     """Generate a mermaid ER diagram from a schema.
 
     By default, all entities traversable from the tree_root are included. If no tree_root is
@@ -306,7 +333,14 @@ def cli(yamlfile, classes: List[str], max_hops: Optional[int], follow_references
         **args,
     )
     if classes:
-        print(gen.serialize_classes(classes, follow_references=follow_references, max_hops=max_hops))
+        print(
+            gen.serialize_classes(
+                classes,
+                follow_references=follow_references,
+                max_hops=max_hops,
+                include_upstream=include_upstream,
+            )
+        )
     else:
         print(gen.serialize())
 

{linkml-1.7.10 → linkml-1.8.0}/linkml/generators/golanggen.py

@@ -5,12 +5,7 @@ from typing import List, Optional
 
 import click
 from jinja2 import Template
-from linkml_runtime.linkml_model.meta import (
-    ClassDefinition,
-    ClassDefinitionName,
-    Element,
-    SlotDefinition,
-)
+from linkml_runtime.linkml_model.meta import ClassDefinition, ClassDefinitionName, Element, SlotDefinition
 from linkml_runtime.utils.formatutils import camelcase, underscore
 
 from linkml._version import __version__

{linkml-1.7.10 → linkml-1.8.0}/linkml/generators/plantumlgen.py

@@ -12,11 +12,7 @@ from typing import Callable, List, Optional, Set, cast
 
 import click
 import requests
-from linkml_runtime.linkml_model.meta import (
-    ClassDefinition,
-    ClassDefinitionName,
-    SlotDefinition,
-)
+from linkml_runtime.linkml_model.meta import ClassDefinition, ClassDefinitionName, SlotDefinition
 from linkml_runtime.utils.formatutils import camelcase, underscore
 
 from linkml import REQUESTS_TIMEOUT

{linkml-1.7.10 → linkml-1.8.0}/linkml/generators/pydanticgen/array.py

@@ -1,18 +1,7 @@
 import sys
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import (
-    Any,
-    ClassVar,
-    Generic,
-    Iterable,
-    List,
-    Optional,
-    Type,
-    TypeVar,
-    Union,
-    get_args,
-)
+from typing import Any, ClassVar, Generic, Iterable, List, Optional, Type, TypeVar, Union, get_args
 
 from linkml_runtime.linkml_model import Element
 from linkml_runtime.linkml_model.meta import ArrayExpression, DimensionExpression

{linkml-1.7.10 → linkml-1.8.0}/linkml/generators/pydanticgen/black.py

@@ -16,9 +16,7 @@ except ImportError:
 
 
 def _default_mode() -> "Mode":
-    return Mode(
-        target_versions={TargetVersion.PY311},
-    )
+    return Mode(target_versions={TargetVersion.PY311}, line_length=120)
 
 
 def format_black(code: str, mode: Optional["Mode"] = None) -> str:

linkml-1.8.0/linkml/generators/pydanticgen/includes.py

@@ -0,0 +1,46 @@
+"""
+Classes to inject in generated pydantic models
+"""
+
+from pydantic.version import VERSION
+
+PYDANTIC_VERSION = int(VERSION[0])
+
+
+LinkMLMeta_v1 = """
+class LinkMLMeta(BaseModel):
+    __root__: Dict[str, Any] = {}
+    
+    def __getattr__(self, key:str):
+        return getattr(self.__root__, key)
+        
+    def __getitem__(self, key:str):
+        return self.__root__[key]
+    
+    def __setitem__(self, key:str, value):
+        self.__root__[key] = value
+   
+    class Config:
+        allow_mutation = False
+"""
+
+LinkMLMeta_v2 = """
+class LinkMLMeta(RootModel):
+    root: Dict[str, Any] = {}
+    model_config = ConfigDict(frozen=True)
+    
+    def __getattr__(self, key:str):
+        return getattr(self.root, key)
+        
+    def __getitem__(self, key:str):
+        return self.root[key]
+    
+    def __setitem__(self, key:str, value):
+        self.root[key] = value
+    
+"""
+
+# if PYDANTIC_VERSION >= 2:
+#     LinkMLMeta = eval(LinkMLMeta_v2)
+# else:
+#     LinkMLMeta = eval(LinkMLMeta_v1)

{linkml-1.7.10 → linkml-1.8.0}/linkml/generators/pydanticgen/pydanticgen.py

@@ -3,19 +3,12 @@ import logging
 import os
 import textwrap
 from collections import defaultdict
-from copy import deepcopy
+from copy import copy, deepcopy
 from dataclasses import dataclass, field
+from enum import Enum
 from pathlib import Path
 from types import ModuleType
-from typing import (
-    Dict,
-    List,
-    Literal,
-    Optional,
-    Set,
-    Type,
-    Union,
-)
+from typing import Dict, List, Literal, Optional, Set, Type, TypeVar, Union, overload
 
 import click
 from jinja2 import ChoiceLoader, Environment, FileSystemLoader
@@ -27,16 +20,14 @@ from linkml_runtime.linkml_model.meta import (
     TypeDefinition,
 )
 from linkml_runtime.utils.compile_python import compile_python
-from linkml_runtime.utils.formatutils import camelcase, underscore
+from linkml_runtime.utils.formatutils import camelcase, remove_empty_items, underscore
 from linkml_runtime.utils.schemaview import SchemaView
 from pydantic.version import VERSION as PYDANTIC_VERSION
 
 from linkml._version import __version__
-from linkml.generators.common.type_designators import (
-    get_accepted_type_designator_values,
-    get_type_designator_value,
-)
+from linkml.generators.common.type_designators import get_accepted_type_designator_values, get_type_designator_value
 from linkml.generators.oocodegen import OOCodeGenerator
+from linkml.generators.pydanticgen import includes
 from linkml.generators.pydanticgen.array import ArrayRangeGenerator, ArrayRepresentation
 from linkml.generators.pydanticgen.build import SlotResult
 from linkml.generators.pydanticgen.template import (
@@ -85,6 +76,7 @@ DEFAULT_IMPORTS = (
         module="typing",
         objects=[
             ObjectImport(name="Any"),
+            ObjectImport(name="ClassVar"),
             ObjectImport(name="List"),
             ObjectImport(name="Literal"),
             ObjectImport(name="Dict"),
@@ -100,6 +92,7 @@ DEFAULT_IMPORTS = (
             ObjectImport(name="BaseModel"),
             ObjectImport(name="ConfigDict"),
             ObjectImport(name="Field"),
+            ObjectImport(name="RootModel"),
             ObjectImport(name="field_validator"),
         ],
         alternative=Import(
@@ -109,6 +102,33 @@ DEFAULT_IMPORTS = (
     )
 )
 
+DEFAULT_INJECTS = {1: [includes.LinkMLMeta_v1], 2: [includes.LinkMLMeta_v2]}
+
+
+class MetadataMode(str, Enum):
+    FULL = "full"
+    """
+    all metadata from the source schema will be included, even if it is represented by the template classes, 
+    and even if it is represented by some child class (eg. "classes" will be included with schema metadata
+    """
+    EXCEPT_CHILDREN = "except_children"
+    """
+    all metadata from the source schema will be included, even if it is represented by the template classes,
+    except if it is represented by some child template class (eg. "classes" will be excluded from schema metadata)
+    """
+    AUTO = "auto"
+    """
+    Only the metadata that isn't represented by the template classes or excluded with ``meta_exclude`` will be included 
+    """
+    NONE = None
+    """
+    No metadata will be included.
+    """
+
+
+DefinitionType = TypeVar("DefinitionType", bound=Union[SchemaDefinition, ClassDefinition, SlotDefinition])
+TemplateType = TypeVar("TemplateType", bound=Union[PydanticModule, PydanticClass, PydanticAttribute])
+
 
 @dataclass
 class PydanticGenerator(OOCodeGenerator):
@@ -212,6 +232,12 @@ class PydanticGenerator(OOCodeGenerator):
             from typing_extensions import Literal
         
     """
+    metadata_mode: Union[MetadataMode, str, None] = MetadataMode.AUTO
+    """
+    How to include schema metadata in generated pydantic models.
+    
+    See :class:`.MetadataMode` for mode documentation
+    """
 
     # ObjectVars (identical to pythongen)
     gen_classvars: bool = True
@@ -530,6 +556,56 @@ class PydanticGenerator(OOCodeGenerator):
 
         return array_reps
 
+    @overload
+    def include_metadata(self, model: PydanticModule, source: SchemaDefinition) -> PydanticModule: ...
+
+    @overload
+    def include_metadata(self, model: PydanticClass, source: ClassDefinition) -> PydanticClass: ...
+
+    @overload
+    def include_metadata(self, model: PydanticAttribute, source: SlotDefinition) -> PydanticAttribute: ...
+
+    def include_metadata(self, model: TemplateType, source: DefinitionType) -> TemplateType:
+        """
+        Include metadata from the source schema that is otherwise not represented in the pydantic template models.
+
+        Metadata inclusion mode is dependent on :attr:`.metadata_mode` - see:
+
+        - :class:`.MetadataMode`
+        - :meth:`.TemplateModel.exclude_from_meta`
+
+        """
+        if self.metadata_mode is None or self.metadata_mode == MetadataMode.NONE:
+            return model
+        elif self.metadata_mode in (MetadataMode.AUTO, MetadataMode.AUTO.value):
+            meta = {k: v for k, v in remove_empty_items(source).items() if k not in model.exclude_from_meta()}
+        elif self.metadata_mode in (MetadataMode.EXCEPT_CHILDREN, MetadataMode.EXCEPT_CHILDREN.value):
+            meta = {}
+            for k, v in remove_empty_items(source).items():
+                if not hasattr(model, k):
+                    meta[k] = v
+                elif isinstance(getattr(model, k), list) and not any(
+                    [isinstance(item, TemplateModel) for item in getattr(model, k)]
+                ):
+                    meta[k] = v
+                elif isinstance(getattr(model, k), dict) and not any(
+                    [isinstance(item, TemplateModel) for item in getattr(model, k).values()]
+                ):
+                    meta[k] = v
+                elif not isinstance(getattr(model, k), TemplateModel):
+                    meta[k] = v
+
+        elif self.metadata_mode in (MetadataMode.FULL, MetadataMode.FULL.value):
+            meta = remove_empty_items(source)
+        else:
+            raise ValueError(
+                f"Unknown metadata mode '{self.metadata_mode}', needs to be one of "
+                f"{[mode.value for mode in MetadataMode]}"
+            )
+
+        model.meta = meta
+        return model
+
     def render(self) -> PydanticModule:
         sv: SchemaView
         sv = self.schemaview
@@ -540,7 +616,7 @@ class PydanticGenerator(OOCodeGenerator):
             description=schema.description.replace('"', '\\"') if schema.description else None,
         )
         enums = self.generate_enums(sv.all_enums())
-        injected_classes = []
+        injected_classes = copy(DEFAULT_INJECTS[self.pydantic_version])
         if self.injected_classes is not None:
             injected_classes += self.injected_classes
 
@@ -665,15 +741,22 @@ class PydanticGenerator(OOCodeGenerator):
                     predef_slot = str(predef_slot)
                 new_fields["predefined"] = predef_slot
                 new_fields["name"] = attr_name
+
                 attrs[attr_name] = PydanticAttribute(**new_fields, pydantic_ver=self.pydantic_version)
+                attrs[attr_name] = self.include_metadata(attrs[attr_name], src_attr)
 
             new_class = PydanticClass(
                 name=k, attributes=attrs, description=c.description, pydantic_ver=self.pydantic_version
             )
+            new_class = self.include_metadata(new_class, c)
             if k in bases:
                 new_class.bases = bases[k]
             classes[k] = new_class
 
+        schema_meta = {
+            k: v for k, v in remove_empty_items(schema).items() if k not in PydanticModule.exclude_from_meta()
+        }
+
         module = PydanticModule(
             pydantic_ver=self.pydantic_version,
             metamodel_version=self.schema.metamodel_version,
@@ -683,7 +766,9 @@ class PydanticGenerator(OOCodeGenerator):
             injected_classes=injected_classes,
             enums=enums,
             classes=classes,
+            meta=schema_meta,
         )
+        module = self.include_metadata(module, pyschema)
         return module
 
     def serialize(self) -> str:
@@ -739,6 +824,12 @@ Available templates to override:
     default="forbid",
     help="How to handle extra fields in BaseModel.",
 )
+@click.option(
+    "--black",
+    is_flag=True,
+    default=False,
+    help="Format generated models with black (must be present in the environment)",
+)
 @click.version_option(__version__, "-V", "--version")
 @click.command()
 def cli(
@@ -752,6 +843,7 @@ def cli(
     array_representations=list("list"),
     pydantic_version=int(PYDANTIC_VERSION[0]),
     extra_fields: Literal["allow", "forbid", "ignore"] = "forbid",
+    black: bool = False,
     **args,
 ):
     """Generate pydantic classes to represent a LinkML model"""
@@ -777,6 +869,7 @@ def cli(
         gen_classvars=classvars,
         gen_slots=slots,
         template_dir=template_dir,
+        black=black,
         **args,
     )
     print(gen.serialize())

{linkml-1.7.10 → linkml-1.8.0}/linkml/generators/pydanticgen/template.py

@@ -60,6 +60,7 @@ class TemplateModel(BaseModel):
     )
 
     pydantic_ver: int = int(PYDANTIC_VERSION[0])
+    meta_exclude: ClassVar[List[str]] = None
 
     def render(self, environment: Optional[Environment] = None, black: bool = False) -> str:
         """
@@ -132,6 +133,16 @@ class TemplateModel(BaseModel):
                 return self.json(**kwargs)
             return self.dict(**kwargs)
 
+    @classmethod
+    def exclude_from_meta(cls: "TemplateModel") -> List[str]:
+        """
+        Attributes in the source definition to exclude from linkml_meta
+        """
+        ret = [*cls.model_fields.keys()]
+        if cls.meta_exclude is not None:
+            ret = ret + cls.meta_exclude
+        return ret
+
 
 def _render(
     item: Union[TemplateModel, Any, List[Union[Any, TemplateModel]], Dict[str, Union[Any, TemplateModel]]],
@@ -213,6 +224,7 @@ class PydanticAttribute(TemplateModel):
     """
 
     template: ClassVar[str] = "attribute.py.jinja"
+    meta_exclude: ClassVar[List[str]] = ["from_schema", "owner", "range", "multivalued", "inlined", "inlined_as_list"]
 
     name: str
     required: bool = False
@@ -237,6 +249,10 @@ class PydanticAttribute(TemplateModel):
     minimum_value: Optional[Union[int, float]] = None
     maximum_value: Optional[Union[int, float]] = None
     pattern: Optional[str] = None
+    meta: Optional[Dict[str, Any]] = None
+    """
+    Metadata for the slot to be included in a Field annotation
+    """
 
     if int(PYDANTIC_VERSION[0]) >= 2:
 
@@ -283,11 +299,16 @@ class PydanticClass(TemplateModel):
     """
 
     template: ClassVar[str] = "class.py.jinja"
+    meta_exclude: ClassVar[List[str]] = ["slots", "is_a"]
 
     name: str
     bases: Union[List[str], str] = PydanticBaseModel.default_name
     description: Optional[str] = None
     attributes: Optional[Dict[str, PydanticAttribute]] = None
+    meta: Optional[Dict[str, Any]] = None
+    """
+    Metadata for the class to be included in a linkml_meta class attribute
+    """
 
     def _validators(self) -> Optional[Dict[str, PydanticValidator]]:
         if self.attributes is None:
@@ -548,6 +569,7 @@ class PydanticModule(TemplateModel):
     """
 
     template: ClassVar[str] = "module.py.jinja"
+    meta_exclude: ClassVar[str] = ["slots"]
 
     metamodel_version: Optional[str] = None
     version: Optional[str] = None
@@ -556,6 +578,10 @@ class PydanticModule(TemplateModel):
     imports: List[Union[Import, ConditionalImport]] = Field(default_factory=list)
     enums: Dict[str, PydanticEnum] = Field(default_factory=dict)
     classes: Dict[str, PydanticClass] = Field(default_factory=dict)
+    meta: Optional[Dict[str, Any]] = None
+    """
+    Metadata for the schema to be included in a linkml_meta module-level instance of LinkMLMeta
+    """
 
     if int(PYDANTIC_VERSION[0]) >= 2:
 

{linkml-1.7.10 → linkml-1.8.0}/linkml/generators/pydanticgen/templates/attribute.py.jinja

@@ -7,4 +7,10 @@
     {%- if minimum_value != None %}, ge={{minimum_value}}{% endif -%}
     {%- if maximum_value != None %}, le={{maximum_value}}{% endif -%}
 {%- endif -%}
-)
+{%- if meta != None -%}
+    {%- if pydantic_ver == 1 -%}
+    , linkml_meta = {{ meta | pprint | indent(width=8) }}
+    {% else -%}
+    , json_schema_extra = { "linkml_meta": {{ meta | pprint | indent(width=8) }} }
+    {%- endif -%}
+{%- endif -%})

{linkml-1.7.10 → linkml-1.8.0}/linkml/generators/pydanticgen/templates/class.py.jinja

@@ -4,6 +4,10 @@ class {{ name }}({% if bases is string %}{{ bases }}{% else %}{{ bases | join(',
     {{ description | indent(width=4) }}
     """
     {% endif -%}
+    {% if meta != None %}
+    linkml_meta: ClassVar[LinkMLMeta] = LinkMLMeta({% if pydantic_ver == 1 %}__root__={% endif %}{{ meta | pprint | indent(width=8) }})
+
+    {% endif %}
     {%  if attributes or validators %}
         {% if attributes %}
             {% for attr in attributes.values() %}

{linkml-1.7.10 → linkml-1.8.0}/linkml/generators/pydanticgen/templates/module.py.jinja

@@ -7,18 +7,25 @@ version = "{{version if version else None}}"
 
 
 {{ base_model }}
-{% if enums %}
-    {% for e in enums.values() %}
 
-{{ e }}
-    {% endfor %}
-{% endif %}
 {% if injected_classes %}
     {% for c in injected_classes%}
 
 {{ c }}
     {% endfor %}
 {% endif %}
+{% if meta != None %}
+linkml_meta = LinkMLMeta({% if pydantic_ver == 1 %}__root__={% endif %}{{ meta | pprint | indent(width=4) }} )
+{% else %}
+linkml_meta = None
+{% endif %}
+{% if enums %}
+    {% for e in enums.values() %}
+
+{{ e }}
+    {% endfor %}
+{% endif %}
+
 {% for c in classes.values() %}
 
 {{ c }}

{linkml-1.7.10 → linkml-1.8.0}/linkml/generators/pythongen.py

@@ -23,14 +23,7 @@ from linkml_runtime.linkml_model.meta import (
     TypeDefinition,
 )
 from linkml_runtime.utils.compile_python import compile_python
-from linkml_runtime.utils.formatutils import (
-    be,
-    camelcase,
-    sfx,
-    split_col,
-    underscore,
-    wrapped_annotation,
-)
+from linkml_runtime.utils.formatutils import be, camelcase, sfx, split_col, underscore, wrapped_annotation
 from linkml_runtime.utils.metamodelcore import builtinnames
 from rdflib import URIRef