linkml 1.7.2__tar.gz → 1.7.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.7.2
+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
@@ -22,7 +22,6 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Provides-Extra: docs
 Requires-Dist: antlr4-python3-runtime (>=4.9.0,<4.10)
 Requires-Dist: click (>=7.0)
 Requires-Dist: graphviz (>=0.10.1)

{linkml-1.7.2 → 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.2 → linkml-1.7.4}/linkml/generators/docgen.py

@@ -126,7 +126,7 @@ class DocGenerator(Generator):
     # ObjectVars
     dialect: Optional[Union[DIALECT, str]] = None
     """markdown dialect (e.g MyST, Python)"""
-    sort_by: str = field(default_factory=lambda: "name")
+    sort_by: str = "name"
     visit_all_class_slots = False
     template_mappings: Dict[str, str] = None
     directory: str = None
@@ -141,19 +141,19 @@ class DocGenerator(Generator):
     diagram_type: Optional[Union[DiagramType, str]] = None
     """style of diagram (ER, UML)"""
 
-    include_top_level_diagram: bool = field(default_factory=lambda: False)
+    include_top_level_diagram: bool = False
     """Whether the index page should include a schema diagram"""
 
     example_directory: Optional[str] = None
     example_runner: ExampleRunner = field(default_factory=lambda: ExampleRunner())
 
-    genmeta: bool = field(default_factory=lambda: False)
-    gen_classvars: bool = field(default_factory=lambda: True)
-    gen_slots: bool = field(default_factory=lambda: True)
-    no_types_dir: bool = field(default_factory=lambda: False)
-    use_slot_uris: bool = field(default_factory=lambda: False)
-    use_class_uris: bool = field(default_factory=lambda: False)
-    hierarchical_class_view: bool = field(default_factory=lambda: False)
+    genmeta: bool = False
+    gen_classvars: bool = True
+    gen_slots: bool = True
+    no_types_dir: bool = False
+    use_slot_uris: bool = False
+    use_class_uris: bool = False
+    hierarchical_class_view: bool = False
 
     def __post_init__(self):
         dialect = self.dialect

{linkml-1.7.2 → linkml-1.7.4}/linkml/generators/erdiagramgen.py

@@ -1,5 +1,5 @@
 import os
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from enum import Enum
 from typing import List, Optional, Union
 
@@ -129,11 +129,11 @@ class ERDiagramGenerator(Generator):
     exclude_attributes: bool = False
     """If True, do not include attributes in entities"""
 
-    genmeta: bool = field(default_factory=lambda: False)
-    gen_classvars: bool = field(default_factory=lambda: True)
-    gen_slots: bool = field(default_factory=lambda: True)
-    no_types_dir: bool = field(default_factory=lambda: False)
-    use_slot_uris: bool = field(default_factory=lambda: False)
+    genmeta: bool = False
+    gen_classvars: bool = True
+    gen_slots: bool = True
+    no_types_dir: bool = False
+    use_slot_uris: bool = False
 
     def __post_init__(self):
         self.schemaview = SchemaView(self.schema)

{linkml-1.7.2 → linkml-1.7.4}/linkml/generators/excelgen.py

@@ -1,5 +1,5 @@
 import logging
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from pathlib import Path
 from typing import List
 
@@ -22,8 +22,8 @@ class ExcelGenerator(Generator):
     uses_schemaloader = False
     requires_metamodel = False
 
-    split_workbook_by_class: bool = field(default_factory=lambda: False)
-    include_mixins: bool = field(default_factory=lambda: False)
+    split_workbook_by_class: bool = False
+    include_mixins: bool = False
 
     def __post_init__(self) -> None:
         super().__post_init__()

{linkml-1.7.2 → linkml-1.7.4}/linkml/generators/golanggen.py

@@ -160,7 +160,7 @@ class GolangGenerator(Generator):
             rc_name = self.name(rc)
             id_slot = self.get_identifier_or_key_slot(r)
             if slot.multivalued:
-                if not id_slot or slot.inlined:
+                if not id_slot or slot.inlined or slot.inlined_as_list:
                     if slot.inlined_as_list or not id_slot:
                         return f"[]{rc_name}"
                     else:

{linkml-1.7.2 → linkml-1.7.4}/linkml/generators/javagen.py

@@ -1,6 +1,6 @@
 import importlib.util
 import os
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Optional
 
 import click
@@ -78,10 +78,10 @@ class JavaGenerator(OOCodeGenerator):
 
     template_file: Optional[str] = None
 
