emmocheck

A module for testing an ontology against conventions defined for EMMO.

A YAML file can be provided with additional test configurations.

Example configuration file

test_unit_dimensions: exceptions: - myunits.MyUnitCategory1 - myunits.MyUnitCategory2

skip: - name_of_test_to_skip

enable: - name_of_test_to_enable

TestEMMOConventions

Base class for testing an ontology against EMMO conventions.

Source code in emmopy/emmocheck.py

class TestEMMOConventions(unittest.TestCase):
    """Base class for testing an ontology against EMMO conventions."""

    config = {}  # configurations

    def get_config(self, string, default=None):
        """Returns the configuration specified by `string`.

        If configuration is not found in the configuration file, `default` is
        returned.

        Sub-configurations can be accessed by separating the components with
        dots, like "test_namespace.exceptions".
        """
        result = self.config
        try:
            for token in string.split("."):
                result = result[token]
        except KeyError:
            return default
        return result

get_config(string, default=None)

Returns the configuration specified by string.

If configuration is not found in the configuration file, default is returned.

Sub-configurations can be accessed by separating the components with dots, like "test_namespace.exceptions".

Source code in emmopy/emmocheck.py

def get_config(self, string, default=None):
    """Returns the configuration specified by `string`.

    If configuration is not found in the configuration file, `default` is
    returned.

    Sub-configurations can be accessed by separating the components with
    dots, like "test_namespace.exceptions".
    """
    result = self.config
    try:
        for token in string.split("."):
            result = result[token]
    except KeyError:
        return default
    return result

TestFunctionalEMMOConventions

Test functional EMMO conventions.

Source code in emmopy/emmocheck.py

