linkml 1.7.7__py3-none-any.whl → 1.7.9__py3-none-any.whl

linkml/utils/generator.py

@@ -20,17 +20,14 @@ import logging
 import os
 import re
 import sys
-from contextlib import redirect_stdout
 from dataclasses import dataclass, field
 from functools import lru_cache
-from io import StringIO
 from pathlib import Path
 from typing import Callable, ClassVar, Dict, List, Mapping, Optional, Set, TextIO, Type, Union, cast
 
 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 +80,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 +127,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
@@ -177,9 +174,14 @@ class Generator(metaclass=abc.ABCMeta):
     stacktrace: bool = False
     """True means print stack trace, false just error message"""
 
+    include: Optional[Union[str, Path, SchemaDefinition]] = None
+    """If set, include extra schema outside of the imports mechanism"""
+
     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 +193,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:
@@ -199,7 +205,12 @@ class Generator(metaclass=abc.ABCMeta):
         else:
             logging.info(f"Using SchemaView with im={self.importmap} // base_dir={self.base_dir}")
             self.schemaview = SchemaView(schema, importmap=self.importmap, base_dir=self.base_dir)
+            if self.include:
+                if isinstance(self.include, (str, Path)):
+                    self.include = SchemaView(self.include, importmap=self.importmap, base_dir=self.base_dir).schema
+                self.schemaview.merge_schema(self.include)
             self.schema = self.schemaview.schema
+
         self._init_namespaces()
 
     def _initialize_using_schemaloader(self, schema: Union[str, TextIO, SchemaDefinition, "Generator"]):
@@ -225,8 +236,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,
@@ -263,66 +273,82 @@ class Generator(metaclass=abc.ABCMeta):
         :param kwargs: Generator specific parameters
         :return: Generated output
         """
-        output = StringIO()
-        # Note: we currently redirect stdout, this means that print statements within
-        # each generator will be redirected to the StringIO object.
-        # See https://github.com/linkml/linkml/issues/923 for discussion on simplifying this
-        with redirect_stdout(output):
-            # the default is to use the Visitor Pattern; each individual generator may
-            # choose to override methods {visit,end}_{element}.
-            # See https://github.com/linkml/linkml/issues/923
-            self.visit_schema(**kwargs)
-            for sn, ss in (
-                sorted(self.schema.subsets.items(), key=lambda s: s[0].lower())
-                if self.visits_are_sorted
-                else self.schema.subsets.items()
-            ):
-                self.visit_subset(ss)
-            for tn, typ in (
-                sorted(self.schema.types.items(), key=lambda s: s[0].lower())
-                if self.visits_are_sorted
-                else self.schema.types.items()
-            ):
-                self.visit_type(typ)
-            for enum in (
-                sorted(self.schema.enums.values(), key=lambda e: e.name.lower())
-                if self.visits_are_sorted
-                else self.schema.enums.values()
-            ):
-                self.visit_enum(enum)
-            for sn, slot in (
-                sorted(self.schema.slots.items(), key=lambda c: c[0].lower())
-                if self.visits_are_sorted
-                else self.schema.slots.items()
-            ):
-                self.visit_slot(self.aliased_slot_name(slot), slot)
-            for cls in (
-                sorted(self.schema.classes.values(), key=lambda c: c.name.lower())
-                if self.visits_are_sorted
-                else self.schema.classes.values()
-            ):
-                if self.visit_class(cls):
-                    for slot in self.all_slots(cls) if self.visit_all_class_slots else self.own_slots(cls):
-                        self.visit_class_slot(cls, self.aliased_slot_name(slot), slot)
-                    self.end_class(cls)
-            self.end_schema(**kwargs)
-        return output.getvalue()
-
-    def visit_schema(self, **kwargs) -> None:
+        out = ""
+
+        # the default is to use the Visitor Pattern; each individual generator may
+        # choose to override methods {visit,end}_{element}.
+        # See https://github.com/linkml/linkml/issues/923
+        sub_out = self.visit_schema(**kwargs)
+        if sub_out is not None:
+            out += sub_out
+        for sn, ss in (
+            sorted(self.schema.subsets.items(), key=lambda s: s[0].lower())
+            if self.visits_are_sorted
+            else self.schema.subsets.items()
+        ):
+            sub_out = self.visit_subset(ss)
+            if sub_out is not None:
+                out += sub_out
+        for tn, typ in (
+            sorted(self.schema.types.items(), key=lambda s: s[0].lower())
+            if self.visits_are_sorted
+            else self.schema.types.items()
+        ):
+            sub_out = self.visit_type(typ)
+            if sub_out is not None:
+                out += sub_out
+        for enum in (
+            sorted(self.schema.enums.values(), key=lambda e: e.name.lower())
+            if self.visits_are_sorted
+            else self.schema.enums.values()
+        ):
+            sub_out = self.visit_enum(enum)
+            if sub_out is not None:
+                out += sub_out
+        for sn, slot in (
+            sorted(self.schema.slots.items(), key=lambda c: c[0].lower())
+            if self.visits_are_sorted
+            else self.schema.slots.items()
+        ):
+            sub_out = self.visit_slot(self.aliased_slot_name(slot), slot)
+            if sub_out is not None:
+                out += sub_out
+        for cls in (
+            sorted(self.schema.classes.values(), key=lambda c: c.name.lower())
+            if self.visits_are_sorted
+            else self.schema.classes.values()
+        ):
+            cls_out = self.visit_class(cls)
+            if cls_out:
+                if isinstance(cls_out, str):
+                    out += cls_out
+                for slot in self.all_slots(cls) if self.visit_all_class_slots else self.own_slots(cls):
+                    sub_out = self.visit_class_slot(cls, self.aliased_slot_name(slot), slot)
+                    if sub_out is not None:
+                        out += sub_out
+                sub_out = self.end_class(cls)
+                if sub_out is not None:
+                    out += sub_out
+        sub_out = self.end_schema(**kwargs)
+        if sub_out is not None:
+            out += sub_out
+        return out
+
+    def visit_schema(self, **kwargs) -> Optional[str]:
         """Visited once at the beginning of generation
 
         @param kwargs: Arguments passed through from CLI -- implementation dependent
         """
         ...
 
-    def end_schema(self, **kwargs) -> None:
+    def end_schema(self, **kwargs) -> Optional[str]:
         """Visited once at the end of generation
 
         @param kwargs: Arguments passed through from CLI -- implementation dependent
         """
         ...
 
-    def visit_class(self, cls: ClassDefinition) -> bool:
+    def visit_class(self, cls: ClassDefinition) -> Optional[Union[str, bool]]:
         """Visited once per schema class
 
         @param cls: class being visited
@@ -330,14 +356,14 @@ class Generator(metaclass=abc.ABCMeta):
         """
         return True
 
-    def end_class(self, cls: ClassDefinition) -> None:
+    def end_class(self, cls: ClassDefinition) -> Optional[str]:
         """Visited after visit_class_slots (if visit_class returned true)
 
         @param cls: class being visited
         """
         ...
 
-    def visit_class_slot(self, cls: ClassDefinition, aliased_slot_name: str, slot: SlotDefinition) -> None:
+    def visit_class_slot(self, cls: ClassDefinition, aliased_slot_name: str, slot: SlotDefinition) -> Optional[str]:
         """Visited for each slot in a class.  If class level visit_all_slots is true, this is visited once
         for any class that is inherited (class itself, is_a, mixin, apply_to).  Otherwise, just the own slots.
 
@@ -347,7 +373,7 @@ class Generator(metaclass=abc.ABCMeta):
         """
         ...
 
-    def visit_slot(self, aliased_slot_name: str, slot: SlotDefinition) -> None:
+    def visit_slot(self, aliased_slot_name: str, slot: SlotDefinition) -> Optional[str]:
         """Visited once for every slot definition in the schema.
 
         @param aliased_slot_name: Aliased name of the slot.  May not be unique