-    gen_classvars: bool = field(default_factory=lambda: True)
-    gen_slots: bool = field(default_factory=lambda: True)
-    genmeta: bool = field(default_factory=lambda: False)
-    emit_metadata: bool = field(default_factory=lambda: True)
+    gen_classvars: bool = True
+    gen_slots: bool = True
+    genmeta: bool = False
+    emit_metadata: bool = True
 
     def default_value_for_type(self, typ: str) -> str:
         return TYPE_DEFAULTS.get(typ, "null")

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

@@ -45,12 +45,12 @@ class ContextGenerator(Generator):
     default_ns: str = None
     context_body: Dict = field(default_factory=lambda: dict())
     slot_class_maps: Dict = field(default_factory=lambda: dict())
-    emit_metadata: bool = field(default_factory=lambda: False)
-    model: Optional[bool] = field(default_factory=lambda: True)
+    emit_metadata: bool = False
+    model: Optional[bool] = True
     base: Optional[str] = None
     output: Optional[str] = None
-    prefixes: Optional[bool] = field(default_factory=lambda: True)
-    flatprefixes: Optional[bool] = field(default_factory=lambda: False)
+    prefixes: Optional[bool] = True
+    flatprefixes: Optional[bool] = False
 
     def __post_init__(self) -> None:
         super().__post_init__()
@@ -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.2 → linkml-1.7.4}/linkml/generators/jsonschemagen.py

@@ -2,7 +2,7 @@ import json
 import logging
 import os
 from copy import deepcopy
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import click
@@ -179,7 +179,7 @@ class JsonSchemaGenerator(Generator):
     # @deprecated("Use top_class")
     topClass: Optional[str] = None
 
-    not_closed: Optional[bool] = field(default_factory=lambda: True)
+    not_closed: Optional[bool] = True
     """If not closed, then an open-ended set of attributes can be instantiated for any object"""
 
     indent: int = 4
@@ -188,7 +188,7 @@ class JsonSchemaGenerator(Generator):
     top_class: Optional[Union[ClassDefinitionName, str]] = None  # JSON object is one instance of this
     """Class instantiated by the root node of the document tree"""
 
-    include_range_class_descendants: bool = field(default_factory=lambda: False)
+    include_range_class_descendants: bool = False
     """If set, use an open world assumption and allow the range of a slot to be any descendant of the declared range.
     Note that if the range of a slot has a type designator, descendants will always be included.
     """

{linkml-1.7.2 → linkml-1.7.4}/linkml/generators/linkmlgen.py

@@ -1,6 +1,6 @@
 import logging
 import os
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Union
 
 import click
@@ -30,8 +30,8 @@ class LinkmlGenerator(Generator):
     uses_schemaloader = False
     requires_metamodel = False
 
-    materialize_attributes: bool = field(default_factory=lambda: False)
-    materialize_patterns: bool = field(default_factory=lambda: False)
+    materialize_attributes: bool = False
+    materialize_patterns: bool = False
 
     def __post_init__(self):
         # TODO: consider moving up a level

{linkml-1.7.2 → linkml-1.7.4}/linkml/generators/markdowngen.py

@@ -1,6 +1,6 @@
 import os
 from contextlib import redirect_stdout
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from io import StringIO
 from typing import Any, Callable, Dict, List, Optional, Set, Union
 
@@ -47,7 +47,7 @@ class MarkdownGenerator(Generator):
     image_directory: Optional[str] = None
     classes: Set[ClassDefinitionName] = None
     image_dir: bool = False
-    index_file: str = field(default_factory=lambda: "index.md")
+    index_file: str = "index.md"
     noimages: bool = False
     noyuml: bool = False
     no_types_dir: bool = False

{linkml-1.7.2 → linkml-1.7.4}/linkml/generators/oocodegen.py

@@ -141,7 +141,10 @@ class OOCodeGenerator(Generator):
                 enum["description"] = enum_original.description
 
             for pv in enum_original.permissible_values.values():
-                label = self.generate_enum_label(pv.text)
+                if pv.title:
+                    label = self.generate_enum_label(pv.title)
+                else:
+                    label = self.generate_enum_label(pv.text)
                 val = {"label": label, "value": pv.text.replace('"', '\\"')}
                 if hasattr(pv, "description"):
                     val["description"] = pv.description

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

@@ -118,29 +118,29 @@ class OwlSchemaGenerator(Generator):
     """By default, use the linkml metadata profile,
     this allows for overrides."""
 
-    metaclasses: bool = field(default_factory=lambda: True)
+    metaclasses: bool = True
     """if True, include OWL representations of ClassDefinition, SlotDefinition, etc. Introduces punning"""
 
-    add_root_classes: bool = field(default_factory=lambda: False)
+    add_root_classes: bool = False
 