class TestFunctionalEMMOConventions(TestEMMOConventions):
    """Test functional EMMO conventions."""

    def test_unit_dimension(self):
        """Check that all measurement units have a physical dimension.

        Configurations:
            exceptions - full class names of classes to ignore.
        """
        exceptions = set(
            (
                "metrology.MultipleUnit",
                "metrology.SubMultipleUnit",
                "metrology.OffSystemUnit",
                "metrology.PrefixedUnit",
                "metrology.NonPrefixedUnit",
                "metrology.SpecialUnit",
                "metrology.DerivedUnit",
                "metrology.BaseUnit",
                "metrology.UnitSymbol",
                "siunits.SICoherentDerivedUnit",
                "siunits.SINonCoherentDerivedUnit",
                "siunits.SISpecialUnit",
                "siunits.SICoherentUnit",
                "siunits.SIPrefixedUnit",
                "siunits.SIBaseUnit",
                "siunits.SIUnitSymbol",
                "siunits.SIUnit",
                "emmo.MultipleUnit",
                "emmo.SubMultipleUnit",
                "emmo.OffSystemUnit",
                "emmo.PrefixedUnit",
                "emmo.NonPrefixedUnit",
                "emmo.SpecialUnit",
                "emmo.DerivedUnit",
                "emmo.BaseUnit",
                "emmo.UnitSymbol",
                "emmo.SICoherentDerivedUnit",
                "emmo.SINonCoherentDerivedUnit",
                "emmo.SISpecialUnit",
                "emmo.SICoherentUnit",
                "emmo.SIPrefixedUnit",
                "emmo.SIBaseUnit",
                "emmo.SIUnitSymbol",
                "emmo.SIUnit",
            )
        )
        if not hasattr(self.onto, "MeasurementUnit"):
            return
        exceptions.update(self.get_config("test_unit_dimension.exceptions", ()))
        regex = re.compile(
            r"^(emmo|metrology).hasPhysicalDimension.some\(.*\)$"
        )
        classes = set(self.onto.classes(self.check_imported))
        for cls in self.onto.MeasurementUnit.descendants():
            if not self.check_imported and cls not in classes:
                continue
            # Assume that actual units are not subclassed
            if not list(cls.subclasses()) and repr(cls) not in exceptions:
                with self.subTest(cls=cls, label=get_label(cls)):
                    self.assertTrue(
                        any(
                            regex.match(repr(r))
                            for r in cls.get_indirect_is_a()
                        ),
                        msg=cls,
                    )

    def test_quantity_dimension(self):
        """Check that all quantities have a physicalDimension annotation.

        Note: this test will be deprecated when isq is moved to emmo/domain.

        Configurations:
            exceptions - full class names of classes to ignore.
        """
        exceptions = set(
            (
                "properties.ModelledQuantitativeProperty",
                "properties.MeasuredQuantitativeProperty",
                "properties.ConventionalQuantitativeProperty",
                "metrology.QuantitativeProperty",
                "metrology.Quantity",
                "metrology.OrdinalQuantity",
                "metrology.BaseQuantity",
                "metrology.PhysicalConstant",
                "metrology.PhysicalQuantity",
                "metrology.ExactConstant",
                "metrology.MeasuredConstant",
                "metrology.DerivedQuantity",
                "isq.ISQBaseQuantity",
                "isq.InternationalSystemOfQuantity",
                "isq.ISQDerivedQuantity",
                "isq.SIExactConstant",
                "emmo.ModelledQuantitativeProperty",
                "emmo.MeasuredQuantitativeProperty",
                "emmo.ConventionalQuantitativeProperty",
                "emmo.QuantitativeProperty",
                "emmo.Quantity",
                "emmo.OrdinalQuantity",
                "emmo.BaseQuantity",
                "emmo.PhysicalConstant",
                "emmo.PhysicalQuantity",
                "emmo.ExactConstant",
                "emmo.MeasuredConstant",
                "emmo.DerivedQuantity",
                "emmo.ISQBaseQuantity",
                "emmo.InternationalSystemOfQuantity",
                "emmo.ISQDerivedQuantity",
                "emmo.SIExactConstant",
                "emmo.NonSIUnits",
                "emmo.StandardizedPhysicalQuantity",
                "emmo.CategorizedPhysicalQuantity",
                "emmo.AtomicAndNuclear",
                "emmo.Defined",
                "emmo.Electromagnetic",
                "emmo.FrequentlyUsed",
                "emmo.PhysicoChemical",
                "emmo.ChemicalCompositionQuantity",
                "emmo.Universal",
            )
        )
        if not hasattr(self.onto, "PhysicalQuantity"):
            return
        exceptions.update(
            self.get_config("test_quantity_dimension.exceptions", ())
        )
        regex = re.compile(
            "^T([+-][1-9]|0) L([+-][1-9]|0) M([+-][1-9]|0) I([+-][1-9]|0) "
            "(H|Θ)([+-][1-9]|0) N([+-][1-9]|0) J([+-][1-9]|0)$"
        )
        classes = set(self.onto.classes(self.check_imported))
        for cls in self.onto.PhysicalQuantity.descendants():
            if not self.check_imported and cls not in classes:
                continue
            if repr(cls) not in exceptions:
                with self.subTest(cls=cls, label=get_label(cls)):
                    anno = cls.get_annotations()
                    self.assertIn("physicalDimension", anno, msg=cls)
                    physdim = anno["physicalDimension"].first()
                    self.assertRegex(physdim, regex, msg=cls)

    def test_physical_quantity_dimension(self):
        """Check that all physical quantities have `hasPhysicalDimension`.

        Note: this test will fail before isq is moved to emmo/domain.

        Configurations:
            exceptions - full class names of classes to ignore.

        """
        exceptions = set(
            (
                "emmo.ModelledQuantitativeProperty",
                "emmo.MeasuredQuantitativeProperty",
                "emmo.ConventionalQuantitativeProperty",
                "emmo.QuantitativeProperty",
                "emmo.BaseQuantity",
                "emmo.PhysicalConstant",
                "emmo.PhysicalQuantity",
                "emmo.ExactConstant",
                "emmo.MeasuredConstant",
                "emmo.DerivedQuantity",
                "emmo.ISQBaseQuantity",
                "emmo.InternationalSystemOfQuantity",
                "emmo.ISQDerivedQuantity",
                "emmo.SIExactConstant",
                "emmo.NonSIUnits",
                "emmo.StandardizedPhysicalQuantity",
                "emmo.CategorizedPhysicalQuantity",
                "emmo.AtomicAndNuclearPhysicsQuantity",
                "emmo.ThermodynamicalQuantity",
                "emmo.LightAndRadiationQuantity",
                "emmo.SpaceAndTimeQuantity",
                "emmo.AcousticQuantity",
                "emmo.PhysioChememicalQuantity",
                "emmo.ElectromagneticQuantity",
                "emmo.MechanicalQuantity",
                "emmo.CondensedMatterPhysicsQuantity",
                "emmo.ChemicalCompositionQuantity",
                "emmo.Extensive",
                "emmo.Intensive",
            )
        )
        if not hasattr(self.onto, "PhysicalQuantity"):
            return
        exceptions.update(
            self.get_config("test_physical_quantity_dimension.exceptions", ())
        )
        classes = set(self.onto.classes(self.check_imported))
        for cls in self.onto.PhysicalQuantity.descendants():
            if not self.check_imported and cls not in classes:
                continue
            if repr(cls) not in exceptions:
                with self.subTest(cls=cls, label=get_label(cls)):
                    try:
                        class_props = cls.INDIRECT_get_class_properties()
                    except AttributeError:
                        # The INDIRECT_get_class_properties() method
                        # does not support inverse properties.  Build
                        # class_props manually...
                        class_props = set()
                        for _ in cls.mro():
                            if hasattr(_, "is_a"):
                                class_props.update(
                                    [
                                        restriction.property
                                        for restriction in _.is_a
                                        if isinstance(
                                            restriction, owlready2.Restriction
                                        )
                                    ]
                                )

                    self.assertIn(
                        self.onto.hasPhysicalDimension, class_props, msg=cls
                    )

    def test_namespace(self):
        """Check that all IRIs are namespaced after their (sub)ontology.

        Configurations:
            exceptions - full name of entities to ignore.
        """
        exceptions = set(
            (
                "owl.qualifiedCardinality",
                "owl.minQualifiedCardinality",
                "terms.creator",
                "terms.contributor",
                "terms.publisher",
                "terms.title",
                "terms.license",
                "terms.abstract",
                "core.prefLabel",
                "core.altLabel",
                "core.hiddenLabel",
                "mereotopology.Item",
                "manufacturing.EngineeredMaterial",
            )
        )
        exceptions.update(self.get_config("test_namespace.exceptions", ()))

        def checker(onto, ignore_namespace):
            if list(
                filter(onto.base_iri.strip("#").endswith, self.ignore_namespace)
            ):
                print(f"Skipping namespace: {onto.base_iri}")
                return
            entities = itertools.chain(
                onto.classes(),
                onto.object_properties(),
                onto.data_properties(),
                onto.individuals(),
                onto.annotation_properties(),
            )
            for entity in entities:
                if entity not in visited and repr(entity) not in exceptions:
                    visited.add(entity)
                    with self.subTest(
                        iri=entity.iri,
                        base_iri=onto.base_iri,
                        entity=repr(entity),
                    ):
                        self.assertTrue(
                            entity.iri.endswith(entity.name),
                            msg=(
                                "the final part of entity IRIs must be their "
                                "name"
                            ),
                        )
                        self.assertEqual(
                            entity.iri,
                            onto.base_iri + entity.name,
                            msg=(
                                f"IRI {entity.iri!r} does not correspond to "
                                f"module namespace: {onto.base_iri!r}"
                            ),
                        )

            if self.check_imported:
                for imp_onto in onto.imported_ontologies:
                    if imp_onto not in visited_onto:
                        visited_onto.add(imp_onto)
                        checker(imp_onto, ignore_namespace)

        visited = set()
        visited_onto = set()
        checker(self.onto, self.ignore_namespace)

