linkml 1.5.5__py3-none-any.whl → 1.5.7__py3-none-any.whl

linkml/generators/markdowngen.py

@@ -2,15 +2,19 @@ import os
 from contextlib import redirect_stdout
 from dataclasses import dataclass, field
 from io import StringIO
-from typing import Any, Callable, Dict, List, Optional, Set, TextIO, Union
+from typing import Any, Callable, Dict, List, Optional, Set, Union
 
 import click
 from jsonasobj2 import JsonObj, values
-from linkml_runtime.linkml_model.meta import (ClassDefinition,
-                                              ClassDefinitionName, Element,
-                                              EnumDefinition, SchemaDefinition,
-                                              SlotDefinition, SubsetDefinition,
-                                              TypeDefinition)
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    ClassDefinitionName,
+    Element,
+    EnumDefinition,
+    SlotDefinition,
+    SubsetDefinition,
+    TypeDefinition,
+)
 from linkml_runtime.utils.formatutils import be, camelcase, underscore
 
 from linkml._version import __version__
@@ -30,7 +34,7 @@ class MarkdownGenerator(Generator):
     The markdown is suitable for deployment as a MkDocs or Sphinx site
     """
 
-    #ClassVars
+    # ClassVars
     generatorname = os.path.basename(__file__)
     generatorversion = "0.2.1"
     directory_output = True
@@ -71,7 +75,7 @@ class MarkdownGenerator(Generator):
         if directory:
             os.makedirs(directory, exist_ok=True)
         elif image_dir:
-            raise ValueError(f"Image directory can only be used with '-d' option")
+            raise ValueError("Image directory can only be used with '-d' option")
         if image_dir:
             self.image_directory = os.path.join(directory, "images")
             if not noimages:
@@ -80,9 +84,7 @@ class MarkdownGenerator(Generator):
         if not self.no_types_dir:
             os.makedirs(os.path.join(directory, "types"), exist_ok=True)
 
-        with open(
-            self.exist_warning(directory, index_file), "w", encoding="UTF-8"
-        ) as ixfile:
+        with open(self.exist_warning(directory, index_file), "w", encoding="UTF-8") as ixfile:
             with redirect_stdout(ixfile):
                 self.frontmatter(f"{self.schema.name}")
                 self.para(
@@ -92,11 +94,7 @@ class MarkdownGenerator(Generator):
 
                 self.header(3, "Classes")
                 for cls in sorted(self.schema.classes.values(), key=lambda c: c.name):
-                    if (
-                        not cls.is_a
-                        and not cls.mixin
-                        and self.is_secondary_ref(cls.name)
-                    ):
+                    if not cls.is_a and not cls.mixin and self.is_secondary_ref(cls.name):
                         self.class_hier(cls)
 
                 self.header(3, "Mixins")
@@ -114,9 +112,7 @@ class MarkdownGenerator(Generator):
                     self.enum_hier(enu)
 
                 self.header(3, "Subsets")
-                for subset in sorted(
-                    self.schema.subsets.values(), key=lambda s: s.name
-                ):
+                for subset in sorted(self.schema.subsets.values(), key=lambda s: s.name):
                     self.bullet(self.subset_link(subset, use_desc=True), 0)
 
                 self.header(3, "Types")
@@ -131,14 +127,9 @@ class MarkdownGenerator(Generator):
                         else:
                             typ_typ = f"**{typ.base}**"
 
-                        self.bullet(
-                            self.type_link(
-                                typ, after_link=f" ({typ_typ})", use_desc=True
-                            )
-                        )
+                        self.bullet(self.type_link(typ, after_link=f" ({typ_typ})", use_desc=True))
 
     def visit_class(self, cls: ClassDefinition) -> bool:
-
         # allow client to relabel metamodel
         mixin_local_name = self.get_metamodel_slot_name("Mixin")
         class_local_name = self.get_metamodel_slot_name("Class")
@@ -146,9 +137,7 @@ class MarkdownGenerator(Generator):
         if self.gen_classes and cls.name not in self.gen_classes:
             return False
 
-        with open(
-            self.exist_warning(self.dir_path(cls)), "w", encoding="UTF-8"
-        ) as clsfile:
+        with open(self.exist_warning(self.dir_path(cls)), "w", encoding="UTF-8") as clsfile:
             with redirect_stdout(clsfile):
                 class_curi = self.namespaces.uri_or_curie_for(
                     str(self.namespaces._base), camelcase(cls.name)
@@ -164,9 +153,7 @@ class MarkdownGenerator(Generator):
                             directory=self.image_directory,
                             load_image=not self.noimages,
                         )
-                        img_url = os.path.join(
-                            "images", os.path.basename(yg.output_file_name)
-                        )
+                        img_url = os.path.join("images", os.path.basename(yg.output_file_name))
                     else:
                         yg = YumlGenerator(self)
                         img_url = (
@@ -219,9 +206,7 @@ class MarkdownGenerator(Generator):
                 self.header(2, "Attributes")
 
                 # List all of the slots that directly belong to the class
-                slot_list = [
-                    slot for slot in [self.schema.slots[sn] for sn in cls.slots]
-                ]
+                slot_list = [slot for slot in [self.schema.slots[sn] for sn in cls.slots]]
                 own_slots = [slot for slot in slot_list if cls.name in slot.domain_of]
                 if own_slots:
                     self.header(3, "Own")
@@ -232,9 +217,7 @@ class MarkdownGenerator(Generator):
                 # List all of the inherited slots
                 ancestors = set(self.ancestors(cls))
                 inherited_slots = [
-                    slot
-                    for slot in slot_list
-                    if set(slot.domain_of).intersection(ancestors)
+                    slot for slot in slot_list if set(slot.domain_of).intersection(ancestors)
                 ]
                 if inherited_slots:
                     self.header(3, "Inherited from " + cls.is_a + ":")
@@ -246,9 +229,7 @@ class MarkdownGenerator(Generator):
                 mixed_in_classes = set()
                 for mixin in cls.mixins:
                     mixed_in_classes.add(mixin)
-                    mixed_in_classes.update(
-                        set(self.ancestors(self.schema.classes[mixin]))
-                    )
+                    mixed_in_classes.update(set(self.ancestors(self.schema.classes[mixin])))
                 for slot in slot_list:
                     mixers = set(slot.domain_of).intersection(mixed_in_classes)
                     for mixer in mixers:
@@ -260,9 +241,7 @@ class MarkdownGenerator(Generator):
         return False
 
     def visit_type(self, typ: TypeDefinition) -> None:
-        with open(
-            self.exist_warning(self.dir_path(typ)), "w", encoding="UTF-8"
-        ) as typefile:
+        with open(self.exist_warning(self.dir_path(typ)), "w", encoding="UTF-8") as typefile:
             with redirect_stdout(typefile):
                 type_uri = typ.definition_uri
                 type_curie = self.namespaces.curie_for(type_uri)
@@ -278,12 +257,8 @@ class MarkdownGenerator(Generator):
                 self.element_properties(typ)
 
     def visit_slot(self, aliased_slot_name: str, slot: SlotDefinition) -> None:
-        with open(
-            self.exist_warning(self.dir_path(slot)), "w", encoding="UTF-8"
-        ) as slotfile:
+        with open(self.exist_warning(self.dir_path(slot)), "w", encoding="UTF-8") as slotfile:
             with redirect_stdout(slotfile):
-                import logging
-
                 slot_curie = self.namespaces.uri_or_curie_for(
                     str(self.namespaces._base), underscore(slot.name)
                 )
@@ -312,29 +287,26 @@ class MarkdownGenerator(Generator):
                         self.bullet(f"{self.class_link(rc)}")
                 if aliased_slot_name == "relation":
                     if slot.subproperty_of:
-                        self.bullet(
-                            f" reifies: {self.slot_link(slot.subproperty_of) if slot.subproperty_of in self.schema.slots else slot.subproperty_of}"
+                        reifies = (
+                            self.slot_link(slot.subproperty_of)
+                            if slot.subproperty_of in self.schema.slots
+                            else slot.subproperty_of
                         )
+                        self.bullet(f" reifies: {reifies}")
                 self.element_properties(slot)
 
     def visit_enum(self, enum: EnumDefinition) -> None:
-        with open(
-            self.exist_warning(self.dir_path(enum)), "w", encoding="UTF-8"
-        ) as enumfile:
+        with open(self.exist_warning(self.dir_path(enum)), "w", encoding="UTF-8") as enumfile:
             with redirect_stdout(enumfile):
                 enum_curie = self.namespaces.uri_or_curie_for(
                     str(self.namespaces._base), underscore(enum.name)
                 )
                 enum_uri = self.namespaces.uri_for(enum_curie)
-                self.element_header(
-                    obj=enum, name=enum.name, curie=enum_curie, uri=enum_uri
-                )
+                self.element_header(obj=enum, name=enum.name, curie=enum_curie, uri=enum_uri)
                 self.element_properties(enum)
 
     def visit_subset(self, subset: SubsetDefinition) -> None:
-        with open(
-            self.exist_warning(self.dir_path(subset)), "w", encoding="UTF-8"
-        ) as subsetfile:
+        with open(self.exist_warning(self.dir_path(subset)), "w", encoding="UTF-8") as subsetfile:
             with redirect_stdout(subsetfile):
                 curie = self.namespaces.uri_or_curie_for(
                     str(self.namespaces._base), underscore(subset.name)
@@ -367,7 +339,6 @@ class MarkdownGenerator(Generator):
                 self.element_properties(subset)
 
     def element_header(self, obj: Element, name: str, curie: str, uri: str) -> None:
-        simple_name = curie.split(":", 1)[1]
         if isinstance(obj, TypeDefinition):
             obj_type = "Type"
         elif isinstance(obj, ClassDefinition):
@@ -382,9 +353,7 @@ class MarkdownGenerator(Generator):
             obj_type = "Class"
 
         header_label = (
-            f"{obj_type}: ~~{name}~~ _(deprecated)_"
-            if obj.deprecated
-            else f"{obj_type}: {name}"
+            f"{obj_type}: ~~{name}~~ _(deprecated)_" if obj.deprecated else f"{obj_type}: {name}"
         )
         self.header(1, header_label)
 
@@ -413,7 +382,7 @@ class MarkdownGenerator(Generator):
         def enum_list(title: str, obj: EnumDefinition) -> None:
             # This data is from the enum provided in the YAML
             self.header(2, title)
-            print(f"| Text | Description | Meaning | Other Information |")
+            print("| Text | Description | Meaning | Other Information |")
             print("| :--- | :---: | :---: | ---: |")
 
             for item, item_info in obj.permissible_values.items():
@@ -507,11 +476,7 @@ class MarkdownGenerator(Generator):
             if isinstance(obj, EnumDefinition)
             else camelcase(obj.name)
         )
-        subdir = (
-            "/types"
-            if isinstance(obj, TypeDefinition) and not self.no_types_dir
-            else ""
-        )
+        subdir = "/types" if isinstance(obj, TypeDefinition) and not self.no_types_dir else ""
         return f"{self.directory}{subdir}/{filename}.md"
 
     def mappings(self, obj: Union[SlotDefinition, ClassDefinition]) -> None:
@@ -641,11 +606,7 @@ class MarkdownGenerator(Generator):
                 parent = self.schema.classes[obj.is_a]
             else:
                 parent = None
-            return (
-                ""
-                if parent and obj.description == parent.description
-                else obj.description
-            )
+            return "" if parent and obj.description == parent.description else obj.description
         return ""
 
     def _link(
@@ -668,9 +629,7 @@ class MarkdownGenerator(Generator):
         if obj is None or not self.is_secondary_ref(obj.name):
             return self.bbin(obj)
         if isinstance(obj, SlotDefinition):
-            link_name = (
-                (be(obj.domain) + "➞") if obj.alias else ""
-            ) + self.aliased_slot_name(obj)
+            link_name = ((be(obj.domain) + "➞") if obj.alias else "") + self.aliased_slot_name(obj)
             link_ref = underscore(obj.name)
         elif isinstance(obj, TypeDefinition):
             link_name = camelcase(obj.name)
@@ -825,25 +784,17 @@ class MarkdownGenerator(Generator):
 @click.command()
 @click.option("--dir", "-d", required=True, help="Output directory")
 @click.option("--classes", "-c", multiple=True, help="Class(es) to emit")
-@click.option(
-    "--map-fields", "-M", multiple=True, help="Map metamodel fields, e.g. slot=field"
-)
-@click.option(
-    "--img", "-i", is_flag=True, help="Download YUML images to 'image' directory"
-)
+@click.option("--map-fields", "-M", multiple=True, help="Map metamodel fields, e.g. slot=field")
+@click.option("--img", "-i", is_flag=True, help="Download YUML images to 'image' directory")
 @click.option("--index-file", "-I", help="Name of markdown file that holds index")
 @click.option("--noimages", is_flag=True, help="Do not (re-)generate images")
 @click.option("--noyuml", is_flag=True, help="Do not add yUML figures to pages")
-@click.option(
-    "--notypesdir", is_flag=True, help="Do not create a separate types directory"
-)
+@click.option("--notypesdir", is_flag=True, help="Do not create a separate types directory")
 @click.option("--warnonexist", is_flag=True, help="Warn if output file already exists")
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, map_fields, dir, img, index_file, notypesdir, warnonexist, **kwargs):
     """Generate markdown documentation of a LinkML model"""
-    gen = MarkdownGenerator(
-        yamlfile, no_types_dir=notypesdir, warn_on_exist=warnonexist, **kwargs
-    )
+    gen = MarkdownGenerator(yamlfile, no_types_dir=notypesdir, warn_on_exist=warnonexist, **kwargs)
     if map_fields is not None:
         gen.metamodel_name_map = {}
         for mf in map_fields:

linkml/generators/namespacegen.py

@@ -5,7 +5,6 @@ import click
 from linkml_runtime.utils.formatutils import be, split_line
 
 from linkml._version import __version__
-from linkml.generators import PYTHON_GEN_VERSION
 from linkml.generators.pythongen import PythonGenerator
 from linkml.utils.generator import shared_arguments
 
@@ -13,7 +12,7 @@ from linkml.utils.generator import shared_arguments
 @dataclass
 class NamespaceGenerator(PythonGenerator):
     generatorname = os.path.basename(__file__)
-    generatorversion = PYTHON_GEN_VERSION
+    generatorversion = "0.0.1"
     valid_formats = ["py"]
     visit_all_class_slots = False
 

linkml/generators/oocodegen.py

@@ -2,12 +2,16 @@ import abc
 import re
 import unicodedata
 from dataclasses import dataclass, field
-from typing import List, Optional, Dict
-
-from linkml_runtime.linkml_model.meta import (ClassDefinition,
-                                              EnumDefinition, EnumDefinitionName,
-                                              SchemaDefinition, SlotDefinition,
-                                              TypeDefinition)
+from typing import Dict, List, Optional
+
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    EnumDefinition,
+    EnumDefinitionName,
+    SchemaDefinition,
+    SlotDefinition,
+    TypeDefinition,
+)
 from linkml_runtime.utils.formatutils import camelcase, lcamelcase, underscore
 from linkml_runtime.utils.schemaview import SchemaView
 
@@ -67,7 +71,6 @@ class OOClass:
 
 @dataclass
 class OOCodeGenerator(Generator):
-
     # ClassVars
     java_style = True
     visit_all_class_slots = False
@@ -120,7 +123,7 @@ class OOCodeGenerator(Generator):
             return label
         else:
             # add an underscore if the value starts with a digit
-            label = re.sub("(?=^\d)", "number_", label)
+            label = re.sub(r"(?=^\d)", "number_", label)
 
             safe_label = ""
             for character in label:
@@ -128,33 +131,25 @@ class OOCodeGenerator(Generator):
 
             return safe_label
 
-    def generate_enums(
-        self, all_enums: Dict[EnumDefinitionName, EnumDefinition]
-    ) -> Dict:
+    def generate_enums(self, all_enums: Dict[EnumDefinitionName, EnumDefinition]) -> Dict:
         # TODO: make an explicit class to represent how an enum is passed to the template
         enums = {}
         for enum_name, enum_original in all_enums.items():
-            enum = {
-                "name": camelcase(enum_name),
-                "values": {}
-            }
+            enum = {"name": camelcase(enum_name), "values": {}}
 
             if hasattr(enum_original, "description"):
                 enum["description"] = enum_original.description
 
             for pv in enum_original.permissible_values.values():
                 label = self.generate_enum_label(pv.text)
-                val = {
-                    "label": label,
-                    "value": pv.text.replace('"', '\\"')
-                }
+                val = {"label": label, "value": pv.text.replace('"', '\\"')}
                 if hasattr(pv, "description"):
                     val["description"] = pv.description
-                else :
+                else:
                     val["description"] = None
 
                 enum["values"][label] = val
-                
+
             enums[enum_name] = enum
 
         return enums
@@ -170,12 +165,14 @@ class OOCodeGenerator(Generator):
         for cn in sv.all_classes(imports=False):
             c = sv.get_class(cn)
             safe_cn = camelcase(cn)
-            oodoc = OODocument(
-                name=safe_cn, package=self.package, source_schema=sv.schema
-            )
+            oodoc = OODocument(name=safe_cn, package=self.package, source_schema=sv.schema)
             docs.append(oodoc)
             ooclass = OOClass(
-                name=safe_cn, description=c.description, package=self.package, fields=[], source_class=c
+                name=safe_cn,
+                description=c.description,
+                package=self.package,
+                fields=[],
+                source_class=c,
             )
             # currently hardcoded for java style, one class per doc
             oodoc.classes = [ooclass]

linkml/generators/owlgen.py

@@ -6,18 +6,23 @@ import logging
 import os
 from dataclasses import dataclass, field
 from enum import Enum, unique
-from typing import List, Optional, Set, TextIO, Union
+from typing import Optional, TextIO, Union
 
 import click
-from linkml_runtime.linkml_model.meta import (ClassDefinition,
-                                              ClassDefinitionName, Definition,
-                                              Element, ElementName,
-                                              EnumDefinition,
-                                              EnumDefinitionName,
-                                              SchemaDefinition, SlotDefinition,
-                                              SlotDefinitionName,
-                                              TypeDefinition,
-                                              TypeDefinitionName)
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    ClassDefinitionName,
+    Definition,
+    Element,
+    ElementName,
+    EnumDefinition,
+    EnumDefinitionName,
+    SchemaDefinition,
+    SlotDefinition,
+    SlotDefinitionName,
+    TypeDefinition,
+    TypeDefinitionName,
+)
 from linkml_runtime.utils.formatutils import camelcase, underscore
 from rdflib import OWL, RDF, BNode, Graph, Literal, URIRef
 from rdflib.collection import Collection
@@ -28,7 +33,6 @@ from rdflib.plugin import plugins as rdflib_plugins
 from linkml import METAMODEL_NAMESPACE, METAMODEL_NAMESPACE_NAME
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
-from linkml.utils.schemaloader import SchemaLoader
 
 
 @unique
@@ -70,6 +74,7 @@ class OwlSchemaGenerator(Generator):
     valid_formats = ["owl", "ttl"] + [
         x.name for x in rdflib_plugins(None, rdflib_Parser) if "/" not in str(x.name)
     ]
+    file_extension = "owl"
     visits_are_sorted = True
     uses_schemaloader = True
     requires_metamodel = True
@@ -82,6 +87,7 @@ class OwlSchemaGenerator(Generator):
     graph: Optional[Graph] = None
     top_value_uri: Optional[URIRef] = None
     type_objects: bool = field(default_factory=lambda: True)
+    assert_equivalent_classes: bool = False
 
     def visit_schema(self, output: Optional[str] = None, **_):
         owl_id = self.schema.id
@@ -92,9 +98,7 @@ class OwlSchemaGenerator(Generator):
         for prefix in self.metamodel.schema.emit_prefixes:
             self.graph.bind(prefix, self.metamodel.namespaces[prefix])
         for pfx in self.schema.prefixes.values():
-            self.graph.namespace_manager.bind(
-                pfx.prefix_prefix, URIRef(pfx.prefix_reference)
-            )
+            self.graph.namespace_manager.bind(pfx.prefix_prefix, URIRef(pfx.prefix_reference))
 
         self.graph.add((base, RDF.type, OWL.Ontology))
         self._add_element_properties(base, self.schema)
@@ -112,9 +116,7 @@ class OwlSchemaGenerator(Generator):
         # add value placeholder
         if self.type_objects:
             # TODO: additional axioms, e.g. String subClassOf hasValue some string
-            self.top_value_uri = self.metamodel.namespaces[METAMODEL_NAMESPACE_NAME][
-                "topValue"
-            ]
+            self.top_value_uri = self.metamodel.namespaces[METAMODEL_NAMESPACE_NAME]["topValue"]
             self.graph.add((self.top_value_uri, RDF.type, OWL.DatatypeProperty))
             self.graph.add((self.top_value_uri, RDFS.label, Literal("value")))
 
@@ -198,7 +200,7 @@ class OwlSchemaGenerator(Generator):
                 k_curie = k
                 try:
                     k_uri = self.namespaces.uri_for(k_curie)
-                except ValueError as e:
+                except ValueError:
                     try:
                         k_uri = self.metamodel.namespaces.uri_for(k_curie)
                     except ValueError as me:
@@ -266,6 +268,13 @@ class OwlSchemaGenerator(Generator):
                             cls_uri,
                         )
                     )
+
+        if cls.class_uri and self.assert_equivalent_classes:
+            eq_class_uri = self.namespaces.uri_for(cls.class_uri)
+            if str(eq_class_uri) != cls.definition_uri:
+                self.graph.add((cls_uri, OWL.equivalentClass, eq_class_uri))
+                self.graph.remove((cls_uri, SKOS.exactMatch, eq_class_uri))
+
         # If defining slots, we generate an equivalentClass entry
         # equ_node = BNode()
         # self.graph.add((cls_uri, OWL.equivalentClass, equ_node))
@@ -317,7 +326,7 @@ class OwlSchemaGenerator(Generator):
             slot_uri = self.namespaces.uri_for(slot.slot_uri)
             if slot_uri == "rdf:type":
                 logging.warning(
-                    f"rdflib may have issues serializing rdf:type with turtle serializer"
+                    "rdflib may have issues serializing rdf:type with turtle serializer"
                 )
             if slot.required:
                 if slot.multivalued:
@@ -346,9 +355,7 @@ class OwlSchemaGenerator(Generator):
                 if slot.multivalued:
                     #    restriction(slot only type)
                     self.graph.add((slot_node, RDF.type, OWL.Restriction))
-                    self.graph.add(
-                        (slot_node, OWL.allValuesFrom, self._range_uri(slot))
-                    )
+                    self.graph.add((slot_node, OWL.allValuesFrom, self._range_uri(slot)))
                     self.graph.add((slot_node, OWL.onProperty, slot_uri))
                 else:
                     #    intersectionOf(restriction(slot only type) restriction(slot max 1 type))
@@ -370,13 +377,10 @@ class OwlSchemaGenerator(Generator):
         @param slot:
         @return:
         """
