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

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/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/generators/summarygen.py

@@ -3,9 +3,9 @@
 """
 
 import os
-import sys
 from csv import DictWriter
 from dataclasses import dataclass
+from io import StringIO
 from typing import Optional
 
 import click
@@ -28,9 +28,12 @@ class SummaryGenerator(Generator):
     slottab: Optional[DictWriter] = None
     dialect: str = "excel-tab"
 
+    _str_io: Optional[StringIO] = None
+
     def visit_schema(self, **_) -> None:
+        self._str_io = StringIO()
         self.classtab = DictWriter(
-            sys.stdout,
+            self._str_io,
             [
                 "Class Name",
                 "Parent Class",
@@ -79,6 +82,9 @@ class SummaryGenerator(Generator):
             }
         )
 
+    def end_schema(self, **kwargs) -> Optional[str]:
+        return self._str_io.getvalue()
+
 
 @shared_arguments(SummaryGenerator)
 @click.version_option(__version__, "-V", "--version")

linkml/generators/terminusdbgen.py

@@ -71,8 +71,8 @@ class TerminusdbGenerator(Generator):
         self.classes = []
         self.raw_additions = []
 
-    def end_schema(self, **_) -> None:
-        print(json.dumps(WQ().woql_and(*self.classes, *self.raw_additions).to_dict(), indent=2))
+    def end_schema(self, **_) -> str:
+        return json.dumps(WQ().woql_and(*self.classes, *self.raw_additions).to_dict(), indent=2)
 
     def visit_class(self, cls: ClassDefinition) -> bool:
         self.clswq = WQ().add_class(camelcase(cls.name)).label(camelcase(cls.name)).description(be(cls.description))

linkml/generators/yumlgen.py

@@ -59,7 +59,7 @@ class YumlGenerator(Generator):
         diagram_name: Optional[str] = None,
         load_image: bool = True,
         **_,
-    ) -> None:
+    ) -> Optional[str]:
         if directory:
             os.makedirs(directory, exist_ok=True)
         if classes is not None:
@@ -106,7 +106,7 @@ class YumlGenerator(Generator):
                 else:
                     self.logger.error(f"{resp.reason} accessing {url}: {resp!r}")
         else:
-            print(str(YUML) + ",".join(yumlclassdef), end="")
+            return str(YUML) + ",".join(yumlclassdef)
 
     def class_box(self, cn: ClassDefinitionName) -> str:
         """Generate a box for the class.  Populate its interior only if (a) it hasn't previously been generated and

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/utils/__init__.py

@@ -0,0 +1,3 @@
+from linkml.utils.deprecation import deprecation_warning
+
+__all__ = ["deprecation_warning"]

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)