test_namespace()

Check that all IRIs are namespaced after their (sub)ontology.

Configurations

exceptions - full name of entities to ignore.

Source code in emmopy/emmocheck.py

def test_namespace(self):
    """Check that all IRIs are namespaced after their (sub)ontology.

    Configurations:
        exceptions - full name of entities to ignore.
    """
    exceptions = set(
        (
            "owl.qualifiedCardinality",
            "owl.minQualifiedCardinality",
            "terms.creator",
            "terms.contributor",
            "terms.publisher",
            "terms.title",
            "terms.license",
            "terms.abstract",
            "core.prefLabel",
            "core.altLabel",
            "core.hiddenLabel",
            "mereotopology.Item",
            "manufacturing.EngineeredMaterial",
        )
    )
    exceptions.update(self.get_config("test_namespace.exceptions", ()))

    def checker(onto, ignore_namespace):
        if list(
            filter(onto.base_iri.strip("#").endswith, self.ignore_namespace)
        ):
            print(f"Skipping namespace: {onto.base_iri}")
            return
        entities = itertools.chain(
            onto.classes(),
            onto.object_properties(),
            onto.data_properties(),
            onto.individuals(),
            onto.annotation_properties(),
        )
        for entity in entities:
            if entity not in visited and repr(entity) not in exceptions:
                visited.add(entity)
                with self.subTest(
                    iri=entity.iri,
                    base_iri=onto.base_iri,
                    entity=repr(entity),
                ):
                    self.assertTrue(
                        entity.iri.endswith(entity.name),
                        msg=(
                            "the final part of entity IRIs must be their "
                            "name"
                        ),
                    )
                    self.assertEqual(
                        entity.iri,
                        onto.base_iri + entity.name,
                        msg=(
                            f"IRI {entity.iri!r} does not correspond to "
                            f"module namespace: {onto.base_iri!r}"
                        ),
                    )

        if self.check_imported:
            for imp_onto in onto.imported_ontologies:
                if imp_onto not in visited_onto:
                    visited_onto.add(imp_onto)
                    checker(imp_onto, ignore_namespace)

    visited = set()
    visited_onto = set()
    checker(self.onto, self.ignore_namespace)