-        # determine if this is a slot that has been induced by slot_usage; if so the meaning of the slot is context-specific
-        # and should not be used for global properties
-        if (
-            slot.alias is not None
-            and slot.alias != slot.name
-            and slot.alias in self.schema.slots
-        ):
+        # determine if this is a slot that has been induced by slot_usage; if so
+        # the meaning of the slot is context-specific and should not be used for
+        # global properties
+        if slot.alias is not None and slot.alias != slot.name and slot.alias in self.schema.slots:
             logging.debug(
                 f"SKIPPING slot induced by slot_usage: {slot.alias} // {slot.name} // {slot}"
             )
@@ -492,9 +496,7 @@ class OwlSchemaGenerator(Generator):
                 g.add(
                     (
                         enum_uri,
-                        self.metamodel.namespaces[METAMODEL_NAMESPACE_NAME][
-                            "permissible_values"
-                        ],
+                        self.metamodel.namespaces[METAMODEL_NAMESPACE_NAME]["permissible_values"],
                         pv_uri,
                     )
                 )
@@ -512,8 +514,7 @@ class OwlSchemaGenerator(Generator):
             if k in metamodel.schema.slots:
                 defining_slot = self.metamodel.schema.slots[k]
                 if v is not None and (
-                    "owl" in defining_slot.in_subset
-                    or "OwlProfile" in defining_slot.in_subset
+                    "owl" in defining_slot.in_subset or "OwlProfile" in defining_slot.in_subset
                 ):
                     if isinstance(v, list):
                         ve = v