@@ -355,21 +381,21 @@ class Generator(metaclass=abc.ABCMeta):
         """
         ...
 
-    def visit_type(self, typ: TypeDefinition) -> None:
+    def visit_type(self, typ: TypeDefinition) -> Optional[str]:
         """Visited once for every type definition in the schema
 
         @param typ: Type definition
         """
         ...
 
-    def visit_subset(self, subset: SubsetDefinition) -> None:
+    def visit_subset(self, subset: SubsetDefinition) -> Optional[str]:
         """Visited once for every subset definition in the schema
 
         #param subset: Subset definition
         """
         ...
 
-    def visit_enum(self, enum: EnumDefinition) -> None:
+    def visit_enum(self, enum: EnumDefinition) -> Optional[str]:
         """Visited once for every enum definition in the schema
 
         @param enum: Enum definition

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/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/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/validator/cli.py

@@ -108,6 +108,13 @@ DEPRECATED = "[DEPRECATED: only used in legacy mode]"
     help=f"{DEPRECATED} When handling range constraints, include all descendants of the range "
     "class instead of just the range class",
 )
+@click.option(
+    "--include-context/--no-include-context",
+    "-D",
+    default=False,
+    show_default=True,
+    help="Include additional context when reporting of validation errors.",
+)
 @click.argument("data_sources", nargs=-1, type=click.Path(exists=True))
 @click.version_option(__version__, "-V", "--version")
 @click.pass_context
@@ -123,6 +130,7 @@ def cli(
     input_format: Optional[str],
     index_slot: Optional[str],
     include_range_class_descendants: bool,
+    include_context: bool,
 ):
     if legacy_mode:
         from linkml.validators import jsonschemavalidator
@@ -183,6 +191,9 @@ def cli(
         for result in validator.iter_results_from_source(loader, config.target_class):
             severity_counter[result.severity] += 1
             click.echo(f"[{result.severity.value}] [{loader.source}/{result.instance_index}] {result.message}")
+            if include_context:
+                for ctx in result.context:
+                    click.echo(f"[CONTEXT] {ctx}")
 
     if sum(severity_counter.values()) == 0:
         click.echo("No issues found")

linkml/validator/plugins/jsonschema_validation_plugin.py

@@ -46,6 +46,7 @@ class JsonschemaValidationPlugin(ValidationPlugin):
             path_override=self.json_schema_path,
         )
         for error in validator.iter_errors(instance):
+            error_context = [ctx.message for ctx in error.context]
             best_error = best_match([error])
             yield ValidationResult(
                 type="jsonschema validation",
@@ -53,4 +54,5 @@ class JsonschemaValidationPlugin(ValidationPlugin):
                 instance=instance,
                 instantiates=context.target_class,
                 message=f"{best_error.message} in /{'/'.join(str(p) for p in best_error.absolute_path)}",
+                context=error_context,
             )

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/validator/report.py

@@ -28,6 +28,7 @@ class ValidationResult(BaseModel):
     instance: Optional[Any] = None
     instance_index: Optional[int] = None
     instantiates: Optional[str] = None
+    context: List[str] = []
 
 
 class ValidationReport(BaseModel):

linkml/workspaces/example_runner.py

@@ -20,6 +20,7 @@ from linkml_runtime.dumpers import json_dumper, rdflib_dumper, yaml_dumper
 from linkml_runtime.linkml_model import ElementName
 from linkml_runtime.utils.formatutils import camelcase
 
+from linkml._version import __version__
 from linkml.generators.pythongen import PythonGenerator
 from linkml.validator import Validator, _get_default_validator
 
@@ -298,6 +299,7 @@ class ExampleRunner:
     show_default=True,
     help="If true use type_designators to deepen ranges",
 )
+@click.version_option(__version__, "-V", "--version")
 def cli(schema, prefixes, output: TextIO, **kwargs):
     """Process a folder of examples and a folder of counter examples.
 

{linkml-1.7.7.dist-info → linkml-1.7.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.7.7
+Version: 1.7.9
 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