linkml 1.7.7__tar.gz → 1.7.8__tar.gz

{linkml-1.7.7 → linkml-1.7.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.7.7
+Version: 1.7.8
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink
@@ -51,6 +51,7 @@ Requires-Dist: pyyaml
 Requires-Dist: rdflib (>=6.0.0)
 Requires-Dist: requests (>=2.22)
 Requires-Dist: sqlalchemy (>=1.4.31)
+Requires-Dist: typing-extensions (>=4.4.0) ; python_version < "3.9"
 Requires-Dist: watchdog (>=0.9.0)
 Project-URL: Documentation, https://linkml.io/linkml/
 Project-URL: Repository, https://github.com/linkml/linkml

{linkml-1.7.7 → linkml-1.7.8}/linkml/__init__.py

@@ -19,6 +19,13 @@ LOCAL_TYPES_YAML_FILE = linkml_files.LOCAL_PATH_FOR(Source.TYPES, Format.YAML)
 LOCAL_MAPPINGS_YAML_FILE = linkml_files.LOCAL_PATH_FOR(Source.MAPPINGS, Format.YAML)
 LOCAL_ANNOTATIONS_YAML_FILE = linkml_files.LOCAL_PATH_FOR(Source.ANNOTATIONS, Format.YAML)
 LOCAL_EXTENSIONS_YAML_FILE = linkml_files.LOCAL_PATH_FOR(Source.EXTENSIONS, Format.YAML)
+LOCAL_MODEL_YAML_FILES = (
+    LOCAL_METAMODEL_YAML_FILE,
+    LOCAL_TYPES_YAML_FILE,
+    LOCAL_MAPPINGS_YAML_FILE,
+    LOCAL_ANNOTATIONS_YAML_FILE,
+    LOCAL_EXTENSIONS_YAML_FILE,
+)
 
 # Local location of jsonld and context.jsonld files
 LOCAL_METAMODEL_LDCONTEXT_FILE = linkml_files.LOCAL_PATH_FOR(Source.META, Format.JSONLD)
@@ -55,6 +62,13 @@ METATYPE_NAMESPACE = METAMODEL_NAMESPACE
 METAMAPPING_NAMESPACE = METAMODEL_NAMESPACE
 METAANNOTATIONS_NAMESPACE = METAMODEL_NAMESPACE
 METAEXTENSIONS_NAMESPACE = METAMODEL_NAMESPACE
+NAMESPACES = (
+    METAMODEL_NAMESPACE,
+    METATYPE_NAMESPACE,
+    METAMAPPING_NAMESPACE,
+    METAANNOTATIONS_NAMESPACE,
+    METAEXTENSIONS_NAMESPACE,
+)
 
 # Metamodel Context URI
 METAMODEL_CONTEXT_URI = linkml_files.URL_FOR(Source.META, Format.JSONLD)

{linkml-1.7.7 → linkml-1.7.8}/linkml/generators/docgen/subset.md.jinja2

@@ -43,20 +43,18 @@ URI: {{ gen.link(element) }}
 
 | Class | Description |
 | --- | --- |
-{% for c in gen.all_class_objects()|sort(attribute=sort_by) -%}
+{% for c in classes_in_subset -%}
 {%- if element.name in c.in_subset -%}
 | {{gen.link(c)}} | {{c.description|enshorten}} |
 {% endif -%}
 {% endfor %}
 
-{% for c in gen.all_class_objects()|sort(attribute=sort_by) -%}
+{% for c in classes_in_subset -%}
 {%- if element.name in c.in_subset -%}
-### {{ gen.name(c) }}
 
-{{c.description}}
+{% set induced_slots = gen.class_induced_slots(c.name)|sort(attribute=sort_by) %}
 
 {%- set filtered_slots = [] -%}
-
 {%- for s in induced_slots|sort(attribute=sort_by) -%}
     {%- if element.name in s.in_subset or element.name in schemaview.get_slot(s.name).in_subset -%}
         {% set _ = filtered_slots.append(s) %}
@@ -64,10 +62,12 @@ URI: {{ gen.link(element) }}
 {%- endfor %}
 
 {%- if filtered_slots|length > 0 -%}
-| Name | Cardinality and Range  | Description  |
+### Slots from {{ gen.link(c) }} also in _{{ element.name }}_
+
+| Name | Cardinality and Range | Description |
 | ---  | ---  | --- |
 {% for s in filtered_slots -%}
-| {{gen.link(s)}} | {{ gen.cardinality(s) }} <br/> {{gen.link(s.range)}}  | {{s.description|enshorten}} {% if s.identifier %}**identifier**{% endif %}  |
+| {{gen.link(s)}} | {{ gen.cardinality(s) }} <br/> {{gen.link(s.range)}} | {{s.description|enshorten}} {% if s.identifier %}**identifier**{% endif %} |
 {% endfor %}
 {%- endif %}
 

{linkml-1.7.7 → linkml-1.7.8}/linkml/generators/pydanticgen/array.py

@@ -30,7 +30,7 @@ else:
     from typing import Annotated
 
 from linkml.generators.pydanticgen.build import SlotResult
-from linkml.generators.pydanticgen.template import Import, Imports, ObjectImport
+from linkml.generators.pydanticgen.template import ConditionalImport, Import, Imports, ObjectImport
 
 
 class ArrayRepresentation(Enum):
@@ -54,7 +54,14 @@ if int(PYDANTIC_VERSION[0]) >= 2:
             item_schema = handler.generate_schema(item_type)
             if item_schema.get("type", "any") != "any":
                 item_schema["strict"] = True
-            array_ref = f"any-shape-array-{item_type.__name__}"
+
+            if item_type is Any:
+                # Before python 3.11, `Any` type was a special object without a __name__
+                item_name = "Any"
+            else:
+                item_name = item_type.__name__
+
+            array_ref = f"any-shape-array-{item_name}"
 
             schema = core_schema.definitions_schema(
                 core_schema.list_schema(core_schema.definition_reference_schema(array_ref)),
@@ -78,7 +85,6 @@ if int(PYDANTIC_VERSION[0]) >= 2:
         + Import(
             module="typing",
             objects=[
-                ObjectImport(name="Annotated"),
                 ObjectImport(name="Generic"),
                 ObjectImport(name="Iterable"),
                 ObjectImport(name="TypeVar"),
@@ -86,6 +92,12 @@ if int(PYDANTIC_VERSION[0]) >= 2:
                 ObjectImport(name="get_args"),
             ],
         )
+        + ConditionalImport(
+            condition="sys.version_info.minor > 8",
+            module="typing",
+            objects=[ObjectImport(name="Annotated")],
+            alternative=Import(module="typing_extensions", objects=[ObjectImport(name="Annotated")]),
+        )
         + Import(module="pydantic", objects=[ObjectImport(name="GetCoreSchemaHandler")])
         + Import(module="pydantic_core", objects=[ObjectImport(name="CoreSchema"), ObjectImport(name="core_schema")])
     )

{linkml-1.7.7 → linkml-1.7.8}/linkml/generators/pydanticgen/pydanticgen.py

@@ -76,6 +76,7 @@ DEFAULT_IMPORTS = (
     + Import(module="decimal", objects=[ObjectImport(name="Decimal")])
     + Import(module="enum", objects=[ObjectImport(name="Enum")])
     + Import(module="re")
+    + Import(module="sys")
     + Import(
         module="typing",
         objects=[
@@ -644,10 +645,11 @@ class PydanticGenerator(OOCodeGenerator):
         for k, c in pyschema.classes.items():
             attrs = {}
             for attr_name, src_attr in c.attributes.items():
+                src_attr = src_attr._as_dict
                 new_fields = {
-                    k: src_attr._as_dict.get(k, None)
+                    k: src_attr.get(k, None)
                     for k in PydanticAttribute.model_fields.keys()
-                    if src_attr._as_dict.get(k, None) is not None
+                    if src_attr.get(k, None) is not None
                 }
                 predef_slot = predefined.get(k, {}).get(attr_name, None)
                 if predef_slot is not None:

{linkml-1.7.7 → linkml-1.7.8}/linkml/generators/pydanticgen/template.py

@@ -1,3 +1,4 @@
+from copy import copy
 from importlib.util import find_spec
 from typing import Any, ClassVar, Dict, Generator, List, Literal, Optional, Union, overload
 
@@ -54,6 +55,10 @@ class TemplateModel(BaseModel):
     """
 
     template: ClassVar[str]
+    _environment: ClassVar[Environment] = Environment(
+        loader=PackageLoader("linkml.generators.pydanticgen", "templates"), trim_blocks=True, lstrip_blocks=True
+    )
+
     pydantic_ver: int = int(PYDANTIC_VERSION[0])
 
     def render(self, environment: Optional[Environment] = None, black: bool = False) -> str:
@@ -95,14 +100,11 @@ class TemplateModel(BaseModel):
     def environment(cls) -> Environment:
         """
         Default environment for Template models.
-
         uses a :class:`jinja2.PackageLoader` for the templates directory within this module
         with the ``trim_blocks`` and ``lstrip_blocks`` parameters set to ``True`` so that the
         default templates could be written in a more readable way.
         """
-        return Environment(
-            loader=PackageLoader("linkml.generators.pydanticgen", "templates"), trim_blocks=True, lstrip_blocks=True
-        )
+        return copy(cls._environment)
 
     if int(PYDANTIC_VERSION[0]) < 2:
         # simulate pydantic 2's model_fields behavior

{linkml-1.7.7 → linkml-1.7.8}/linkml/generators/pythongen.py

@@ -4,6 +4,7 @@ import os
 import re
 from copy import copy
 from dataclasses import dataclass
+from pathlib import Path
 from types import ModuleType
 from typing import Callable, Dict, Iterator, List, Optional, Set, Tuple, Union
 
@@ -62,6 +63,8 @@ class PythonGenerator(Generator):
     emit_metadata: bool = True
 
     def __post_init__(self) -> None:
+        if isinstance(self.schema, Path):
+            self.schema = str(self.schema)
         self.sourcefile = self.schema
         self.schemaview = SchemaView(self.schema, base_dir=self.base_dir)
         super().__post_init__()

{linkml-1.7.7 → linkml-1.7.8}/linkml/generators/rdfgen.py

@@ -7,10 +7,12 @@ Generate a JSON LD representation of the model
 
 import os
 import urllib.parse as urlparse
+from copy import deepcopy
 from dataclasses import dataclass
 from typing import List, Optional
 
 import click
+from linkml_runtime.linkml_model import SchemaDefinition
 from rdflib import Graph
 from rdflib.plugin import Parser as rdflib_Parser
 from rdflib.plugin import plugins as rdflib_plugins
@@ -35,13 +37,19 @@ class RDFGenerator(Generator):
     # ObjectVars
     emit_metadata: bool = False
     context: List[str] = None
+    original_schema: SchemaDefinition = None
+    """See https://github.com/linkml/linkml/issues/871"""
+
+    def __post_init__(self):
+        self.original_schema = deepcopy(self.schema)
+        super().__post_init__()
 
     def _data(self, g: Graph) -> str:
         return g.serialize(format="turtle" if self.format == "ttl" else self.format)
 
     def end_schema(self, output: Optional[str] = None, context: str = None, **_) -> None:
         gen = JSONLDGenerator(
-            self,
+            self.original_schema,
             format=JSONLDGenerator.valid_formats[0],
             metadata=self.emit_metadata,
             importmap=self.importmap,

{linkml-1.7.7 → linkml-1.7.8}/linkml/generators/shaclgen.py

@@ -22,7 +22,8 @@ class ShaclGenerator(Generator):
     # ClassVars
     closed: bool = True
     """True means add 'sh:closed=true' to all shapes, except of mixin shapes and shapes, that have parents"""
-
+    suffix: str = None
+    """parameterized suffix to be appended. No suffix per default."""
     generatorname = os.path.basename(__file__)
     generatorversion = "0.0.1"
     valid_formats = ["ttl"]
@@ -59,9 +60,12 @@ class ShaclGenerator(Generator):
 
             def shape_pv(p, v):
                 if v is not None:
-                    g.add((class_uri, p, v))
+                    g.add((class_uri_with_suffix, p, v))
 
             class_uri = URIRef(sv.get_uri(c, expand=True))
+            class_uri_with_suffix = class_uri
+            if self.suffix is not None:
+                class_uri_with_suffix += self.suffix
             shape_pv(RDF.type, SH.NodeShape)
             shape_pv(SH.targetClass, class_uri)  # TODO
             if self.closed:
@@ -211,14 +215,21 @@ def add_simple_data_type(func: Callable, r: ElementName) -> None:
 
 
 @shared_arguments(ShaclGenerator)
+@click.command()
 @click.option(
     "--closed/--non-closed",
     default=True,
     show_default=True,
     help="Use '--closed' to generate closed SHACL shapes. Use '--non-closed' to generate open SHACL shapes.",
 )
+@click.option(
+    "-s",
+    "--suffix",
+    default=None,
+    show_default=True,
+    help="Use --suffix to append given string to SHACL class name (e. g. --suffix Shape: Person becomes PersonShape).",
+)
 @click.version_option(__version__, "-V", "--version")
-@click.command()
 def cli(yamlfile, **args):
     """Generate SHACL turtle from a LinkML model"""
     gen = ShaclGenerator(yamlfile, **args)

{linkml-1.7.7 → linkml-1.7.8}/linkml/generators/sqlalchemygen.py

@@ -121,6 +121,7 @@ class SQLAlchemyGenerator(Generator):
             is_join_table=lambda c: any(tag for tag in c.annotations.keys() if tag == "linkml:derived_from"),
             classes=rel_schema_classes_ordered,
         )
+        logging.debug(f"# Generated code:\n{code}")
         return code
 
     def serialize(self, **kwargs) -> str:

{linkml-1.7.7 → linkml-1.7.8}/linkml/generators/sqltablegen.py

@@ -211,7 +211,22 @@ class SQLTableGenerator(Generator):
                         col.comment = s.description
                     cols.append(col)
                 for uc_name, uc in c.unique_keys.items():
-                    sql_uc = UniqueConstraint(*[sql_name(sn) for sn in uc.unique_key_slots])
+
+                    def _sql_name(sn: str):
+                        if sn in c.attributes:
+                            return sql_name(sn)
+                        else:
+                            # for candidate in c.attributes.values():
+                            #    if "original_slot" in candidate.annotations:
+                            #        original = candidate.annotations["original_slot"]
+                            #        if original.value == sn:
+                            #            return sql_name(candidate.name)
+                            return None
+
+                    sql_names = [_sql_name(sn) for sn in uc.unique_key_slots]
+                    if any(sn is None for sn in sql_names):
+                        continue
+                    sql_uc = UniqueConstraint(*sql_names)
                     cols.append(sql_uc)
                 Table(sql_name(cn), schema_metadata, *cols, comment=str(c.description))
         schema_metadata.create_all(engine)

{linkml-1.7.7 → linkml-1.7.8}/linkml/transformers/relmodel_transformer.py

@@ -226,6 +226,7 @@ class RelationalModelTransformer:
 
         # TODO: separate out the logic into separate testable methods
         target_sv.set_modified()
+        multivalued_slots_original = []
         # post-process target schema
         for cn, c in target_sv.all_classes().items():
             if self.foreign_key_policy == ForeignKeyPolicy.NO_FOREIGN_KEYS:
@@ -243,6 +244,7 @@ class RelationalModelTransformer:
                     slot.inlined or slot.inlined_as_list or "shared" in slot.annotations
                 )
                 if slot.multivalued:
+                    multivalued_slots_original.append(slot.name)
                     slot.multivalued = False
                     slot_name = slot.name
                     sn_singular = slot.singular_name if slot.singular_name else slot.name
@@ -332,6 +334,7 @@ class RelationalModelTransformer:
         # add PK and FK anns
         target_sv.set_modified()
         fk_policy = self.foreign_key_policy
+        forward_map = {}
         for c in target.classes.values():
             if self.foreign_key_policy == ForeignKeyPolicy.NO_FOREIGN_KEYS:
                 continue
@@ -356,14 +359,31 @@ class RelationalModelTransformer:
                         # if it is already an injected backref, no need to re-inject
                         if "backref" not in a.annotations:
                             del c.attributes[a.name]
+                            original_name = a.name
                             if "forwardref" not in a.annotations:
-                                add_annotation(a, "original_slot", a.name)
+                                add_annotation(a, "original_slot", original_name)
                             a.alias = f"{a.name}_{tc_pk_slot.name}"
                             a.name = a.alias
                             c.attributes[a.name] = a
+                            forward_map[original_name] = a.name
                     ann = Annotation("foreign_key", f"{tc.name}.{tc_pk_slot.name}")
                     a.annotations[ann.tag] = ann
                     target_sv.set_modified()
+            # Rewrite unique key constraints
+            # - if a slot has a range of object, it may be renamed, e.g. person => person_id
+            # - if a slot is multivalued then it is translated to backref and the UC must be dropped
+            removed_ucs = []
+            for uc_name, uc in c.unique_keys.items():
+                if any(sn in multivalued_slots_original for sn in uc.unique_key_slots):
+                    logging.warning(
+                        f"Cannot represent uniqueness constraint {uc_name}. "
+                        f"one of the slots {uc.unique_key_slots} is multivalued"
+                    )
+                    removed_ucs.append(uc_name)
+                new_slot_names = [forward_map.get(sn, sn) for sn in uc.unique_key_slots]
+                uc.unique_key_slots = new_slot_names
+            for uc_name in removed_ucs:
+                del c.unique_keys[uc_name]
 
         result = TransformationResult(target, mappings=mappings)
         return result

{linkml-1.7.7 → linkml-1.7.8}/linkml/utils/generator.py

@@ -30,7 +30,6 @@ from typing import Callable, ClassVar, Dict, List, Mapping, Optional, Set, TextI
 import click
 from click import Argument, Command, Option
 from linkml_runtime import SchemaView
-from linkml_runtime.dumpers import yaml_dumper
 from linkml_runtime.linkml_model.meta import (
     ClassDefinition,
     ClassDefinitionName,
@@ -83,7 +82,7 @@ class Generator(metaclass=abc.ABCMeta):
     For usage `Generator Docs <https://linkml.io/linkml/generators/>`_
     """
 
-    schema: Union[str, TextIO, SchemaDefinition, "Generator"]
+    schema: Union[str, TextIO, SchemaDefinition, "Generator", Path]
     """metamodel compliant schema.  Can be URI, file name, actual schema, another generator, an
         open file or a pre-parsed schema"""
 
@@ -130,7 +129,7 @@ class Generator(metaclass=abc.ABCMeta):
     useuris: Optional[bool] = None
     """True means declared class slot uri's are used.  False means use model uris"""
 
-    log_level: int = DEFAULT_LOG_LEVEL_INT
+    log_level: Optional[int] = DEFAULT_LOG_LEVEL_INT
     """Logging level, 0 is minimum"""
 
     mergeimports: Optional[bool] = True
@@ -180,6 +179,8 @@ class Generator(metaclass=abc.ABCMeta):
     def __post_init__(self) -> None:
         if not self.logger:
             self.logger = logging.getLogger()
+        if self.log_level is not None:
+            self.logger.setLevel(self.log_level)
         if self.format is None:
             self.format = self.valid_formats[0]
         if self.format not in self.valid_formats:
@@ -191,7 +192,11 @@ class Generator(metaclass=abc.ABCMeta):
             self.source_file_size = None
         if self.requires_metamodel:
             self.metamodel = _resolved_metamodel(self.mergeimports)
+
         schema = self.schema
+        if isinstance(schema, Path):
+            schema = str(schema)
+
         # TODO: remove aliasing
         self.emit_metadata = self.metadata
         if self.uses_schemaloader:
@@ -225,8 +230,7 @@ class Generator(metaclass=abc.ABCMeta):
                 # schemaloader based methods require schemas to have been created via SchemaLoader,
                 # which prepopulates some fields (e.g. definition_url). If the schema has not been processed through the
                 # loader, then roundtrip
-                if any(c for c in schema.classes.values() if not c.definition_uri):
-                    schema = yaml_dumper.dumps(schema)
+                schema = schema._as_dict
             loader = SchemaLoader(
                 schema,
                 self.base_dir,

{linkml-1.7.7 → linkml-1.7.8}/linkml/utils/rawloader.py

@@ -1,5 +1,6 @@
 import copy
 from datetime import datetime
+from pathlib import Path
 from typing import Optional, TextIO, Union
 from urllib.parse import urlparse
 
@@ -29,7 +30,7 @@ SchemaDefinition.MissingRequiredField = mrf
 
 
 def load_raw_schema(
-    data: Union[str, dict, TextIO],
+    data: Union[str, dict, TextIO, Path],
     source_file: Optional[str] = None,
     source_file_date: Optional[str] = None,
     source_file_size: Optional[int] = None,
@@ -58,6 +59,9 @@ def load_raw_schema(
         assert source_file_date is None, "source_file_date parameter not allowed if data is a file or URL"
         assert source_file_size is None, "source_file_size parameter not allowed if data is a file or URL"
 
+    if isinstance(data, Path):
+        data = str(data)
+
     # Convert the input into a valid SchemaDefinition
     if isinstance(data, (str, dict, TextIO)):
         # TODO: Build a generic loader that detects type from suffix or content and invokes the appropriate loader

{linkml-1.7.7 → linkml-1.7.8}/linkml/utils/schemaloader.py

@@ -2,6 +2,7 @@ import logging
 import os
 from collections import OrderedDict
 from copy import deepcopy
+from pathlib import Path
 from typing import Dict, Iterator, List, Mapping, Optional, Set, TextIO, Tuple, Union, cast
 from urllib.parse import urlparse
 
@@ -32,7 +33,7 @@ from linkml.utils.schemasynopsis import SchemaSynopsis
 class SchemaLoader:
     def __init__(
         self,
-        data: Union[str, TextIO, SchemaDefinition, dict],
+        data: Union[str, TextIO, SchemaDefinition, dict, Path],
         base_dir: Optional[str] = None,
         namespaces: Optional[Namespaces] = None,
         useuris: Optional[bool] = None,

{linkml-1.7.7 → linkml-1.7.8}/linkml/utils/sqlutils.py

@@ -58,16 +58,22 @@ class SQLStore:
     - mapping your data/objects in any LinkML compliant data format (json. yaml, rdf) into ORM objects
     """
 
-    schema: Union[str, SchemaDefinition] = None
-    schemaview: SchemaView = None
-    engine: Engine = None
-    database_path: str = None
+    schema: Optional[Union[str, Path, SchemaDefinition]] = None
+    schemaview: Optional[SchemaView] = None
+    engine: Optional[Engine] = None
+    database_path: Union[str, Path] = None
     use_memory: bool = False
     """https://docs.sqlalchemy.org/en/20/dialects/sqlite.html#using-a-memory-database-in-multiple-threads"""
 
-    module: ModuleType = None
-    native_module: ModuleType = None
-    include_schema_in_database: bool = None
+    module: Optional[ModuleType] = None
+    native_module: Optional[ModuleType] = None
+    include_schema_in_database: bool = False
+
+    def __post_init__(self):
+        if self.database_path is None and not self.use_memory:
+            raise ValueError("Must have database path or use_memory must be True")
+        if self.schema is not None and self.schemaview is None:
+            self.schemaview = SchemaView(self.schema)
 
     def db_exists(self, create=True, force=False) -> Optional[str]:
         """
@@ -117,8 +123,6 @@ class SQLStore:
         """
         gen = SQLAlchemyGenerator(self.schema)
         self.module = gen.compile_sqla(template=TemplateEnum.DECLARATIVE)
-        if self.schemaview is None:
-            self.schemaview = SchemaView(self.schema)
         return self.module
 
     def compile_native(self) -> ModuleType:
@@ -223,7 +227,6 @@ class SQLStore:
             for n, nu_typ in inspect.getmembers(self.module):
                 # TODO: make more efficient
                 if n == typ.__name__:
-                    # print(f'Creating {nu_typ} from: {inst_args}')
                     nu_obj = nu_typ(**inst_args)
                     return nu_obj
             raise ValueError(f"Cannot find {typ.__name__} in {self.module}")
@@ -237,8 +240,6 @@ class SQLStore:
         :param obj: sqla object
         :return: native dataclass object
         """
-        if self.schemaview is None:
-            self.schemaview = SchemaView(self.schema)
         typ = type(obj)
         nm = self.schemaview.class_name_mappings()
         if typ.__name__ in nm:
@@ -262,9 +263,7 @@ class SQLStore:
             for n, nu_typ in inspect.getmembers(self.native_module):
                 # TODO: make more efficient
                 if n == typ.__name__:
-                    # print(f'CREATING {nu_typ} FROM {inst_args}')
                     nu_obj = nu_typ(**inst_args)
-                    # print(f'CREATED {nu_obj}')
                     return nu_obj
             raise ValueError(f"Cannot find {typ.__name__} in {self.native_module}")
         else:

{linkml-1.7.7 → linkml-1.7.8}/linkml/validator/plugins/shacl_validation_plugin.py

@@ -34,21 +34,27 @@ class ShaclValidationPlugin(ValidationPlugin):
         self.closed = closed
         self.shacl_path = shacl_path
         self.raise_on_conversion_error = raise_on_conversion_error
+        self._loaded_graphs = {}
 
     def _shacl_graph(self, context: ValidationContext) -> Optional[rdflib.Graph]:
         g = rdflib.Graph()
         if self.shacl_path:
             g.parse(str(self.shacl_path))
         else:
-            gen = ShaclGenerator(context._schema)
-            g = gen.as_graph()
+            schema_hash = hash(str(context._schema))
+            if schema_hash in self._loaded_graphs:
+                g = self._loaded_graphs[schema_hash]
+            else:
+                gen = ShaclGenerator(context._schema)
+                g = gen.as_graph()
+                self._loaded_graphs[schema_hash] = g
         return g
 
     def process(self, instance: Any, context: ValidationContext) -> Iterator[ValidationResult]:
-        """Perform JSON Schema validation on the provided instance
+        """Perform SHACL Schema validation on the provided instance
 
         :param instance: The instance to validate
-        :param context: The validation context which provides a JSON Schema artifact
+        :param context: The validation context which provides a SHACL artifact
         :return: Iterator over validation results
         :rtype: Iterator[ValidationResult]
         """

{linkml-1.7.7 → linkml-1.7.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "linkml"
-version = "1.7.7"
+version = "1.7.8"
 description = "Linked Open Data Modeling Language"
 authors = [
     "Chris Mungall <cjmungall@lbl.gov>",
@@ -124,6 +124,7 @@ sqlalchemy = ">=1.4.31"
 watchdog = ">=0.9.0"
 pyshacl = { version = "^0.25.0", optional = true }
 black = { version=">=24.0.0", optional = true }
+typing-extensions = { version=">=4.4.0", python="<3.9" }
 
 [tool.poetry.group.dev.dependencies]
 chardet = "*"
@@ -133,12 +134,6 @@ nbconvert = "*"
 nbformat = "*"
 coverage = "^6.4.1"
 tox = "^4"
-furo = {version = "^2023.03.27", extras = ["docs"]}
-sphinxcontrib-mermaid = {version = "^0.7.1", extras = ["docs"]}
-sphinx = "*"
-sphinx-click = "*"
-sphinx-rtd-theme = "*"
-myst-parser = "*"
 requests-cache = "^1.2.0"
 myst-nb = {version=">=1.0.0", python=">=3.9"}
 sphinx-design = "^0.5.0"
@@ -157,6 +152,17 @@ black = ["black"]
 shacl = ["pyshacl"]
 tests = ["black", "pyshacl"]
 
+[tool.poetry.group.docs]
+optional = true
+
+[tool.poetry.group.docs.dependencies]
+furo = {version = "^2023.03.27", extras = ["docs"]}
+sphinxcontrib-mermaid = {version = "^0.7.1", extras = ["docs"]}
+sphinx = "*"
+sphinx-click = "*"
+sphinx-rtd-theme = "*"
+myst-parser = "*"
+
 [build-system]
 requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning"]
 build-backend = "poetry_dynamic_versioning.backend"
@@ -193,7 +199,9 @@ filterwarnings = [
 ]
 markers = [
   "network: mark tests that make external network requests",
-  "slow: mark test as slow to run"
+  "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"
 ]
 
 [tool.ruff]

{linkml-1.7.7 → linkml-1.7.8}/setup.py

@@ -55,7 +55,8 @@ install_requires = \
  'watchdog>=0.9.0']
 
 extras_require = \
-{'black': ['black>=24.0.0'],
+{':python_version < "3.9"': ['typing-extensions>=4.4.0'],
+ 'black': ['black>=24.0.0'],
  'shacl': ['pyshacl>=0.25.0,<0.26.0'],
  'tests': ['pyshacl>=0.25.0,<0.26.0', 'black>=24.0.0']}
 
@@ -113,7 +114,7 @@ entry_points = \
 
 setup_kwargs = {
     'name': 'linkml',
-    'version': '1.7.7',
+    'version': '1.7.8',
     '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.7.7 → linkml-1.7.8}/linkml/generators/jsonldgen.py

@@ -60,8 +60,8 @@ class JSONLDGenerator(Generator):
     """Path to a JSONLD context file"""
 
     def __post_init__(self) -> None:
-        super().__post_init__()
         self.original_schema = deepcopy(self.schema)
+        super().__post_init__()
 
     def _add_type(self, node: YAMLRoot) -> dict:
         if self.format == "jsonld":