linkml 1.8.0rc2__py3-none-any.whl → 1.8.2__py3-none-any.whl

linkml/generators/shaclgen.py

@@ -11,7 +11,7 @@ from linkml_runtime.utils.schemaview import SchemaView
 from linkml_runtime.utils.yamlutils import TypedNode, extended_float, extended_int, extended_str
 from rdflib import BNode, Graph, Literal, URIRef
 from rdflib.collection import Collection
-from rdflib.namespace import RDF, SH, XSD
+from rdflib.namespace import RDF, RDFS, SH, XSD
 
 from linkml._version import __version__
 from linkml.generators.shacl.ifabsent_processor import IfAbsentProcessor
@@ -73,6 +73,10 @@ class ShaclGenerator(Generator):
                 class_uri_with_suffix += self.suffix
             shape_pv(RDF.type, SH.NodeShape)
             shape_pv(SH.targetClass, class_uri)  # TODO
+
+            if c.is_a:
+                shape_pv(RDFS.subClassOf, URIRef(sv.get_uri(c.is_a, expand=True)))
+
             if self.closed:
                 if c.mixin or c.abstract:
                     shape_pv(SH.closed, Literal(False))
@@ -303,7 +307,7 @@ def add_simple_data_type(func: Callable, r: ElementName) -> None:
 
 
 @shared_arguments(ShaclGenerator)
-@click.command()
+@click.command(name="shacl")
 @click.option(
     "--closed/--non-closed",
     default=True,

linkml/generators/shexgen.py

@@ -223,7 +223,7 @@ class ShExGenerator(Generator):
 
 
 @shared_arguments(ShExGenerator)
-@click.command()
+@click.command(name="shex")
 @click.option("-o", "--output", help="Output file name")
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, **args):

linkml/generators/sparqlgen.py

@@ -188,7 +188,7 @@ class SparqlGenerator(Generator):
 
 
 @shared_arguments(SparqlGenerator)
-@click.command()
+@click.command(name="sparql")
 @click.option("--dir", "-d", help="Directory in which queries will be deposited")
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, dir, **kwargs):

linkml/generators/sqlalchemygen.py

@@ -216,7 +216,7 @@ class SQLAlchemyGenerator(Generator):
     help="Emit FK declarations",
 )
 @click.version_option(__version__, "-V", "--version")
-@click.command()
+@click.command(name="sqla")
 def cli(yamlfile, declarative, generate_classes, pydantic, use_foreign_keys=True, **args):
     """Generate SQL DDL representation"""
     if pydantic:

linkml/generators/sqltablegen.py

@@ -290,7 +290,7 @@ class SQLTableGenerator(Generator):
 
 
 @shared_arguments(SQLTableGenerator)
-@click.command()
+@click.command(name="sqltables")
 @click.option(
     "--dialect",
     default="sqlite",

linkml/generators/sssomgen.py

@@ -180,7 +180,7 @@ class SSSOMGenerator(Generator):
 
 
 @shared_arguments(SSSOMGenerator)
-@click.command()
+@click.command(name="sssom")
 @click.option("-o", "--output", help="Output file name")
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, **kwargs):

linkml/generators/summarygen.py

@@ -88,7 +88,7 @@ class SummaryGenerator(Generator):
 
 @shared_arguments(SummaryGenerator)
 @click.version_option(__version__, "-V", "--version")
-@click.command()
+@click.command(name="summary")
 def cli(yamlfile, **args):
     """Generate TSV summary files for viewing in Excel and the like"""
     print(SummaryGenerator(yamlfile, **args).serialize(**args))

linkml/generators/terminusdbgen.py

@@ -1,5 +1,6 @@
 import json
 import os
+import warnings
 from dataclasses import dataclass
 from typing import List
 
@@ -10,9 +11,7 @@ from linkml_runtime.utils.formatutils import be, camelcase, underscore
 try:
     from terminusdb_client.woqlquery import WOQLQuery as WQ
 except ImportError:
-    import warnings
-
-    warnings.warn("terminusdb_client is not a requirement of this package, please install it separately")
+    WQ = None
 
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
@@ -67,6 +66,10 @@ class TerminusdbGenerator(Generator):
     raw_additions: List = None
     clswq: str = None
 
+    def __post_init__(self):
+        if WQ is None:
+            warnings.warn("terminusdb_client is not a requirement of this package, please install it separately")
+
     def visit_schema(self, inline: bool = False, **kwargs) -> None:
         self.classes = []
         self.raw_additions = []
@@ -134,7 +137,7 @@ class TerminusdbGenerator(Generator):
 
 @shared_arguments(TerminusdbGenerator)
 @click.version_option(__version__, "-V", "--version")
-@click.command()
+@click.command(name="terminusdb")
 def cli(yamlfile, **args):
     """Generate graphql representation of a LinkML model"""
     print(TerminusdbGenerator(yamlfile, **args).serialize(**args))