test_physical_quantity_dimension()

Check that all physical quantities have hasPhysicalDimension.

Note: this test will fail before isq is moved to emmo/domain.

Configurations

exceptions - full class names of classes to ignore.

Source code in emmopy/emmocheck.py

def test_physical_quantity_dimension(self):
    """Check that all physical quantities have `hasPhysicalDimension`.

    Note: this test will fail before isq is moved to emmo/domain.

    Configurations:
        exceptions - full class names of classes to ignore.

    """
    exceptions = set(
        (
            "emmo.ModelledQuantitativeProperty",
            "emmo.MeasuredQuantitativeProperty",
            "emmo.ConventionalQuantitativeProperty",
            "emmo.QuantitativeProperty",
            "emmo.BaseQuantity",
            "emmo.PhysicalConstant",
            "emmo.PhysicalQuantity",
            "emmo.ExactConstant",
            "emmo.MeasuredConstant",
            "emmo.DerivedQuantity",
            "emmo.ISQBaseQuantity",
            "emmo.InternationalSystemOfQuantity",
            "emmo.ISQDerivedQuantity",
            "emmo.SIExactConstant",
            "emmo.NonSIUnits",
            "emmo.StandardizedPhysicalQuantity",
            "emmo.CategorizedPhysicalQuantity",
            "emmo.AtomicAndNuclearPhysicsQuantity",
            "emmo.ThermodynamicalQuantity",
            "emmo.LightAndRadiationQuantity",
            "emmo.SpaceAndTimeQuantity",
            "emmo.AcousticQuantity",
            "emmo.PhysioChememicalQuantity",
            "emmo.ElectromagneticQuantity",
            "emmo.MechanicalQuantity",
            "emmo.CondensedMatterPhysicsQuantity",
            "emmo.ChemicalCompositionQuantity",
            "emmo.Extensive",
            "emmo.Intensive",
        )
    )
    if not hasattr(self.onto, "PhysicalQuantity"):
        return
    exceptions.update(
        self.get_config("test_physical_quantity_dimension.exceptions", ())
    )
    classes = set(self.onto.classes(self.check_imported))
    for cls in self.onto.PhysicalQuantity.descendants():
        if not self.check_imported and cls not in classes:
            continue
        if repr(cls) not in exceptions:
            with self.subTest(cls=cls, label=get_label(cls)):
                try:
                    class_props = cls.INDIRECT_get_class_properties()
                except AttributeError:
                    # The INDIRECT_get_class_properties() method
                    # does not support inverse properties.  Build
                    # class_props manually...
                    class_props = set()
                    for _ in cls.mro():
                        if hasattr(_, "is_a"):
                            class_props.update(
                                [
                                    restriction.property
                                    for restriction in _.is_a
                                    if isinstance(
                                        restriction, owlready2.Restriction
                                    )
                                ]
                            )

                self.assertIn(
                    self.onto.hasPhysicalDimension, class_props, msg=cls
                )

test_quantity_dimension()

Check that all quantities have a physicalDimension annotation.

Note: this test will be deprecated when isq is moved to emmo/domain.

Configurations

exceptions - full class names of classes to ignore.

Source code in emmopy/emmocheck.py