@@ -532,18 +533,12 @@ class OwlSchemaGenerator(Generator):
                             ),
                         ):
                             return
-                        if (
-                            k == "name"
-                            and isinstance(el, SlotDefinition)
-                            and el.alias is not None
-                        ):
+                        if k == "name" and isinstance(el, SlotDefinition) and el.alias is not None:
                             prop_uri = RDFS.label
                             e = el.alias
                         else:
                             prop_uri = URIRef(
-                                self.metamodel.namespaces.uri_for(
-                                    defining_slot.slot_uri
-                                )
+                                self.metamodel.namespaces.uri_for(defining_slot.slot_uri)
                             )
                         object = self._as_rdf_element(e, defining_slot)
                         if object is not None:
@@ -568,7 +563,7 @@ class OwlSchemaGenerator(Generator):
             elif element_name in self.metamodel.schema.enums:
                 return self._enum_uri(element_name)
         else:
-            logging.warning(f"Unknown range {defining_slot.range}")
+            logging.warning(f"Unknown range {parent_slot.range}")
             return None
 
     def _range_is_datatype(self, slot: SlotDefinition) -> bool:
@@ -613,9 +608,7 @@ class OwlSchemaGenerator(Generator):
 
     def _add_metamodel_class(self, cname: str) -> None:
         metac = self.metamodel.schema.classes[cname]