linkml/generators/typescriptgen.py

@@ -264,7 +264,7 @@ class TypescriptGenerator(OOCodeGenerator):
 @click.version_option(__version__, "-V", "--version")
 @click.option("--gen-type-utils/", "-u", help="Generate Type checking utils", is_flag=True)
 @click.option("--include-induced-slots/", help="Generate slots induced through inheritance", is_flag=True)
-@click.command()
+@click.command(name="typescript")
 def cli(yamlfile, gen_type_utils=False, include_induced_slots=False, **args):
     """Generate typescript interfaces and types
 

linkml/generators/yamlgen.py

@@ -36,7 +36,7 @@ class YAMLGenerator(Generator):
 
 
 @shared_arguments(YAMLGenerator)
-@click.command()
+@click.command(name="yaml")
 @click.option(
     "--raw/--no-raw",
     default=False,

linkml/generators/yumlgen.py

@@ -262,7 +262,7 @@ class YumlGenerator(Generator):
 
 
 @shared_arguments(YumlGenerator)
-@click.command()
+@click.command(name="yuml")
 @click.option("--classes", "-c", multiple=True, help="Class(es) to emit")
 @click.option(
     "--directory",

linkml/linter/cli.py

@@ -33,7 +33,7 @@ def get_yaml_files(root: Path, accept_dot_files: bool) -> Iterable[str]:
                     yield str(path)
 
 
-@click.command()
+@click.command(name="lint")
 @click.argument(
     "schema",
     type=click.Path(exists=True, dir_okay=True, file_okay=True, resolve_path=True, path_type=Path),

linkml/transformers/logical_model_transformer.py

@@ -1,23 +1,67 @@
 """
-A model transformer that transforms a schema into logical form with inheritance remaoved.
+A model transformer that transforms a schema into logical form.
 
 Formally, this transformer generates a logical model of the schema in which inheritance
-of slots/attributes is replaced by boolean conjunctions.
+of slots/attributes is replaced by boolean conjunctions, and the final form is simplified.
+
+For example, given a slot `s`:
+
+```
+slots:
+  s:
+    range: integer
+    minimum_value: 1
+```
+
+Which is reused and refined by C and C (where C is_a D):
+
+```
+classes:
+  D:
+    slots:
+     - s
+    slot_usage:
+      s:
+         minimum_value: 2
+  C:
+    is_a: D
+    slot_usage:
+      s:
+        minimum_value: 3
+```
+
+The hierarchy unrolling step will create an attribute `s` for C that is the conjunction of usages for that
+class, ancestors, and the base slot:
+
+```
+s:
+    range: integer
+    all_of:
+        - minimum_value: 1
+        - minimum_value: 2
+        - minimum_value: 3
+```
+
+This is then simplified using symbolic reasoning to:
+
+```
+s:
+    range: integer
+    minimum_value: 3
+```
+
+See logictools.py for the symbolic reasoning engine.
+
 
-For example, given a slot s and two classes C and D, where C is_a D. If both C and D
-place constraints on s (for example, C may refine the range, or make more restricted
-value constraints), then an attribute is generated for C that for which the conjunction
-of constraints in both classes hold.
 
