linkml 1.8.6__tar.gz → 1.9.0rc1__tar.gz

{linkml-1.8.6 → linkml-1.9.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.8.6
+Version: 1.9.0rc1
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/docgen/class.md.jinja2

@@ -21,7 +21,7 @@
     {%- endif -%}
 {% endmacro %}
 
-# Class: {{ title }}
+# Class: {{ title }} {% if element.deprecated %} <span style="color: red;"><strong> (DEPRECATED) </strong> {% endif %}
 
 {%- if header -%}
 {{header}}

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/docgen/enum.md.jinja2

@@ -1,4 +1,4 @@
-# Enum: {{ gen.name(element) }}
+# Enum: {{ gen.name(element) }} {% if element.deprecated %} <span style="color: red;"><strong> (DEPRECATED) </strong> {% endif %}
 
 {% if element.description %}
 {% set element_description_lines = element.description.split('\n') %}

linkml-1.9.0rc1/linkml/generators/docgen/schema.md.jinja2

@@ -0,0 +1,7 @@
+# {{ schema.name }} {% if schema.deprecated %} <span style="color: red;"><strong> (DEPRECATED) </strong> {% endif %}
+
+{{ schema.description }}
+
+URI: {{ schema.id }}
+
+

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/docgen/slot.md.jinja2

@@ -21,7 +21,7 @@
     {%- endif -%}
 {% endmacro %}
 
-# Slot: {{ title }}
+# Slot: {{ title }} {% if element.deprecated %} <span style="color: red;"><strong> (DEPRECATED) </strong> {% endif %}
 
 {%- if header -%}
 {{header}}
@@ -40,6 +40,9 @@ _{{ element_description_line }}_
 
 URI: {{ gen.uri_link(element) }}
 
+{%- if element.alias %}
+Alias: {{ element.alias }}
+{% endif -%}
 
 {% if schemaview.slot_parents(element.name) or schemaview.slot_children(element.name, mixins=False) %}
 

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/docgen/subset.md.jinja2

@@ -1,4 +1,4 @@
-# Subset: {{ gen.name(element) }}
+# Subset: {{ gen.name(element) }} {% if element.deprecated %} <span style="color: red;"><strong> (DEPRECATED) </strong> {% endif %}
 
 {%- if header -%}
 {{ header }}

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/docgen/type.md.jinja2

@@ -1,4 +1,4 @@
-# Type: {{ gen.name(element) }}
+# Type: {{ gen.name(element) }} {% if element.deprecated %} <span style="color: red;"><strong> (DEPRECATED) </strong> {% endif %}
 
 {% if element.description %}
 {% set element_description_lines = element.description.split('\n') %}

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/jsonldgen.py

@@ -1,6 +1,4 @@
-""" Generate JSONld
-
-"""
+"""Generate JSONld from a LinkML schema."""
 
 import os
 from copy import deepcopy

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/jsonschemagen.py

@@ -237,6 +237,7 @@ class JsonSchemaGenerator(Generator, LifecycleMixin):
     valid_formats = ["json"]
     uses_schemaloader = False
     file_extension = "schema.json"
+    materialize_patterns: bool = False
 
     # @deprecated("Use top_class")
     topClass: Optional[str] = None
@@ -690,6 +691,10 @@ class JsonSchemaGenerator(Generator, LifecycleMixin):
         return self.top_level_schema
 
     def serialize(self, **kwargs) -> str:
+        if self.materialize_patterns:
+            logger.info("Materializing patterns in the schema before serialization")
+            self.schemaview.materialize_patterns()
+
         return self.generate().to_json(sort_keys=True, indent=self.indent if self.indent > 0 else None)
 
 
@@ -752,6 +757,12 @@ Include LinkML Schema outside of imports mechanism.  Helpful in including deprec
 YAML, and including it when necessary but not by default (e.g. in documentation or for backwards compatibility)
 """,
 )
+@click.option(
+    "--materialize-patterns/--no-materialize-patterns",
+    default=True,  # Default set to True
+    show_default=True,
+    help="If set, patterns will be materialized in the generated JSON Schema.",
+)
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, **kwargs):
     """Generate JSON Schema representation of a LinkML model"""

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/linkmlgen.py

@@ -114,8 +114,16 @@ def cli(
 ):
     # You can use the `--materialize` / `--no-materialize` for control
     # over both attribute and pattern materialization.
-    materialize_attributes = bool(materialize)
-    materialize_patterns = bool(materialize)
+
+    # If the user did not explicitly specify materialize_attributes,
+    # fall back to the umbrella materialize flag.
+    if materialize_attributes is None:
+        materialize_attributes = materialize
+
+    # If the user did not explicitly specify materialize_patterns,
+    # fall back to the umbrella materialize flag.
+    if materialize_patterns is None:
+        materialize_patterns = materialize
 
     gen = LinkmlGenerator(
         yamlfile,

linkml-1.9.0rc1/linkml/generators/mermaidclassdiagramgen.py

@@ -0,0 +1,133 @@
+import importlib
+import logging
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+import click
+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.utils.generator import Generator, shared_arguments
+
+
+@dataclass
+class MermaidClassDiagramGenerator(Generator):
+    """This generator creates Mermaid Class diagrams (https://mermaid.js.org/syntax/classDiagram.html)
+    for individual classes in a given LinkML schema and outputs them as Markdown files. It uses
+    a jinja template to render these class diagrams, which can be customized by the user and pointed
+    to using the `--template-file` option. If no template is provided, then the default template
+    file provided by LinkML and present at linkml/generators/docgen/class_diagram.md.jinja2 will be used.
+    The generator also has the option of specifying a certain set of classes for which you want the
+    class diagrams to be generated by using the `--classes` option.
+    """
+
+    generatorname = os.path.basename(__file__)
+    generatorversion = "0.0.1"
+    valid_formats = ["markdown"]
+    uses_schemaloader = False
+    requires_metamodel = False
+
+    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
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.logger = logging.getLogger(__name__)
+        self.schemaview = SchemaView(self.schema, merge_imports=self.mergeimports)
+
+        # set the output directory
+        self.output_directory = Path(self.directory)
+
+        # set the template file
+        if not self.template_file:
+            package_dir = os.path.dirname(importlib.util.find_spec("linkml").origin)
+            # Default location of the template file
+            self.template_file = os.path.join(package_dir, "generators", "docgen", "class_diagram.md.jinja2")
+
+    def generate_class_diagrams(self):
+        """Generate Mermaid class diagrams for the specified subset of classes
+        or all classes if none are specified.
+        """
+        self.output_directory.mkdir(parents=True, exist_ok=True)
+
+        template_folder = os.path.dirname(self.template_file)
+        template_name = os.path.basename(self.template_file)
+        loader = FileSystemLoader(template_folder)
+        env = Environment(loader=loader)
+        customize_environment(env)
+
+        template = env.get_template(template_name)
+
+        all_classes = self.schemaview.all_classes()
+
+        if self.classes:
+            class_items = [(cn, all_classes[cn]) for cn in self.classes if cn in all_classes]
+        else:
+            class_items = list(all_classes.items())
+
+        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"
+            with open(outfile, "w", encoding="utf-8") as f:
+                f.write(rendered)
+
+    def cardinality(self, slot: SlotDefinition) -> str:
+        """Reuses the cardinality logic from DocGenerator."""
+        return DocGenerator.cardinality(slot)
+
+    def mermaid_directive(self) -> str:
+        """Provides the code fence directive (e.g., `mermaid` or `{mermaid}`)."""
+        return "mermaid"
+
+    def name(self, element: Element) -> str:
+        """Returns the canonical name for an element."""
+        return element.name
+
+    def all_type_object_names(self):
+        return list(self.schemaview.all_types().keys())
+
+
+@shared_arguments(MermaidClassDiagramGenerator)
+@click.command()
+@click.option(
+    "--template-file",
+    "-t",
+    type=click.Path(exists=True),
+    default=None,
+    help="Path to Jinja template for class diagrams.",
+)
+@click.option(
+    "--directory",
+    "-d",
+    type=click.Path(),
+    required=True,
+    help="Folder in which to write the Markdown files.",
+)
+@click.option(
+    "--classes",
+    "-c",
+    multiple=True,
+    help="One or more classes in the schema for which to generate diagrams. "
+    "If omitted, diagrams for all classes are generated.",
+)
+@click.version_option(click.__version__, "-V", "--version")
+def cli(yamlfile, template_file, directory, classes, **args):
+    logging.basicConfig(level=logging.INFO)
+    gen = MermaidClassDiagramGenerator(
+        schema=yamlfile,
+        template_file=template_file,
+        directory=directory,
+        classes=list(classes),  # convert tuple to a list
+        **args,
+    )
+    gen.generate_class_diagrams()
+
+
+if __name__ == "__main__":
+    cli()

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/owlgen.py

@@ -708,18 +708,10 @@ class OwlSchemaGenerator(Generator):
                 owl_exprs.append(eq_uri)
         if element.equals_string_in:
             equals_string_in = element.equals_string_in
-            if is_literal is None:
-                logger.warning(f"ignoring equals_string={equals_string_in} as unable to tell if literal")
-            elif is_literal:
-                dt_exprs = [
-                    self._datatype_restriction(XSD.string, [self._facet(XSD.pattern, s)]) for s in equals_string_in
-                ]
-                union_expr = self._union_of(dt_exprs, owl_types={RDFS.Literal})
-                owl_exprs.append(union_expr)
-                owl_types.add(RDFS.Literal)
-            else:
-                eq_uris = [URIRef(self.schemaview.expand_curie(s)) for s in equals_string_in]
-                owl_exprs.append(self._union_of(eq_uris))
+            literals = [Literal(s) for s in equals_string_in]
+            one_of_expr = self._boolean_expression(literals, OWL.oneOf, owl_types={RDFS.Literal})
+            owl_exprs.append(one_of_expr)
+            owl_types.add(RDFS.Literal)
         for constraint_prop, constraint_val in constraints.items():
             if is_literal is not None and not is_literal:
                 # In LinkML, it is permissible to have a literal constraints on slots that refer to
@@ -1140,7 +1132,7 @@ class OwlSchemaGenerator(Generator):
 
     def _boolean_expression(
         self,
-        exprs: List[Union[BNode, URIRef]],
+        exprs: List[Union[BNode, URIRef, Literal]],
         predicate: URIRef,
         node: Optional[URIRef] = None,
         owl_types: Set[OWL_TYPE] = None,

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/shacl/shacl_ifabsent_processor.py

@@ -62,7 +62,8 @@ class ShaclIfAbsentProcessor(IfAbsentProcessor):
         return Literal(f"{year}-{month}-{day}T{hour}:{minutes}:{seconds}", datatype=ShaclDataType.DATETIME.uri_ref)
 
     def map_uri_or_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
-        raise NotImplementedError()
+        uri = URIRef(self.schema_view.expand_curie(default_value))
+        return Literal(uri, datatype=ShaclDataType.URI.uri_ref)
 
     def map_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
         return Literal(default_value, datatype=ShaclDataType.CURIE.uri_ref)

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/shaclgen.py

@@ -30,6 +30,8 @@ class ShaclGenerator(Generator):
     """parameterized suffix to be appended. No suffix per default."""
     include_annotations: bool = False
     """True means include all class / slot / type annotations in generated Node or Property shapes"""
+    exclude_imports: bool = False
+    """If True, elements from imported ontologies won't be included in the generator's output"""
     generatorname = os.path.basename(__file__)
     generatorversion = "0.0.1"
     valid_formats = ["ttl"]
@@ -63,7 +65,7 @@ class ShaclGenerator(Generator):
         for pfx in self.schema.prefixes.values():
             g.bind(str(pfx.prefix_prefix), pfx.prefix_reference)
 
-        for c in sv.all_classes().values():
+        for c in sv.all_classes(imports=not self.exclude_imports).values():
 
             def shape_pv(p, v):
                 if v is not None:
@@ -364,6 +366,13 @@ def add_simple_data_type(func: Callable, r: ElementName) -> None:
     show_default=True,
     help="Use --include-annotations to include annotations of slots, types, and classes in the generated SHACL shapes.",
 )
+@click.option(
+    "--exclude-imports/--include-imports",
+    default=False,
+    show_default=True,
+    help="Use --exclude-imports to exclude imported elements from the generated SHACL shapes. This is useful when "
+    "extending a substantial ontology to avoid large output files.",
+)
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, **args):
     """Generate SHACL turtle from a LinkML model"""

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/shexgen.py

@@ -1,6 +1,4 @@
-"""Generate ShEx definition of a model
-
-"""
+"""Generate ShEx definition of a model"""
 
 import os
 import urllib.parse as urlparse

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/summarygen.py

@@ -1,6 +1,4 @@
-"""Generate Summary Spreadsheets
-
-"""
+"""Generate Summary Spreadsheets"""
 
 import os
 from csv import DictWriter

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/generators/yamlgen.py

@@ -1,6 +1,4 @@
-"""Validate linkml input and optionally emit completely resolved biolink yaml output
-
-"""
+"""Validate linkml input and optionally emit completely resolved biolink yaml output"""
 
 import os
 from dataclasses import dataclass

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/transformers/logical_model_transformer.py

@@ -409,11 +409,13 @@ class LogicalModelTransformer(ModelTransformer):
         target_class_name: ClassDefinitionName,
         ancestors: List[ClassDefinitionName],
     ):
-        anc_classes = [self.schemaview.get_class(anc) for anc in ancestors]
+        anc_classes = [self.schemaview.get_class(ancestor) for ancestor in ancestors]
         attributes: Dict[SlotDefinitionName, SlotDefinition] = {}
-        for anc in anc_classes:
-            top_level_slots = [(s, target_schema.slots[s]) for s in anc.slots]
-            for slot_name, slot_expr in list(anc.attributes.items()) + list(anc.slot_usage.items()) + top_level_slots:
+        for ancestor_class in anc_classes:
+            top_level_slots = [(s, target_schema.slots[s]) for s in ancestor_class.slots]
+            for slot_name, slot_expr in (
+                list(ancestor_class.attributes.items()) + list(ancestor_class.slot_usage.items()) + top_level_slots
+            ):
                 if slot_name not in attributes:
                     attributes[slot_name] = SlotDefinition(slot_name)
                 sx = attributes[slot_name]
@@ -644,7 +646,7 @@ class LogicalModelTransformer(ModelTransformer):
         if slot_expression.all_of:
             exprs.append(logictools.And(*[self._as_logical_expression(subx) for subx in slot_expression.all_of]))
         if slot_expression.exactly_one_of:
-            # TODO: disjointness
+            # TODO: disjointedness
             exprs.append(logictools.Or(*[self._as_logical_expression(subx) for subx in slot_expression.exactly_one_of]))
         if slot_expression.none_of:
             exprs.append(

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/utils/generator.py

@@ -27,6 +27,7 @@ from typing import Callable, ClassVar, Dict, List, Mapping, Optional, Set, TextI
 
 import click
 from click import Argument, Command, Option
+from jsonasobj2 import JsonObj
 from linkml_runtime import SchemaView
 from linkml_runtime.linkml_model.meta import (
     ClassDefinition,
@@ -265,8 +266,16 @@ class Generator(metaclass=abc.ABCMeta):
     def _init_namespaces(self):
         if self.namespaces is None:
             self.namespaces = Namespaces()
-            for prefix in self.schema.prefixes.values():
-                self.namespaces[prefix.prefix_prefix] = prefix.prefix_reference
+            if isinstance(self.schema.prefixes, dict):
+                for key, value in self.schema.prefixes.items():
+                    self.namespaces[key] = value
+            elif isinstance(self.schema.prefixes, JsonObj):
+                prefixes = vars(self.schema.prefixes)
+                for key, value in prefixes.items():
+                    self.namespaces[key] = value
+            else:
+                for prefix in self.schema.prefixes.values():
+                    self.namespaces[prefix.prefix_prefix] = prefix.prefix_reference
 
     def serialize(self, **kwargs) -> str:
         """

{linkml-1.8.6 → linkml-1.9.0rc1}/linkml/workspaces/example_runner.py

@@ -1,6 +1,4 @@
-"""Iterate through all examples in a folder testing them for validity.
-
-"""
+"""Iterate through all examples in a folder testing them for validity."""
 
 import glob
 import json

{linkml-1.8.6 → linkml-1.9.0rc1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "linkml"
-version = "1.8.6"
+version = "1.9.0rc1"
 description = "Linked Open Data Modeling Language"
 authors = [
     "Chris Mungall <cjmungall@lbl.gov>",
@@ -93,6 +93,7 @@ linkml-run-examples = "linkml.workspaces.example_runner:cli"
 gen-excel = "linkml.generators.excelgen:cli"
 gen-sssom = "linkml.generators.sssomgen:cli"
 gen-linkml = "linkml.generators.linkmlgen:cli"
+gen-mermaid-class-diagram = "linkml.generators.mermaidclassdiagramgen:cli"
 linkml-schema-fixer = "linkml.utils.schema_fixer:main"
 
 [tool.poetry.dependencies]
@@ -177,11 +178,11 @@ build-backend = "poetry_dynamic_versioning.backend"
 
 [tool.codespell]
 # TODO: bring in tests in too
-skip = '.git,*.pdf,*.svg,./tests,pyproject.toml,*.dill,poetry.lock'
+skip = '.git,*.pdf,*.svg,./tests,pyproject.toml,*.dill,poetry.lock,./notebooks/DistributedModels.ipynb'
 # Ignore table where words could be split across rows
 # Ignore shortcut specifications like [Ff]alse
 ignore-regex = '(\|.*\|.*\|.*\||\[[A-Z][a-z]\][a-z][a-z])'
-ignore-words-list = 'mater,connexion,infarction,thirdparty,linke'
+ignore-words-list = 'anc,mater,connexion,infarction,thirdparty,linke'
 quiet-level = 3
 
 [tool.black]
@@ -210,6 +211,7 @@ markers = [
   "slow: mark test as slow to run",
   "no_asserts: tests that don't have meaningful asserts, but are only snapshot comparisons, or historically had print statements, or other non-erroring behavior",
   "strcmp: tests that compare stringified values rather than the values themselves",
+  "biolink: tests that validate that the biolink model is unchanged",
   "docker: tests that require a running docker server",
   "plantumlgen: Tests for the plantuml generator",
   "pydanticgen_split: Split module generation in pydanticgen",

{linkml-1.8.6 → linkml-1.9.0rc1}/setup.py

@@ -81,6 +81,8 @@ entry_points = \
                      'linkml.generators.jsonldcontextgen:cli',
                      'gen-linkml = linkml.generators.linkmlgen:cli',
                      'gen-markdown = linkml.generators.markdowngen:cli',
+                     'gen-mermaid-class-diagram = '
+                     'linkml.generators.mermaidclassdiagramgen:cli',
                      'gen-namespaces = linkml.generators.namespacegen:cli',
                      'gen-owl = linkml.generators.owlgen:cli',
                      'gen-plantuml = linkml.generators.plantumlgen:cli',
@@ -119,7 +121,7 @@ entry_points = \
 
 setup_kwargs = {
     'name': 'linkml',
-    'version': '1.8.6',
+    'version': '1.9.0rc1',
     'description': 'Linked Open Data Modeling Language',
     'long_description': '[![Pyversions](https://img.shields.io/pypi/pyversions/linkml.svg)](https://pypi.python.org/pypi/linkml)\n![](https://github.com/linkml/linkml/workflows/Build/badge.svg)\n[![PyPi](https://img.shields.io/pypi/v/linkml.svg)](https://pypi.python.org/pypi/linkml)\n[![badge](https://img.shields.io/badge/launch-binder-579ACA.svg)](https://mybinder.org/v2/gh/linkml/linkml/main?filepath=notebooks)\n[![DOI](https://zenodo.org/badge/13996/linkml/linkml.svg)](https://zenodo.org/badge/latestdoi/13996/linkml/linkml)\n[![PyPIDownloadsTotal](https://pepy.tech/badge/linkml)](https://pepy.tech/project/linkml)\n[![PyPIDownloadsMonth](https://img.shields.io/pypi/dm/linkml?logo=PyPI&color=blue)](https://pypi.org/project/linkml)\n[![codecov](https://codecov.io/gh/linkml/linkml/branch/main/graph/badge.svg?token=WNQNG986UN)](https://codecov.io/gh/linkml/linkml)\n\n\n# LinkML - Linked Data Modeling Language\n\nLinkML is a linked data modeling language following object-oriented and ontological principles. LinkML models are typically authored in YAML, and can be converted to other schema representation formats such as JSON or RDF.\n\nThis repo holds the tools for generating and working with LinkML. For the LinkML schema (metamodel), please see https://github.com/linkml/linkml-model\n\nThe complete documentation for LinkML can be found here:\n\n - [linkml.io/linkml](https://linkml.io/linkml)\n',
     'author': 'Chris Mungall',

linkml-1.8.6/linkml/generators/docgen/schema.md.jinja2

@@ -1,7 +0,0 @@
-# {{ schema.name }}
-
-{{ schema.description }}
-
-URI: {{ schema.id }}
-
-