-        metac_uri = self.metamodel.namespaces[METAMODEL_NAMESPACE_NAME][
-            camelcase(metac.name)
-        ]
+        metac_uri = self.metamodel.namespaces[METAMODEL_NAMESPACE_NAME][camelcase(metac.name)]
         self.graph.add((metac_uri, RDF.type, OWL.Class))
         # self._add_element_properties(metac_uri, metac)
 
@@ -679,6 +672,12 @@ class OwlSchemaGenerator(Generator):
     show_default=True,
     help="Suffix to append to schema id to generate OWL Ontology IRI",
 )
+@click.option(
+    "--assert-equivalent-classes/--no-assert-equivalent-classes",
+    default=False,
+    show_default=True,
+    help="If true, add owl:equivalentClass between a class and a class_uri",
+)
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, metadata_profile: str, **kwargs):
     """Generate an OWL representation of a LinkML model
@@ -700,9 +699,9 @@ def cli(yamlfile, metadata_profile: str, **kwargs):
     else:
         metadata_profile = MetadataProfile.linkml
     print(
-        OwlSchemaGenerator(
-            yamlfile, metadata_profile=metadata_profile, **kwargs
-        ).serialize(**kwargs)
+        OwlSchemaGenerator(yamlfile, metadata_profile=metadata_profile, **kwargs).serialize(
+            **kwargs
+        )
     )