-    add_ols_annotations: bool = field(default_factory=lambda: True)
+    add_ols_annotations: bool = True
     graph: Optional[Graph] = None
     """Mutable graph that is being built up during OWL generation."""
 
     top_value_uri: Optional[URIRef] = None
     """If metaclasses=True, then this property is used to connect object shadows to literals"""
 
-    type_objects: bool = field(default_factory=lambda: True)
+    type_objects: bool = True
     """if True, represents types as classes (and thus all slots are object properties);
     typed object classes effectively shadow the main xsd literal types.
     The purpose of this is to allow a uniform ObjectProperty representation for all slots,
     without having to commit to being either Data or Object property (OWL-DL does not
     allow a property to be both."""
 
-    assert_equivalent_classes: bool = field(default_factory=lambda: False)
+    assert_equivalent_classes: bool = False
     """If True, assert equivalence between definition_uris and class_uris"""
 
-    use_native_uris: bool = field(default_factory=lambda: True)
+    use_native_uris: bool = True
     """If True, use the definition_uris, otherwise use class_uris."""
 
     mixins_as_expressions: bool = None
@@ -152,10 +152,10 @@ class OwlSchemaGenerator(Generator):
     node_owltypes: Mapping[Union[BNode, URIRef], Set[OWL_TYPE]] = field(default_factory=lambda: defaultdict(set))
     """rdfs:Datatype, owl:Thing"""
 
-    simplify: bool = field(default_factory=lambda: True)
+    simplify: bool = True
     """Reduce complex expressions to simpler forms"""
 
-    use_swrl: bool = field(default_factory=lambda: False)
+    use_swrl: bool = False
     """Use of SWRL is experimental"""
 
     target_profile: OWLProfile = field(default_factory=lambda: OWLProfile.dl)
@@ -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:
@@ -533,7 +536,8 @@ class OwlSchemaGenerator(Generator):
                 graph.add((max_card_expr, OWL.onProperty, slot_uri))
             if slot.has_member:
                 has_member_expr = self.transform_class_slot_expression(cls, slot.has_member, slot)
-                owl_exprs.append(self._some_values_from(slot_uri, has_member_expr))
+                if has_member_expr:
+                    owl_exprs.append(self._some_values_from(slot_uri, has_member_expr))
         return self._intersection_of(owl_exprs)
 
     def slot_node_owltypes(self, slot: Union[SlotDefinition, AnonymousSlotExpression]) -> Set[URIRef]:
@@ -558,7 +562,7 @@ class OwlSchemaGenerator(Generator):
         slot: Union[SlotDefinition, AnonymousSlotExpression],
         main_slot: SlotDefinition = None,
         owl_types: Set[OWL_TYPE] = None,
-    ) -> Union[BNode, URIRef]:
+    ) -> Optional[Union[BNode, URIRef]]:
         """
         Take a ClassExpression and SlotExpression combination and transform to a node.
 
@@ -597,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
@@ -929,6 +941,10 @@ class OwlSchemaGenerator(Generator):
                 triples.extend(graph.triples((obj, None, None)))
 
     def _some_values_from(self, property: URIRef, filler: Union[URIRef, BNode]) -> BNode:
+        if not property:
+            raise ValueError(f"Property is required, filler: {filler}")
+        if not filler:
+            raise ValueError(f"Filler is required, property: {property}")
         node = BNode()
         self.graph.add((node, RDF.type, OWL.Restriction))
         self.graph.add((node, OWL.onProperty, property))
@@ -970,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.2 → linkml-1.7.4}/linkml/generators/plantumlgen.py

@@ -7,7 +7,7 @@ https://plantuml.com/
 import base64
 import os
 import zlib
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Callable, List, Optional, Set, cast
 
 import click
@@ -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
 
@@ -48,7 +49,7 @@ class PlantumlGenerator(Generator):
     classes: Set[ClassDefinitionName] = None
     directory: Optional[str] = None
     kroki_server: Optional[str] = "https://kroki.io"
-    load_image: bool = field(default_factory=lambda: True)
+    load_image: bool = True
 
     def visit_schema(
         self,
@@ -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.2 → linkml-1.7.4}/linkml/generators/protogen.py

@@ -1,5 +1,5 @@
 import os
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 
 import click
 from linkml_runtime.linkml_model.meta import ClassDefinition, SlotDefinition
@@ -24,7 +24,7 @@ class ProtoGenerator(Generator):
     uses_schemaloader = True
 
     # ObjectVars
-    relative_slot_num: int = field(default_factory=lambda: 0)
+    relative_slot_num: int = 0
 
     def __post_init__(self):
         super().__post_init__()