def test_quantity_dimension(self):
    """Check that all quantities have a physicalDimension annotation.

    Note: this test will be deprecated when isq is moved to emmo/domain.

    Configurations:
        exceptions - full class names of classes to ignore.
    """
    exceptions = set(
        (
            "properties.ModelledQuantitativeProperty",
            "properties.MeasuredQuantitativeProperty",
            "properties.ConventionalQuantitativeProperty",
            "metrology.QuantitativeProperty",
            "metrology.Quantity",
            "metrology.OrdinalQuantity",
            "metrology.BaseQuantity",
            "metrology.PhysicalConstant",
            "metrology.PhysicalQuantity",
            "metrology.ExactConstant",
            "metrology.MeasuredConstant",
            "metrology.DerivedQuantity",
            "isq.ISQBaseQuantity",
            "isq.InternationalSystemOfQuantity",
            "isq.ISQDerivedQuantity",
            "isq.SIExactConstant",
            "emmo.ModelledQuantitativeProperty",
            "emmo.MeasuredQuantitativeProperty",
            "emmo.ConventionalQuantitativeProperty",
            "emmo.QuantitativeProperty",
            "emmo.Quantity",
            "emmo.OrdinalQuantity",
            "emmo.BaseQuantity",
            "emmo.PhysicalConstant",
            "emmo.PhysicalQuantity",
            "emmo.ExactConstant",
            "emmo.MeasuredConstant",
            "emmo.DerivedQuantity",
            "emmo.ISQBaseQuantity",
            "emmo.InternationalSystemOfQuantity",
            "emmo.ISQDerivedQuantity",
            "emmo.SIExactConstant",
            "emmo.NonSIUnits",
            "emmo.StandardizedPhysicalQuantity",
            "emmo.CategorizedPhysicalQuantity",
            "emmo.AtomicAndNuclear",
            "emmo.Defined",
            "emmo.Electromagnetic",
            "emmo.FrequentlyUsed",
            "emmo.PhysicoChemical",
            "emmo.ChemicalCompositionQuantity",
            "emmo.Universal",
        )
    )
    if not hasattr(self.onto, "PhysicalQuantity"):
        return
    exceptions.update(
        self.get_config("test_quantity_dimension.exceptions", ())
    )
    regex = re.compile(
        "^T([+-][1-9]|0) L([+-][1-9]|0) M([+-][1-9]|0) I([+-][1-9]|0) "
        "(H|Θ)([+-][1-9]|0) N([+-][1-9]|0) J([+-][1-9]|0)$"
    )
    classes = set(self.onto.classes(self.check_imported))
    for cls in self.onto.PhysicalQuantity.descendants():
        if not self.check_imported and cls not in classes:
            continue
        if repr(cls) not in exceptions:
            with self.subTest(cls=cls, label=get_label(cls)):
                anno = cls.get_annotations()
                self.assertIn("physicalDimension", anno, msg=cls)
                physdim = anno["physicalDimension"].first()
                self.assertRegex(physdim, regex, msg=cls)

test_unit_dimension()

Check that all measurement units have a physical dimension.

Configurations

exceptions - full class names of classes to ignore.

Source code in emmopy/emmocheck.py

def test_unit_dimension(self):
    """Check that all measurement units have a physical dimension.

    Configurations:
        exceptions - full class names of classes to ignore.
    """
    exceptions = set(
        (
            "metrology.MultipleUnit",
            "metrology.SubMultipleUnit",
            "metrology.OffSystemUnit",
            "metrology.PrefixedUnit",
            "metrology.NonPrefixedUnit",
            "metrology.SpecialUnit",
            "metrology.DerivedUnit",
            "metrology.BaseUnit",
            "metrology.UnitSymbol",
            "siunits.SICoherentDerivedUnit",
            "siunits.SINonCoherentDerivedUnit",
            "siunits.SISpecialUnit",
            "siunits.SICoherentUnit",
            "siunits.SIPrefixedUnit",
            "siunits.SIBaseUnit",
            "siunits.SIUnitSymbol",
            "siunits.SIUnit",
            "emmo.MultipleUnit",
            "emmo.SubMultipleUnit",
            "emmo.OffSystemUnit",
            "emmo.PrefixedUnit",
            "emmo.NonPrefixedUnit",
            "emmo.SpecialUnit",
            "emmo.DerivedUnit",
            "emmo.BaseUnit",
            "emmo.UnitSymbol",
            "emmo.SICoherentDerivedUnit",
            "emmo.SINonCoherentDerivedUnit",
            "emmo.SISpecialUnit",
            "emmo.SICoherentUnit",
            "emmo.SIPrefixedUnit",
            "emmo.SIBaseUnit",
            "emmo.SIUnitSymbol",
            "emmo.SIUnit",
        )
    )
    if not hasattr(self.onto, "MeasurementUnit"):
        return
    exceptions.update(self.get_config("test_unit_dimension.exceptions", ()))
    regex = re.compile(
        r"^(emmo|metrology).hasPhysicalDimension.some\(.*\)$"
    )
    classes = set(self.onto.classes(self.check_imported))
    for cls in self.onto.MeasurementUnit.descendants():
        if not self.check_imported and cls not in classes:
            continue
        # Assume that actual units are not subclassed
        if not list(cls.subclasses()) and repr(cls) not in exceptions:
            with self.subTest(cls=cls, label=get_label(cls)):
                self.assertTrue(
                    any(
                        regex.match(repr(r))
                        for r in cls.get_indirect_is_a()
                    ),
                    msg=cls,
                )