-These logical constraints are then simplified by translating to disjunctive normal form,
-and applying simplification rules.
 """
 
 import logging
 from copy import deepcopy
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, Iterator, List, Union
+from typing import Any, Callable, Dict, Iterator, List, Optional, Union
 
+from linkml_runtime import SchemaView
 from linkml_runtime.dumpers import json_dumper
 from linkml_runtime.linkml_model import ClassDefinitionName, SchemaDefinition
 from linkml_runtime.linkml_model.meta import (
@@ -37,6 +81,8 @@ HERITABLE_METASLOT = [
     "range_expression",
     "minimum_value",
     "maximum_value",
+    "minimum_cardinality",
+    "maximum_cardinality",
     "pattern",
     "structured_pattern",
     "required",
@@ -64,6 +110,8 @@ DIRECT_ROLL_DOWN = ["multivalued", "key", "identifier", "designates_type"]
 HERITABLE_TYPE_METASLOT = [
     "minimum_value",
     "maximum_value",
+    # "minimum_cardinality",
+    # "maximum_cardinality",
     "pattern",
     "structured_pattern",
     "all_of",
@@ -103,6 +151,7 @@ class LogicalModelTransformer(ModelTransformer):
     >>> _ = sb.add_class("Person", slots={"age": {"range": "integer"}}, is_a="Thing")
     >>> _ = sb.add_class("Organization", slots={"category": {"range": "OrganizationType"}}, is_a="Thing")
     >>> _ = sb.add_enum("OrganizationType", ["commercial", "non-profit"])
+    >>> _ = sb.add_defaults()
     >>> from linkml.transformers.logical_model_transformer import LogicalModelTransformer
     >>> tr = LogicalModelTransformer()
     >>> tr.set_schema(sb.schema)
@@ -113,8 +162,10 @@ class LogicalModelTransformer(ModelTransformer):
     attributes:
       id:
         name: id
+        range: string
       name:
         name: name
+        range: string
       age:
         name: age
         range: integer
@@ -142,6 +193,10 @@ class LogicalModelTransformer(ModelTransformer):
 
     ...
 
+    This has "compiled away" the hierarchy. The type of the values of 'entities' for Container can
+    be checked against the any_of expression, without needing to know the full class hierarchy.
+    This is useful when compiling to a framework that does not support inheritance.
+
     If you are compiling to a framework that does have inheritance, then you can specify that these are
     preserved:
 
@@ -173,6 +228,9 @@ class LogicalModelTransformer(ModelTransformer):
         name: entities2
         multivalued: true
         any_of:
+        - range: Organization
+        - range: Person
+
     ...
 
     Note that defaults are always applied after reasoning. So if you set a default_range to
@@ -211,6 +269,10 @@ class LogicalModelTransformer(ModelTransformer):
     minimum_value: 40
     maximum_value: 60
 
+    Here the slot-level constraints seem to have been "overridden". In fact, LinkML is monotonic, and there
+    is no overriding. In fact the constraints have been combined as a conjunction (And), and then the resulting
+    entailed attribute has been *simplified* (age >= 40 & age >= 0 ==> age >= 40).
+
     The reasoning engine can also detect unsatisfiable constraints:
 
     >>> from linkml.transformers.logical_model_transformer import UnsatisfiableAttribute
@@ -227,6 +289,9 @@ class LogicalModelTransformer(ModelTransformer):
     Let's get rid of the problematic class:
 
     >>> del sb.schema.classes["YoungAdult"]
+
+    And try a different example - we will try and override the range of the age slot with a string:
+
     >>> _ = sb.add_class("Person2", is_a="Person", slot_usage={"age": {"range": "string"}})
     >>> tr.set_schema(sb.schema)
     >>> try:
@@ -237,8 +302,6 @@ class LogicalModelTransformer(ModelTransformer):
     Attribute Person2.age is unsatisfiable
     <BLANKLINE>
 
-
-
     """
 
     preserve_class_is_a: bool = False
@@ -277,16 +340,24 @@ class LogicalModelTransformer(ModelTransformer):
     a lack of range assignment.
     """
 
-    def transform(self, tgt_schema_name: str = None, simplify=True, **kwargs) -> Any:
+    reason_over_metamodel_slots: Optional[List[str]] = None
+    """
+    If set, only reason over the specified metamodel slots.
+    """
+
+    def transform(self, tgt_schema_name: str = None, simplify=True, force_any_of=False, **kwargs) -> Any:
         """
-        Transform the schema to a logical model, translating inheritance to boolean expressions.
+        Transform the schema using logical reasoning, materializing entailed simple attributes.
 
         :param tgt_schema_name:
         :param simplify: If True (default), simplify the schema after transformation
+        :param force_any_of: If True, force the use of any_of expressions for range, even for singletons
         :return:
         """
         sv = self.schemaview
-        target_schema = deepcopy(self.source_schema)
+        target_schemaview = SchemaView(deepcopy(self.source_schema))
+        target_schemaview.merge_imports()
+        target_schema = target_schemaview.schema
         for tn, typ in target_schema.types.items():
             ancs = sv.type_ancestors(tn, reflexive=False)
             logging.debug(f"Unrolling type {tn}, merging {len(ancs)}")
@@ -312,7 +383,7 @@ class LogicalModelTransformer(ModelTransformer):
             self._roll_down(target_schema, cn, ancs)
         self.apply_defaults(target_schema)
         if simplify:
-            self.simplify(target_schema)
+            self.simplify(target_schema, force_any_of=force_any_of)
         if self.tidy_slots:
             target_schema.slots = {}
         if self.tidy_inheritance:
@@ -366,7 +437,8 @@ class LogicalModelTransformer(ModelTransformer):
         :return:
         """
         new_slot_dict = {}
-        for p in HERITABLE_METASLOT:
+        heritable_metaslots = self.reason_over_metamodel_slots or HERITABLE_METASLOT
+        for p in heritable_metaslots:
             pv = getattr(source, p)
             if pv is not None and pv != [] and pv != {} and pv is not False:
                 new_slot_dict[p] = pv
@@ -377,7 +449,7 @@ class LogicalModelTransformer(ModelTransformer):
         sv = self.schemaview
         if source.range in sv.all_types():
             typ = sv.get_type(source.range)
