linkml 1.7.3__tar.gz → 1.7.4__tar.gz

{linkml-1.7.3 → linkml-1.7.4}/PKG-INFO

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

{linkml-1.7.3 → linkml-1.7.4}/linkml/__init__.py

@@ -71,3 +71,10 @@ BIOLINK_MODEL_URI = "https://w3id.org/biolink/biolink-model"
 BIOLINK_MODEL_PYTHON_LOC = "biolink.model"
 
 TurtleSerializer.roundtrip_prefixes = [""]
+
+REQUESTS_TIMEOUT = 10
+"""
+Time (in seconds) to wait before failing a network request
+
+See: https://docs.python-requests.org/en/latest/user/advanced/#timeouts
+"""

{linkml-1.7.3 → linkml-1.7.4}/linkml/generators/jsonldcontextgen.py

@@ -150,7 +150,8 @@ class ContextGenerator(Generator):
         else:
             slot_def = {}
             if not slot.usage_slot_name:
-                if slot.range in self.schema.classes:
+                any_of_ranges = [any_of_el.range for any_of_el in slot.any_of]
+                if slot.range in self.schema.classes or any(rng in self.schema.classes for rng in any_of_ranges):
                     slot_def["@type"] = "@id"
                 elif slot.range in self.schema.enums:
                     slot_def["@context"] = ENUM_CONTEXT

{linkml-1.7.3 → linkml-1.7.4}/linkml/generators/owlgen.py

@@ -378,8 +378,12 @@ class OwlSchemaGenerator(Generator):
         # rules yield OWL GCI subClassOf axioms
         for rule in cls.rules:
             pre_node = condition_to_bnode(rule.preconditions)
+            if not pre_node:
+                continue
             pre_node = self._intersection_of([pre_node, subject_expr])
             post_node = condition_to_bnode(rule.postconditions)
+            if not post_node:
+                continue
             self.graph.add((pre_node, RDFS.subClassOf, post_node))
         # classification rules yield OWL GCI subClassOf axioms
         for expr in cls.classification_rules:
@@ -433,15 +437,10 @@ class OwlSchemaGenerator(Generator):
             if slot.name in slot_map:
                 for k, v in slot.__dict__.items():
                     curr = slot_map[slot.name].get(k, None)
-                    # print(f"MERGE={slot.name}.{k} = {v} // CURR={curr}")
                     if v and not curr:
                         slot_map[slot.name][k] = v
-                        # print(f"OVERRIDE={slot.name}, k={k}, v={v}")
             else:
                 slot_map[slot.name] = copy(slot.__dict__)
-                # print(f"INIT={slot.name}, vals={slot_map[slot.name]}")
-
-            # print(f"SN={slot.name}, vals={slot_map[slot.name]}")
         own_slots = [SlotDefinition(**v) for v in slot_map.values()]
         # sort by name
         own_slots.sort(key=lambda x: x.name)
@@ -462,6 +461,8 @@ class OwlSchemaGenerator(Generator):
         :param cls: LinkML class expression (anonymous if called recursively)
         :return: blank node representing the OWL expression
         """
+        if cls is None:
+            cls = AnonymousClassExpression()
         graph = self.graph
         sv = self.schemaview
         own_slots = self.get_own_slots(cls)
@@ -477,11 +478,13 @@ class OwlSchemaGenerator(Generator):
                 graph.add((cls_uri, OWL.disjointUnionOf, listnode))
             else:
                 sub_sub_exprs = []
-                for i, x in enumerate(sub_exprs):
-                    rest = sub_exprs[0:i] + sub_exprs[i + 1 :]
-                    neg_expr = self._complement_of_union_of(rest)
-                    sub_sub_exprs.append(self._intersection_of([x, neg_expr]))
-                sub_exprs.append(self._union_of(sub_sub_exprs))
+                for i, x in enumerate(cls.exactly_one_of):
+                    rest = cls.exactly_one_of[0:i] + cls.exactly_one_of[i + 1 :]
+                    neg_expr = self._complement_of_union_of([self.transform_class_expression(nx) for nx in rest])
+                    pos_expr = self._intersection_of([self.transform_class_expression(x), neg_expr])
+                    sub_sub_exprs.append(pos_expr)
+                owl_exprs.append(self._union_of(sub_sub_exprs))
+                # owl_exprs.extend(sub_exprs)
         if cls.all_of:
             owl_exprs.append(self._intersection_of([self.transform_class_expression(x) for x in cls.all_of]))
         if cls.none_of:
@@ -598,11 +601,19 @@ class OwlSchemaGenerator(Generator):
                 )
             )
         if slot.exactly_one_of:
-            owl_exprs.append(
-                self._exactly_one_of(
-                    [self.transform_class_slot_expression(cls, x, main_slot, owl_types) for x in slot.exactly_one_of]
+            disj_exprs = []
+            for i, operand in enumerate(slot.exactly_one_of):
+                rest = slot.exactly_one_of[0:i] + slot.exactly_one_of[i + 1 :]
+                neg_expr = self._complement_of_union_of(
+                    [self.transform_class_slot_expression(cls, x, main_slot, owl_types) for x in rest],
+                    owl_types=owl_types,
                 )
-            )
+                pos_expr = self._intersection_of(
+                    [self.transform_class_slot_expression(cls, operand, main_slot, owl_types), neg_expr],
+                    owl_types=owl_types,
+                )
+                disj_exprs.append(pos_expr)
+            owl_exprs.append(self._union_of(disj_exprs, owl_types=owl_types))
         range = slot.range
         # if not range and not owl_exprs:
         #    range = sv.schema.default_range
@@ -975,11 +986,14 @@ class OwlSchemaGenerator(Generator):
     def _metaslot_uri(self, name: str) -> URIRef:
         return URIRef("https://w3id.org/linkml/" + name)
 
-    def _complement_of_union_of(self, exprs: List[Union[BNode, URIRef]], **kwargs) -> Optional[Union[BNode, URIRef]]:
+    def _complement_of_union_of(
+        self, exprs: List[Union[BNode, URIRef]], owl_types: Set[OWL_TYPE] = None, **kwargs
+    ) -> Optional[Union[BNode, URIRef]]:
         if not exprs:
             raise ValueError("Must pass at least one")
         neg_expr = BNode()
-        owl_types = self._get_owltypes(set(), exprs)
+        if not owl_types:
+            owl_types = self._get_owltypes(set(), exprs)
         complement_predicate = OWL.complementOf
         if len(owl_types) == 1:
             if RDFS.Literal in owl_types:

{linkml-1.7.3 → linkml-1.7.4}/linkml/generators/plantumlgen.py

@@ -19,6 +19,7 @@ from linkml_runtime.linkml_model.meta import (
 )
 from linkml_runtime.utils.formatutils import camelcase, underscore
 
+from linkml import REQUESTS_TIMEOUT
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
 
@@ -101,7 +102,7 @@ class PlantumlGenerator(Generator):
                 camelcase(sorted(classes)[0] if classes else self.schema.name) + file_suffix,
             )
             if load_image:
-                resp = requests.get(plantuml_url, stream=True)
+                resp = requests.get(plantuml_url, stream=True, timeout=REQUESTS_TIMEOUT)
                 if resp.ok:
                     with open(self.output_file_name, "wb") as f:
                         for chunk in resp.iter_content(chunk_size=2048):

{linkml-1.7.3 → linkml-1.7.4}/linkml/generators/pydanticgen.py

@@ -1,10 +1,11 @@
+import inspect
 import logging
 import os
 from collections import defaultdict
 from copy import deepcopy
 from dataclasses import dataclass, field
 from types import ModuleType
-from typing import Dict, List, Optional, Set
+from typing import Dict, List, Optional, Set, Type, Union
 
 import click
 from jinja2 import Template
@@ -32,7 +33,9 @@ from linkml.utils.generator import shared_arguments
 from linkml.utils.ifabsent_functions import ifabsent_value_declaration
 
 
-def default_template(pydantic_ver: str = "1", extra_fields: str = "forbid") -> str:
+def default_template(
+    pydantic_ver: str = "1", extra_fields: str = "forbid", injected_classes: Optional[List[Union[Type, str]]] = None
+) -> str:
     """Constructs a default template for pydantic classes based on the version of pydantic"""
     ### HEADER ###
     template = """
@@ -62,7 +65,26 @@ if sys.version_info >= (3, 8):
 else:
     from typing_extensions import Literal
 
-
+{% if imports is not none %}
+{%- for import_module, import_classes in imports.items() -%}
+{% if import_classes is none -%}
+import {{ import_module }}
+{% elif import_classes is mapping -%}
+import {{ import_module }} as {{ import_classes['as'] }}
+{% else -%}
+from {{ import_module }} import (
+    {% for imported_class in import_classes %}
+    {%- if imported_class is string -%}
+    {{ imported_class }}
+    {%- else -%}
+    {{ imported_class['name'] }} as {{ imported_class['as'] }}
+    {%- endif -%}
+    {%- if not loop.last %},{{ '\n    ' }}{% else %}{{ '\n' }}{%- endif -%}
+    {% endfor -%}
+)
+{% endif -%}
+{% endfor -%}
+{% endif %}
 metamodel_version = "{{metamodel_version}}"
 version = "{{version if version else None}}"
 """
@@ -79,7 +101,6 @@ class ConfiguredBaseModel(WeakRefShimBaseModel,
                 extra = '{extra_fields}',
                 arbitrary_types_allowed = True,
                 use_enum_values = True):
-    pass
 """
     else:
         template += f"""
@@ -90,9 +111,27 @@ class ConfiguredBaseModel(BaseModel):
         extra = '{extra_fields}',
         arbitrary_types_allowed=True,
         use_enum_values = True)
-    pass
 """
 
+    ### Fields injected into base model
+    template += """{% if injected_fields is not none %}
+    {% for field in injected_fields -%}
+    {{ field }}
+    {% endfor %}
+{% else %}
+    pass
+{% endif %}
+        """
+
+    ### Extra classes
+    if injected_classes is not None and len(injected_classes) > 0:
+        template += """{{ '\n\n' }}"""
+        for cls in injected_classes:
+            if isinstance(cls, str):
+                template += cls + "\n\n"
+            else:
+                template += inspect.getsource(cls) + "\n\n"
+
     ### ENUMS ###
     template += """
 {% for e in enums.values() %}
@@ -273,6 +312,67 @@ class PydanticGenerator(OOCodeGenerator):
     template_file: str = None
     extra_fields: str = "forbid"
     gen_mixin_inheritance: bool = True
+    injected_classes: Optional[List[Union[Type, str]]] = None
+    """
+    A list/tuple of classes to inject into the generated module.
+    
+    Accepts either live classes or strings. Live classes will have their source code
+    extracted with inspect.get - so they need to be standard python classes declared in a
+    source file (ie. the module they are contained in needs a ``__file__`` attr, 
+    see: :func:`inspect.getsource` )
+    """
+    injected_fields: Optional[List[str]] = None
+    """
+    A list/tuple of field strings to inject into the base class.
+    
+    Examples:
+    
+    .. code-block:: python
+
+        injected_fields = (
+            'object_id: Optional[str] = Field(None, description="Unique UUID for each object")',
+        )
+    
+    """
+    imports: Optional[Dict[str, Union[None, Dict[str, str], List[Union[str, Dict[str, str]]]]]] = None
+    """
+    Additional imports to inject into generated module. 
+    
+    A dictionary mapping a module to a list of objects to import. 
+    If the value of an entry is ``None`` , import the whole module.
+    
+    Import Aliases:
+    If the value of a module import is a dictionary with a key "as",
+    or a class is specified as a dictionary with a "name" and "as",
+    then the import is renamed like "from module import class as renamedClass".
+    
+    Examples:
+        
+    .. code-block:: python
+    
+        imports = {
+            'typing': ['Dict', 'List', 'Union'],
+            'types': None,
+            'numpy': {'as': 'np'},
+            'collections': [{'name': 'OrderedDict', 'as': 'odict'}]
+        }
+        
+    becomes:
+    
+    .. code-block:: python
+    
+        from typing import (
+            Dict,
+            List,
+            Union
+        )
+        import types
+        import numpy as np
+        from collections import (
+            OrderedDict as odict
+        )
+    
+    """
 
     # ObjectVars (identical to pythongen)
     gen_classvars: bool = True
@@ -567,7 +667,7 @@ class PydanticGenerator(OOCodeGenerator):
             with open(self.template_file) as template_file:
                 template_obj = Template(template_file.read())
         else:
-            template_obj = Template(default_template(self.pydantic_version, self.extra_fields))
+            template_obj = Template(default_template(self.pydantic_version, self.extra_fields, self.injected_classes))
 
         sv: SchemaView
         sv = self.schemaview
@@ -668,6 +768,8 @@ class PydanticGenerator(OOCodeGenerator):
             metamodel_version=self.schema.metamodel_version,
             version=self.schema.version,
             class_isa_plus_mixins=self.get_class_isa_plus_mixins(),
+            imports=self.imports,
+            injected_fields=self.injected_fields,
             uses_numpy=uses_numpy,
         )
         return code

{linkml-1.7.3 → linkml-1.7.4}/linkml/generators/yumlgen.py

@@ -14,6 +14,7 @@ from linkml_runtime.linkml_model.meta import ClassDefinition, ClassDefinitionNam
 from linkml_runtime.utils.formatutils import camelcase, underscore
 from rdflib import Namespace
 
+from linkml import REQUESTS_TIMEOUT
 from linkml.utils.generator import Generator, shared_arguments
 
 yuml_is_a = "^-"
@@ -95,10 +96,10 @@ class YumlGenerator(Generator):
                 payload = "dsl_text=" + (",".join(yumlclassdef))
                 payload = payload.replace("%3F", "?").replace("%2B", "+")
                 url = "https://yuml.me/diagram/plain/class/"
-                resp = requests.post(url, data=payload)
+                resp = requests.post(url, data=payload, timeout=REQUESTS_TIMEOUT)
                 if resp.ok:
                     filename = resp.text.strip().replace(".svg", file_suffix)
-                    resp = requests.get(f"https://yuml.me/{filename}", stream=True)
+                    resp = requests.get(f"https://yuml.me/{filename}", stream=True, timeout=REQUESTS_TIMEOUT)
                     with open(self.output_file_name, "wb") as f:
                         for chunk in resp.iter_content(chunk_size=2048):
                             f.write(chunk)

{linkml-1.7.3 → linkml-1.7.4}/linkml/utils/converter.py

@@ -1,7 +1,6 @@
 import logging
 import os
 import sys
-from typing import List
 
 import click
 from linkml_runtime.linkml_model import Prefix
@@ -77,7 +76,7 @@ def cli(
     output=None,
     input_format=None,
     output_format=None,
-    prefix: List = [],
+    prefix=None,
     target_class_from_path=None,
     schema=None,
     validate=None,
@@ -98,6 +97,8 @@ def cli(
 
     For more information, see https://linkml.io/linkml/data/index.html
     """
+    if prefix is None:
+        prefix = []
     if module is None:
         if schema is None:
             raise Exception("must pass one of module OR schema")

{linkml-1.7.3 → linkml-1.7.4}/linkml/utils/generator.py

@@ -465,7 +465,7 @@ class Generator(metaclass=abc.ABCMeta):
         """Return an ordered list of ancestor names for the supplied slot or class
 
         @param element: Slot or class name or definition
-        @return: Ordered list of of ancestor names
+        @return: Ordered list of ancestor names
         """
         return [element.name] + ([] if element.is_a is None else self.ancestors(self.parent(element)))
 
@@ -620,7 +620,7 @@ class Generator(metaclass=abc.ABCMeta):
 
     def slot_range_path(self, slot_or_name: Union[str, SlotDefinition]) -> List[str]:
         """
-        Return a ordered list of slot ranges from distal to proximal
+        Return an ordered list of slot ranges from distal to proximal
 
         :param slot_or_name: slot whose range is being typed
         :return: ordered list of types from base type forward

{linkml-1.7.3 → linkml-1.7.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "linkml"
-version = "1.7.3"
+version = "1.7.4"
 description = "Linked Open Data Modeling Language"
 authors = [
     "Chris Mungall <cjmungall@lbl.gov>",

{linkml-1.7.3 → linkml-1.7.4}/setup.py

@@ -109,7 +109,7 @@ entry_points = \
 
 setup_kwargs = {
     'name': 'linkml',
-    'version': '1.7.3',
+    'version': '1.7.4',
     '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',