TestSyntacticEMMOConventions

Test syntactic EMMO conventions.

Source code in emmopy/emmocheck.py

class TestSyntacticEMMOConventions(TestEMMOConventions):
    """Test syntactic EMMO conventions."""

    def test_number_of_labels(self):
        """Check that all entities have one and only one prefLabel.

        Use "altLabel" for synonyms.

        The only allowed exception is entities who's representation
        starts with "owl.".
        """
        exceptions = set(
            (
                "terms.license",
                "terms.abstract",
                "terms.contributor",
                "terms.creator",
                "terms.publisher",
                "terms.title",
                "core.prefLabel",
                "core.altLabel",
                "core.hiddenLabel",
            )
        )
        exceptions.update(
            self.get_config("test_number_of_labels.exceptions", ())
        )

        if (
            "prefLabel"
            in self.onto.world._props  # pylint: disable=protected-access
        ):
            for entity in self.onto.get_entities():
                if repr(entity) not in exceptions:
                    with self.subTest(
                        entity=entity,
                        label=get_label(entity),
                        prefLabels=entity.prefLabel,
                    ):
                        if not repr(entity).startswith("owl."):
                            self.assertTrue(hasattr(entity, "prefLabel"))
                            self.assertEqual(1, len(entity.prefLabel))
        else:
            self.fail("ontology has no prefLabel")

    def test_class_label(self):
        """Check that class labels are CamelCase and valid identifiers.

        For CamelCase, we are currently only checking that the labels
        start with upper case.
        """
        exceptions = set(
            (
                "0-manifold",  # not needed in 1.0.0-beta
                "1-manifold",
                "2-manifold",
                "3-manifold",
                "C++",
            )
        )
        exceptions.update(self.get_config("test_class_label.exceptions", ()))

        for cls in self.onto.classes(self.check_imported):
            for label in cls.label + getattr(cls, "prefLabel", []):
                if label not in exceptions:
                    with self.subTest(entity=cls, label=label):
                        self.assertTrue(label.isidentifier())
                        self.assertTrue(label[0].isupper())

    def test_object_property_label(self):
        """Check that object property labels are lowerCamelCase.

        Allowed exceptions: "EMMORelation"

        If they start with "has" or "is" they should be followed by a
        upper case letter.

        If they start with "is" they should also end with "Of".
        """
        exceptions = set(("EMMORelation",))
        exceptions.update(
            self.get_config("test_object_property_label.exceptions", ())
        )

        for obj_prop in self.onto.object_properties():
            if repr(obj_prop) not in exceptions:
                for label in obj_prop.label:
                    with self.subTest(entity=obj_prop, label=label):
                        self.assertTrue(
                            label[0].islower(), "label start with lowercase"
                        )
                        if label.startswith("has"):
                            self.assertTrue(
                                label[3].isupper(),
                                'what follows "has" must be ' "uppercase",
                            )
                        if label.startswith("is"):
                            self.assertTrue(
                                label[2].isupper(),
                                'what follows "is" must be ' "uppercase",
                            )
                            self.assertTrue(
                                label.endswith(("Of", "With")),
                                'should end with "Of" or "With"',
                            )

test_class_label()

Check that class labels are CamelCase and valid identifiers.

For CamelCase, we are currently only checking that the labels start with upper case.

Source code in emmopy/emmocheck.py

def test_class_label(self):
    """Check that class labels are CamelCase and valid identifiers.

    For CamelCase, we are currently only checking that the labels
    start with upper case.
    """
    exceptions = set(
        (
            "0-manifold",  # not needed in 1.0.0-beta
            "1-manifold",
            "2-manifold",
            "3-manifold",
            "C++",
        )
    )
    exceptions.update(self.get_config("test_class_label.exceptions", ()))

    for cls in self.onto.classes(self.check_imported):
        for label in cls.label + getattr(cls, "prefLabel", []):
            if label not in exceptions:
                with self.subTest(entity=cls, label=label):
                    self.assertTrue(label.isidentifier())
                    self.assertTrue(label[0].isupper())

test_number_of_labels()

Check that all entities have one and only one prefLabel.

Use "altLabel" for synonyms.

The only allowed exception is entities who's representation starts with "owl.".

Source code in emmopy/emmocheck.py

def test_number_of_labels(self):
    """Check that all entities have one and only one prefLabel.

    Use "altLabel" for synonyms.

    The only allowed exception is entities who's representation
    starts with "owl.".
    """
    exceptions = set(
        (
            "terms.license",
            "terms.abstract",
            "terms.contributor",
            "terms.creator",
            "terms.publisher",
            "terms.title",
            "core.prefLabel",
            "core.altLabel",
            "core.hiddenLabel",
        )
    )
    exceptions.update(
        self.get_config("test_number_of_labels.exceptions", ())
    )

    if (
        "prefLabel"
        in self.onto.world._props  # pylint: disable=protected-access
    ):
        for entity in self.onto.get_entities():
            if repr(entity) not in exceptions:
                with self.subTest(
                    entity=entity,
                    label=get_label(entity),
                    prefLabels=entity.prefLabel,
                ):
                    if not repr(entity).startswith("owl."):
                        self.assertTrue(hasattr(entity, "prefLabel"))
                        self.assertEqual(1, len(entity.prefLabel))
    else:
        self.fail("ontology has no prefLabel")

test_object_property_label()

Check that object property labels are lowerCamelCase.

Allowed exceptions: "EMMORelation"

If they start with "has" or "is" they should be followed by a upper case letter.

If they start with "is" they should also end with "Of".

Source code in emmopy/emmocheck.py

def test_object_property_label(self):
    """Check that object property labels are lowerCamelCase.

    Allowed exceptions: "EMMORelation"

    If they start with "has" or "is" they should be followed by a
    upper case letter.

    If they start with "is" they should also end with "Of".
    """
    exceptions = set(("EMMORelation",))
    exceptions.update(
        self.get_config("test_object_property_label.exceptions", ())
    )

    for obj_prop in self.onto.object_properties():
        if repr(obj_prop) not in exceptions:
            for label in obj_prop.label:
                with self.subTest(entity=obj_prop, label=label):
                    self.assertTrue(
                        label[0].islower(), "label start with lowercase"
                    )
                    if label.startswith("has"):
                        self.assertTrue(
                            label[3].isupper(),
                            'what follows "has" must be ' "uppercase",
                        )
                    if label.startswith("is"):
                        self.assertTrue(
                            label[2].isupper(),
                            'what follows "is" must be ' "uppercase",
                        )
                        self.assertTrue(
                            label.endswith(("Of", "With")),
                            'should end with "Of" or "With"',
                        )

main(argv=None)

Run all checks on ontology iri.

Default is 'http://emmo.info/emmo'.

Parameters:

Name	Type	Description	Default
argv	list	List of arguments, similar to sys.argv[1:]. Mainly for testing purposes, since it allows one to invoke the tool manually / through Python.	None

Source code in emmopy/emmocheck.py

def main(
    argv: list = None,
):  # pylint: disable=too-many-locals,too-many-branches,too-many-statements
    """Run all checks on ontology `iri`.

    Default is 'http://emmo.info/emmo'.

    Parameters:
        argv: List of arguments, similar to `sys.argv[1:]`.
            Mainly for testing purposes, since it allows one to invoke the tool
            manually / through Python.

    """
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("iri", help="File name or URI to the ontology to test.")
    parser.add_argument(
        "--database",
        "-d",
        metavar="FILENAME",
        default=":memory:",
        help=(
            "Load ontology from Owlready2 sqlite3 database. The `iri` argument"
            " should in this case be the IRI of the ontology you want to "
            "check."
        ),
    )
    parser.add_argument(
        "--local",
        "-l",
        action="store_true",
        help=(
            "Load imported ontologies locally.  Their paths are specified in "
            "Protègè catalog files or via the --path option.  The IRI should "
            "be a file name."
        ),
    )
    parser.add_argument(
        "--catalog-file",
        default="catalog-v001.xml",
        help=(
            "Name of Protègè catalog file in the same folder as the ontology. "
            "This option is used together with --local and defaults to "
            '"catalog-v001.xml".'
        ),
    )
    parser.add_argument(
        "--path",
        action="append",
        default=[],
        help=(
            "Paths where imported ontologies can be found. May be provided as "
            "a comma-separated string and/or with multiple --path options."
        ),
    )
    parser.add_argument(
        "--check-imported",
        "-i",
        action="store_true",
        help="Whether to check imported ontologies.",
    )
    parser.add_argument(
        "--verbose", "-v", action="store_true", help="Verbosity level."
    )
    parser.add_argument(
        "--configfile",
        "-c",
        help="A yaml file with additional test configurations.",
    )
    parser.add_argument(
        "--skip",
        "-s",
        action="append",
        default=[],
        help=(
            "Shell pattern matching tests to skip.  This option may be "
            "provided multiple times."
        ),
    )
    parser.add_argument(
        "--enable",
        "-e",
        action="append",
        default=[],
        help=(
            "Shell pattern matching tests to enable that have been skipped by "
            "default or in the config file.  This option may be provided "
            "multiple times."
        ),
    )
    parser.add_argument(  # deprecated, replaced by --no-catalog
        "--url-from-catalog",
        "-u",
        default=None,
        action="store_true",
        help="Get url from catalog file",
    )
    parser.add_argument(
        "--no-catalog",
        action="store_false",
        dest="url_from_catalog",
        default=None,
        help="Whether to not read catalog file even if it exists.",
    )
    parser.add_argument(
        "--ignore-namespace",
        "-n",
        action="append",
        default=[],
        help="Namespace to be ignored. Can be given multiple times",
    )

    # Options to pass forward to unittest
    parser.add_argument(
        "--buffer",
        "-b",
        dest="unittest",
        action="append_const",
        const="-b",
        help=(
            "The standard output and standard error streams are buffered "
            "during the test run. Output during a passing test is discarded. "
            "Output is echoed normally on test fail or error and is added to "
            "the failure messages."
        ),
    )
    parser.add_argument(
        "--catch",
        dest="unittest",
        action="append_const",
        const="-c",
        help=(
            "Control-C during the test run waits for the current test to end "
            "and then reports all the results so far. A second control-C "
            "raises the normal KeyboardInterrupt exception"
        ),
    )
    parser.add_argument(
        "--failfast",
        "-f",
        dest="unittest",
        action="append_const",
        const="-f",
        help="Stop the test run on the first error or failure.",
    )
    try:
        args = parser.parse_args(args=argv)
        sys.argv[1:] = args.unittest if args.unittest else []
        if args.verbose:
            sys.argv.append("-v")
    except SystemExit as exc:
        sys.exit(exc.code)  # Exit without traceback on invalid arguments

    # Append to onto_path
    for paths in args.path:
        for path in paths.split(","):
            if path not in onto_path:
                onto_path.append(path)

    # Load ontology
    world = World(filename=args.database)
    if args.database != ":memory:" and args.iri not in world.ontologies:
        parser.error(
            "The IRI argument should be one of the ontologies in "
            "the database:\n  " + "\n  ".join(world.ontologies.keys())
        )

    onto = world.get_ontology(args.iri)
    onto.load(
        only_local=args.local,
        url_from_catalog=args.url_from_catalog,
        catalog_file=args.catalog_file,
    )

    # Store settings TestEMMOConventions
    TestEMMOConventions.onto = onto
    TestEMMOConventions.check_imported = args.check_imported
    TestEMMOConventions.ignore_namespace = args.ignore_namespace

    # Configure tests
    verbosity = 2 if args.verbose else 1
    if args.configfile:
        import yaml  # pylint: disable=import-outside-toplevel

        with open(args.configfile, "rt") as handle:
            TestEMMOConventions.config.update(
                yaml.load(handle, Loader=yaml.SafeLoader)
            )

    # Run all subclasses of TestEMMOConventions as test suites
    status = 0
    for cls in TestEMMOConventions.__subclasses__():
        # pylint: disable=cell-var-from-loop,undefined-loop-variable

        suite = unittest.TestLoader().loadTestsFromTestCase(cls)

        # Mark tests to be skipped
        for test in suite:
            name = test.id().split(".")[-1]
            skipped = set(  # skipped by default
                [
                    "test_namespace",
                    "test_physical_quantity_dimension",
                ]
            )
            msg = {name: "skipped by default" for name in skipped}

            # enable/skip tests from config file
            for pattern in test.get_config("enable", ()):
                if fnmatch.fnmatchcase(name, pattern):
                    skipped.remove(name)
            for pattern in test.get_config("skip", ()):
                if fnmatch.fnmatchcase(name, pattern):
                    skipped.add(name)
                    msg[name] = "skipped from config file"

            # enable/skip from command line
            for pattern in args.enable:
                if fnmatch.fnmatchcase(name, pattern):
                    skipped.remove(name)
            for pattern in args.skip:
                if fnmatch.fnmatchcase(name, pattern):
                    skipped.add(name)
                    msg[name] = "skipped from command line"

            if name in skipped:
                setattr(test, "setUp", lambda: test.skipTest(msg.get(name, "")))

        runner = TextTestRunner(verbosity=verbosity)
        runner.resultclass.checkmode = True
        result = runner.run(suite)
        if result.failures:
            status = 1

    return status