linkml 1.7.8__py3-none-any.whl → 1.7.10__py3-none-any.whl

linkml/utils/deprecation.py

@@ -0,0 +1,255 @@
+"""
+Utilities for deprecating functionality and dependencies.
+
+- Emitting DeprecationWarnings
+- Tracking deprecated and removed in versions
+- Fail tests when something marked as removed_in is still present in the specified version
+
+Initial draft for deprecating Pydantic 1, to make more general, needs
+- function wrapper version
+- ...
+
+To deprecate something:
+
+- Create a :class:`.Deprecation` object within the `DEPRECATIONS` tuple
+- Use the :func:`.deprecation_warning` function wherever the deprecated feature would be used to emit the warning
+
+"""
+
+import re
+import warnings
+from dataclasses import dataclass
+from importlib.metadata import version
+from typing import Optional
+
+# Stolen from https://github.com/pypa/packaging/blob/main/src/packaging/version.py
+# Updated to include major, minor, and patch versions
+PEP440_PATTERN = r"""
+    v?
+    (?:
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch
+        (?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)
+        (?P<pre>                                          # pre-release
+            [-_\.]?
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?P<pre_n>[0-9]+)?
+        )?
+        (?P<post>                                         # post release
+            (?:-(?P<post_n1>[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?P<post_l>post|rev|r)
+                [-_\.]?
+                (?P<post_n2>[0-9]+)?
+            )
+        )?
+        (?P<dev>                                          # dev release
+            [-_\.]?
+            (?P<dev_l>dev)
+            [-_\.]?
+            (?P<dev_n>[0-9]+)?
+        )?
+    )
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
+PEP440 = re.compile(r"^\s*" + PEP440_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
+
+
+@dataclass
+class SemVer:
+    """
+    Representation of semantic version that supports inequality comparisons.
+
+    .. note::
+
+        The inequality methods _only_ test the numeric major, minor, and patch components
+        of the version - ie. they do not evaluate the prerelease versions as described in the semver
+        spec. This is not intended to be a general SemVer inequality calculator, but used
+        only for testing deprecations
+
+    """
+
+    major: int = 0
+    minor: int = 0
+    patch: int = 0
+    epoch: Optional[int] = None
+    pre: Optional[str] = None
+    pre_l: Optional[str] = None
+    pre_n: Optional[str] = None
+    post: Optional[str] = None
+    post_n1: Optional[str] = None
+    post_l: Optional[str] = None
+    post_n2: Optional[str] = None
+    dev: Optional[str] = None
+    dev_l: Optional[str] = None
+    dev_n: Optional[str] = None
+    local: Optional[str] = None
+
+    def __post_init__(self):
+        self.major = int(self.major)
+        self.minor = int(self.minor)
+        self.patch = int(self.patch)
+
+    @classmethod
+    def from_str(cls, v: str) -> Optional["SemVer"]:
+        """
+        Create a SemVer from a string using `PEP 440 <https://peps.python.org/pep-0440/>`_
+        syntax.
+
+        Examples:
+
+            .. code-block:: python
+
+                >>> version = SemVer.from_str("v0.1.0")
+                >>> print(version)
+                0.1.0
+
+        """
+        match = PEP440.search(v)
+        if match is None:
+            return None
+        return SemVer(**match.groupdict())
+
+    @classmethod
+    def from_package(cls, package: str) -> "SemVer":
+        """Get semver from package name"""
+        v = version(package)
+        return SemVer.from_str(v)
+
+    def __eq__(self, other: "SemVer"):
+        return self.major == other.major and self.minor == other.minor and self.patch == other.patch
+
+    def __lt__(self, other: "SemVer"):
+        # fall through each if elif only if version component is equal
+        for field in ("major", "minor", "patch"):
+            if getattr(self, field) < getattr(other, field):
+                return True
+            elif getattr(self, field) > getattr(other, field):
+                return False
+
+        # otherwise, equal (which is False)
+        return False
+
+    def __gt__(self, other: "SemVer"):
+        return not (self < other) and not (self == other)
+
+    def __le__(self, other: "SemVer"):
+        return (self < other) or (self == other)
+
+    def __ge__(self, other: "SemVer"):
+        return (self > other) or (self == other)
+
+    def __str__(self) -> str:
+        return ".".join([str(item) for item in [self.major, self.minor, self.patch]])
+
+
+@dataclass
+class Deprecation:
+    """
+    Parameterization of a deprecation.
+    """
+
+    name: str
+    """Shorthand, unique name used to refer to this deprecation"""
+    message: str
+    """Message to be displayed explaining the deprecation"""
+    deprecated_in: SemVer
+    """Version that the feature was deprecated in"""
+    removed_in: Optional[SemVer] = None
+    """Version that the feature will be removed in"""
+    recommendation: Optional[str] = None
+    """Recommendation about what to do to replace the deprecated behavior"""
+    issue: Optional[int] = None
+    """GitHub version describing deprecation"""
+
+    def __post_init__(self):
+        if self.deprecated_in is not None and isinstance(self.deprecated_in, str):
+            self.deprecated_in = SemVer.from_str(self.deprecated_in)
+        if self.removed_in is not None and isinstance(self.removed_in, str):
+            self.removed_in = SemVer.from_str(self.removed_in)
+
+    def __str__(self) -> str:
+        msg = f"[{self.name}] "
+        if self.removed:
+            msg += "REMOVED"
+        elif self.deprecated:
+            msg += "DEPRECATED"
+
+        msg += f"\n{self.message}"
+        msg += f"\nDeprecated In: {str(self.deprecated_in)}"
+        if self.removed_in is not None:
+            msg += f"\nRemoved In: {str(self.removed_in)}"
+        if self.recommendation is not None:
+            msg += f"\nRecommendation: {self.recommendation}"
+        if self.issue is not None:
+            msg += f"\nSee: https://github.com/linkml/linkml/issues/{self.issue}"
+        return msg
+
+    @property
+    def deprecated(self) -> bool:
+        return SemVer.from_package("linkml") >= self.deprecated_in
+
+    @property
+    def removed(self) -> bool:
+        if self.removed_in is None:
+            return False
+        return SemVer.from_package("linkml") >= self.removed_in
+
+    def warn(self, **kwargs):
+        if self.deprecated:
+            warnings.warn(message=str(self), category=DeprecationWarning, stacklevel=3, **kwargs)
+
+
+DEPRECATIONS = (
+    Deprecation(
+        name="pydanticgen-v1",
+        deprecated_in=SemVer.from_str("1.7.5"),
+        removed_in=SemVer.from_str("1.8.0"),
+        message="Support for generating Pydantic v1.*.* models with pydanticgen is deprecated",
+        recommendation="Migrate any existing models to Pydantic v2",
+        issue=1925,
+    ),
+    Deprecation(
+        name="pydantic-v1",
+        deprecated_in=SemVer.from_str("1.7.5"),
+        removed_in=SemVer.from_str("1.9.0"),
+        message=(
+            "LinkML will set a dependency of pydantic>=2 and become incompatible "
+            "with packages with pydantic<2 as a runtime dependency"
+        ),
+        recommendation="Update dependent packages to use pydantic>=2",
+        issue=1925,
+    ),
+)  # type: tuple[Deprecation, ...]
+
+EMITTED = set()  # type: set[str]
+
+
+def deprecation_warning(name: str):
+    """
+    Call this with the name of the deprecation object wherever the deprecated functionality will be used
+
+    This function will
+
+    - emit a warning if the current version is greater than ``deprecated_in``
+    - log that the deprecated feature was accessed in ``EMITTED`` for testing deprecations and muting warnings
+
+    """
+    global DEPRECATIONS
+    global EMITTED
+
+    dep = [dep for dep in DEPRECATIONS if dep.name == name]
+    if len(dep) == 1:
+        dep = dep[0]
+    elif len(dep) > 1:
+        raise RuntimeError(f"Duplicate deprecations found with name {name}")
+    else:
+        EMITTED.add(name)
+        return
+
+    if dep.name not in EMITTED:
+        dep.warn()
+
+    EMITTED.add(name)

linkml/utils/generator.py

@@ -20,10 +20,8 @@ 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
 
@@ -176,6 +174,9 @@ 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()
@@ -204,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"]):
@@ -267,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
@@ -334,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.
 
@@ -351,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
@@ -359,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/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/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.8.dist-info → linkml-1.7.10.dist-info}/METADATA

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