-            for p in set(HERITABLE_TYPE_METASLOT).intersection(HERITABLE_METASLOT):
+            for p in set(HERITABLE_TYPE_METASLOT).intersection(heritable_metaslots):
                 pv = getattr(typ, p)
                 if pv is not None and pv != [] and pv != {} and pv is not False:
                     new_slot_dict[p] = pv
@@ -395,6 +467,9 @@ class LogicalModelTransformer(ModelTransformer):
         """
         new_slot_dict = {}
         for p in HERITABLE_TYPE_METASLOT:
+            if p in ["repr"]:
+                # not on anonymous types
+                continue
             pv = getattr(source, p)
             if pv is not None and pv != [] and pv != {} and pv is not False:
                 new_slot_dict[p] = pv
@@ -431,7 +506,7 @@ class LogicalModelTransformer(ModelTransformer):
         for sx in att.all_of + att.exactly_one_of + att.none_of + att.any_of:
             yield from self._collection_slot_expressions(sx, filter_function)
 
-    def simplify(self, target_schema: SchemaDefinition):
+    def simplify(self, target_schema: SchemaDefinition, force_any_of=False):
         for cls in target_schema.classes.values():
             for att in cls.attributes.values():
                 x = self._as_logical_expression(att)
@@ -441,6 +516,9 @@ class LogicalModelTransformer(ModelTransformer):
                 if logictools.is_contradiction(x):
                     raise UnsatisfiableAttribute(f"Attribute {cls.name}.{att.name} is unsatisfiable")
                 self._simplify_member_ofs(x)
+                if force_any_of:
+                    if not isinstance(x, logictools.Or):
+                        x = logictools.Or(x)
                 logger.debug(f"Simplified member of: {x}")
                 simplified_att = self._from_logical_expression(x)
                 for k, v in simplified_att.__dict__.items():
@@ -524,6 +602,10 @@ class LogicalModelTransformer(ModelTransformer):
     def _value_var(self) -> logictools.Variable:
         return logictools.Variable("value")
 
+    @property
+    def _length_var(self) -> logictools.Variable:
+        return logictools.Variable("length")
+
     @property
     def _type_var(self) -> logictools.Variable:
         return logictools.Variable("type")
@@ -535,10 +617,15 @@ class LogicalModelTransformer(ModelTransformer):
         exprs = []
         value_var = self._value_var
         type_var = self._type_var
+        length_var = self._length_var
         if slot_expression.minimum_value is not None:
             exprs.append(value_var >= slot_expression.minimum_value)
         if slot_expression.maximum_value is not None:
             exprs.append(value_var <= slot_expression.maximum_value)
+        if slot_expression.minimum_cardinality is not None:
+            exprs.append(length_var >= slot_expression.minimum_cardinality)
+        if slot_expression.maximum_cardinality is not None:
+            exprs.append(length_var <= slot_expression.maximum_cardinality)
         if slot_expression.pattern is not None:
             exprs.append(logictools.Term(MATCHES_PREDICATE, value_var, slot_expression.pattern))
         if slot_expression.range:
@@ -576,6 +663,7 @@ class LogicalModelTransformer(ModelTransformer):
                 "none_of",
                 "any_of",
             ]:
+                # already accounted for
                 continue
             v = getattr(slot_expression, p, None)
             if v is not None and v != [] and v != {}:
@@ -624,6 +712,17 @@ class LogicalModelTransformer(ModelTransformer):
                     return AnonymousSlotExpression(maximum_value=val - 1)
                 else:
                     raise ValueError(f"Unknown predicate {expr.predicate} for {var}")
+            elif var == self._length_var:
+                if expr.predicate == ">=":
+                    return AnonymousSlotExpression(minimum_cardinality=val)
+                elif expr.predicate == ">":
+                    return AnonymousSlotExpression(minimum_cardinality=val + 1)
+                elif expr.predicate == "<=":
+                    return AnonymousSlotExpression(maximum_cardinality=val)
+                elif expr.predicate == "<":
+                    return AnonymousSlotExpression(maximum_cardinality=val - 1)
+                else:
+                    raise ValueError(f"Unknown predicate {expr.predicate} for {var}")
             elif var == self._type_var:
                 if expr.predicate == "in":
                     if val == logictools.UniversalSet():

linkml/utils/converter.py

@@ -24,7 +24,7 @@ from linkml.utils.datautils import (
 )
 
 
-@click.command()
+@click.command(name="convert")
 @click.option("--module", "-m", help="Path to python datamodel module")
 @click.option("--output", "-o", help="Path to output file")
 @click.option(

linkml/utils/execute_tutorial.py

@@ -189,6 +189,8 @@ def parse_file_to_blocks(input) -> List[Block]:
 @click.version_option(__version__, "-V", "--version")
 def cli(inputs, directory):
     """
+    Execute a tutorial markdown file (eg. those in the /docs/intro/ directory) and
+    save the outputs in the given directory
 
     Example: