cognite-neat 0.88.0__py3-none-any.whl → 0.88.1__py3-none-any.whl

cognite/neat/graph/queries/_shared.py

@@ -160,7 +160,7 @@ def triples2dictionary(triples: Iterable[tuple[URIRef, URIRef, str | URIRef]]) -
         value: str
         uri: URIRef
 
-        id_, property_, value = remove_namespace_from_uri(*triple)  # type: ignore[misc]
+        id_, property_, value = remove_namespace_from_uri(triple)  # type: ignore[misc]
         uri = triple[0]
 
         if uri not in dictionary:

cognite/neat/graph/stores/_base.py

@@ -108,7 +108,7 @@ class NeatGraphStore:
 
     @classmethod
     def from_memory_store(cls, rules: InformationRules | None = None) -> "Self":
-        return cls(Graph(), rules)
+        return cls(Graph(identifier=DEFAULT_NAMESPACE), rules)
 
     @classmethod
     def from_sparql_store(
@@ -126,17 +126,17 @@ class NeatGraphStore:
             postAsEncoded=False,
             autocommit=False,
         )
-        graph = Graph(store=store)
+        graph = Graph(store=store, identifier=DEFAULT_NAMESPACE)
         return cls(graph, rules)
 
     @classmethod
     def from_oxi_store(cls, storage_dir: Path | None = None, rules: InformationRules | None = None) -> "Self":
         """Creates a NeatGraphStore from an Oxigraph store."""
         local_import("pyoxigraph", "oxi")
+        local_import("oxrdflib", "oxi")
+        import oxrdflib
         import pyoxigraph
 
-        from cognite.neat.graph.stores._oxrdflib import OxigraphStore
-
         # Adding support for both oxigraph in-memory and file-based storage
         for i in range(4):
             try:
@@ -149,8 +149,10 @@ class NeatGraphStore:
         else:
             raise Exception("Error initializing Oxigraph store")
 
-        graph = Graph(store=OxigraphStore(store=oxi_store))
-        graph.default_union = True
+        graph = Graph(
+            store=oxrdflib.OxigraphStore(store=oxi_store),
+            identifier=DEFAULT_NAMESPACE,
+        )
 
         return cls(graph, rules)
 
@@ -208,7 +210,8 @@ class NeatGraphStore:
         property_renaming_config = InformationAnalysis(self.rules).define_property_renaming_config(class_entity)
 
         for instance_id in instance_ids:
-            yield self.queries.describe(instance_id, property_renaming_config)
+            if res := self.queries.describe(instance_id, property_renaming_config):
+                yield res
 
     def _parse_file(
         self,
@@ -221,7 +224,7 @@ class NeatGraphStore:
         Args:
             filepath : File path to file containing graph data, by default None
             mime_type : MIME type of graph data, by default "application/rdf+xml"
-            add_base_iri : Add base IRI to graph, by default True
+            base_uri : Add base IRI to graph, by default True
         """
 
         # Oxigraph store, do not want to type hint this as it is an optional dependency
@@ -229,10 +232,15 @@ class NeatGraphStore:
 
             def parse_to_oxi_store():
                 local_import("pyoxigraph", "oxi")
-                from cognite.neat.graph.stores._oxrdflib import OxigraphStore
+                import pyoxigraph
 
-                cast(OxigraphStore, self.graph.store)._inner.bulk_load(str(filepath), mime_type, base_iri=base_uri)  # type: ignore[attr-defined]
-                cast(OxigraphStore, self.graph.store)._inner.optimize()  # type: ignore[attr-defined]
+                cast(pyoxigraph.Store, self.graph.store._store).bulk_load(
+                    str(filepath),
+                    mime_type,
+                    base_iri=base_uri,
+                    to_graph=pyoxigraph.NamedNode(self.graph.identifier),
+                )
+                cast(pyoxigraph.Store, self.graph.store._store).optimize()
 
             parse_to_oxi_store()
 

cognite/neat/graph/transformers/_rdfpath.py

@@ -1,4 +1,4 @@
-from rdflib import RDF, Graph
+from rdflib import Graph
 
 from cognite.neat.rules.analysis import InformationAnalysis
 from cognite.neat.rules.models._rdfpath import RDFPath, SingleProperty
@@ -17,6 +17,7 @@ class AddSelfReferenceProperty(BaseTransformer):
     description: str = "Adds property that contains id of reference to all references of given class in Rules"
     _use_only_once: bool = True
     _need_changes = frozenset({})
+    _ref_template: str = """SELECT ?s WHERE {{?s a <{type_}>}}"""
 
     def __init__(
         self,
@@ -32,7 +33,7 @@ class AddSelfReferenceProperty(BaseTransformer):
 
             namespace = self.rules.prefixes[prefix] if prefix in self.rules.prefixes else self.rules.metadata.namespace
 
-            for reference in graph.subjects(RDF.type, namespace[suffix]):
+            for (reference,) in graph.query(self._ref_template.format(type_=namespace[suffix])):  # type: ignore [misc]
                 graph.add(
                     (
                         reference,

cognite/neat/issues.py

@@ -9,6 +9,7 @@ from typing import Any, ClassVar, TypeVar
 from warnings import WarningMessage
 
 import pandas as pd
+from pydantic_core import PydanticCustomError
 
 if sys.version_info < (3, 11):
     from exceptiongroup import ExceptionGroup
@@ -56,6 +57,13 @@ class NeatError(NeatIssue, ABC):
     def as_exception(self) -> ValueError:
         return ValueError(self.message())
 
+    def as_pydantic_exception(self) -> PydanticCustomError:
+        return PydanticCustomError(
+            self.__class__.__name__,
+            self.message(),
+            dict(description=self.description, fix=self.fix),
+        )
+
 
 @dataclass(frozen=True)
 class NeatWarning(NeatIssue, ABC, UserWarning):

cognite/neat/rules/exporters/_rules2ontology.py

@@ -9,8 +9,19 @@ from rdflib import DCTERMS, OWL, RDF, RDFS, XSD, BNode, Graph, Literal, Namespac
 from rdflib.collection import Collection as GraphCollection
 
 from cognite.neat.constants import DEFAULT_NAMESPACE as NEAT_NAMESPACE
-from cognite.neat.rules import exceptions
 from cognite.neat.rules.analysis import InformationAnalysis
+from cognite.neat.rules.issues.ontology import (
+    MetadataSheetNamespaceNotDefinedError,
+    MissingDataModelPrefixOrNamespaceWarning,
+    OntologyMultiDefinitionPropertyWarning,
+    OntologyMultiDomainPropertyWarning,
+    OntologyMultiLabeledPropertyWarning,
+    OntologyMultiRangePropertyWarning,
+    OntologyMultiTypePropertyWarning,
+    PrefixMissingError,
+    PropertiesDefinedMultipleTimesError,
+    PropertyDefinitionsNotForSamePropertyError,
+)
 from cognite.neat.rules.models import DMSRules
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
@@ -102,13 +113,15 @@ class Ontology(OntologyModel):
 
         properties_redefined, redefinition_warnings = are_properties_redefined(rules, return_report=True)
         if properties_redefined:
-            raise exceptions.PropertiesDefinedMultipleTimes(report=generate_exception_report(redefinition_warnings))
+            raise PropertiesDefinedMultipleTimesError(
+                report=generate_exception_report(redefinition_warnings)
+            ).as_exception()
 
         if rules.prefixes is None:
-            raise exceptions.PrefixMissing()
+            raise PrefixMissingError().as_exception()
 
         if rules.metadata.namespace is None:
-            raise exceptions.MissingDataModelPrefixOrNamespace()
+            raise MissingDataModelPrefixOrNamespaceWarning()
 
         class_dict = InformationAnalysis(rules).as_class_dict()
         return cls(
@@ -172,7 +185,7 @@ class Ontology(OntologyModel):
             owl.bind(prefix, namespace)
 
         if self.metadata.namespace is None:
-            raise exceptions.MetadataSheetNamespaceNotDefined()
+            raise MetadataSheetNamespaceNotDefinedError().as_exception()
 
         owl.add((URIRef(self.metadata.namespace), RDF.type, OWL.Ontology))
         for property_ in self.properties:
@@ -221,7 +234,7 @@ class OWLMetadata(InformationMetadata):
     def triples(self) -> list[tuple]:
         # Mandatory triples originating from Metadata mandatory fields
         if self.namespace is None:
-            raise exceptions.MetadataSheetNamespaceNotDefined()
+            raise MetadataSheetNamespaceNotDefinedError().as_exception()
         triples: list[tuple] = [
             (URIRef(self.namespace), DCTERMS.hasVersion, Literal(self.version)),
             (URIRef(self.namespace), OWL.versionInfo, Literal(self.version)),
@@ -319,7 +332,7 @@ class OWLProperty(OntologyModel):
         """Here list of properties is a list of properties with the same id, but different definitions."""
 
         if not cls.same_property_id(definitions):
-            raise exceptions.PropertyDefinitionsNotForSameProperty()
+            raise PropertyDefinitionsNotForSamePropertyError().as_exception()
 
         owl_property = cls.model_construct(
             id_=namespace[definitions[0].property_],
@@ -350,10 +363,9 @@ class OWLProperty(OntologyModel):
     def is_multi_type(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                exceptions.OntologyMultiTypeProperty(
+                OntologyMultiTypePropertyWarning(
                     remove_namespace_from_uri(info.data["id_"]), [remove_namespace_from_uri(t) for t in v]
-                ).message,
-                category=exceptions.OntologyMultiTypeProperty,
+                ),
                 stacklevel=2,
             )
         return v
@@ -362,10 +374,9 @@ class OWLProperty(OntologyModel):
     def is_multi_range(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                exceptions.OntologyMultiRangeProperty(
+                OntologyMultiRangePropertyWarning(
                     remove_namespace_from_uri(info.data["id_"]), [remove_namespace_from_uri(t) for t in v]
-                ).message,
-                category=exceptions.OntologyMultiRangeProperty,
+                ),
                 stacklevel=2,
             )
         return v
@@ -374,10 +385,9 @@ class OWLProperty(OntologyModel):
     def is_multi_domain(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                exceptions.OntologyMultiDomainProperty(
+                OntologyMultiDomainPropertyWarning(
                     remove_namespace_from_uri(info.data["id_"]), [remove_namespace_from_uri(t) for t in v]
-                ).message,
-                category=exceptions.OntologyMultiDomainProperty,
+                ),
                 stacklevel=2,
             )
         return v
@@ -386,8 +396,7 @@ class OWLProperty(OntologyModel):
     def has_multi_name(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                exceptions.OntologyMultiLabeledProperty(remove_namespace_from_uri(info.data["id_"]), v).message,
-                category=exceptions.OntologyMultiLabeledProperty,
+                OntologyMultiLabeledPropertyWarning(remove_namespace_from_uri(info.data["id_"]), v),
                 stacklevel=2,
             )
         return v
@@ -396,8 +405,7 @@ class OWLProperty(OntologyModel):
     def has_multi_comment(cls, v, info: ValidationInfo):
         if len(v) > 1:
             warnings.warn(
-                exceptions.OntologyMultiDefinitionProperty(remove_namespace_from_uri(info.data["id_"])).message,
-                category=exceptions.OntologyMultiDefinitionProperty,
+                OntologyMultiDefinitionPropertyWarning(remove_namespace_from_uri(info.data["id_"])),
                 stacklevel=2,
             )
         return v

cognite/neat/rules/exporters/_validation.py

@@ -1,11 +1,11 @@
-import re
 import warnings
 from typing import Literal, overload
 
 from cognite.neat.exceptions import wrangle_warnings
-from cognite.neat.rules import exceptions
+from cognite.neat.rules.issues.dms import EntityIDNotDMSCompliantWarning
+from cognite.neat.rules.issues.importing import PropertyRedefinedWarning
 from cognite.neat.rules.models import InformationRules
-from cognite.neat.rules.models._types._base import DMS_PROPERTY_ID_COMPLIANCE_REGEX, VIEW_ID_COMPLIANCE_REGEX
+from cognite.neat.utils.regex_patterns import DMS_PROPERTY_ID_COMPLIANCE_REGEX, PATTERNS, VIEW_ID_COMPLIANCE_REGEX
 
 
 @overload
@@ -26,35 +26,30 @@ def are_entity_names_dms_compliant(
     flag: bool = True
     with warnings.catch_warnings(record=True) as validation_warnings:
         for class_ in rules.classes:
-            if not re.match(VIEW_ID_COMPLIANCE_REGEX, str(class_.class_.suffix)):
+            if not PATTERNS.view_id_compliance.match(class_.class_.suffix):
                 warnings.warn(
-                    exceptions.EntityIDNotDMSCompliant(
-                        "Class", class_.class_.versioned_id, f"[Classes/Class/{class_.class_.versioned_id}]"
-                    ).message,
-                    category=exceptions.EntityIDNotDMSCompliant,
+                    EntityIDNotDMSCompliantWarning(class_.class_.versioned_id, "Class", VIEW_ID_COMPLIANCE_REGEX),
                     stacklevel=2,
                 )
                 flag = False
 
-        for row, property_ in enumerate(rules.properties):
+        for _, property_ in enumerate(rules.properties):
             # check class id which would resolve as view/container id
-            if not re.match(VIEW_ID_COMPLIANCE_REGEX, str(property_.class_.suffix)):
+            if not PATTERNS.view_id_compliance.match(property_.class_.suffix):
                 warnings.warn(
-                    exceptions.EntityIDNotDMSCompliant(
-                        "Class", property_.class_.versioned_id, f"[Properties/Class/{row}]"
-                    ).message,
-                    category=exceptions.EntityIDNotDMSCompliant,
+                    EntityIDNotDMSCompliantWarning(
+                        property_.class_.versioned_id,
+                        "Class",
+                        VIEW_ID_COMPLIANCE_REGEX,
+                    ),
                     stacklevel=2,
                 )
                 flag = False
 
             # check property id which would resolve as view/container id
-            if not re.match(DMS_PROPERTY_ID_COMPLIANCE_REGEX, property_.property_):
+            if not PATTERNS.dms_property_id_compliance.match(property_.property_):
                 warnings.warn(
-                    exceptions.EntityIDNotDMSCompliant(
-                        "Property", property_.property_, f"[Properties/Property/{row}]"
-                    ).message,
-                    category=exceptions.EntityIDNotDMSCompliant,
+                    EntityIDNotDMSCompliantWarning(property_.property_, "Property", DMS_PROPERTY_ID_COMPLIANCE_REGEX),
                     stacklevel=2,
                 )
                 flag = False
@@ -83,8 +78,7 @@ def are_properties_redefined(rules: InformationRules, return_report: bool = Fals
             elif property_.class_ in analyzed_properties[property_.property_]:
                 flag = True
                 warnings.warn(
-                    exceptions.PropertyRedefined(property_.property_, property_.class_.versioned_id).message,
-                    category=exceptions.EntityIDNotDMSCompliant,
+                    PropertyRedefinedWarning(property_.property_, property_.class_.versioned_id),
                     stacklevel=2,
                 )
 

cognite/neat/rules/importers/_owl2rules/_owl2metadata.py

@@ -1,16 +1,12 @@
 import datetime
-import re
 
 from rdflib import Graph, Namespace
 
 from cognite.neat.constants import DEFAULT_NAMESPACE
 from cognite.neat.rules.models import RoleTypes, SchemaCompleteness
-from cognite.neat.rules.models._types._base import (
-    PREFIX_COMPLIANCE_REGEX,
-    VERSION_COMPLIANCE_REGEX,
-)
 from cognite.neat.utils.collection_ import remove_none_elements_from_set
 from cognite.neat.utils.rdf_ import convert_rdflib_content
+from cognite.neat.utils.regex_patterns import PATTERNS
 
 
 def parse_owl_metadata(graph: Graph) -> dict:
@@ -144,7 +140,7 @@ def fix_description(metadata: dict, default: str = "This model has been inferred
 
 def fix_prefix(metadata: dict, default: str = "neat") -> dict:
     if prefix := metadata.get("prefix", None):
-        if not isinstance(prefix, str) or not re.match(PREFIX_COMPLIANCE_REGEX, prefix):
+        if not isinstance(prefix, str) or not PATTERNS.prefix_compliance.match(prefix):
             metadata["prefix"] = default
     else:
         metadata["prefix"] = default
@@ -189,7 +185,7 @@ def fix_date(
 
 def fix_version(metadata: dict, default: str = "1.0.0") -> dict:
     if version := metadata.get("version", None):
-        if not re.match(VERSION_COMPLIANCE_REGEX, version):
+        if not PATTERNS.version_compliance.match(version):
             metadata["version"] = default
     else:
         metadata["version"] = default

cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -131,25 +131,24 @@ class SpreadsheetReader:
         names = MANDATORY_SHEETS_BY_ROLE[role]
         return {f"{self._sheet_prefix}{sheet_name}" for sheet_name in names if sheet_name != "Metadata"}
 
-    def read(self, filepath: Path) -> None | ReadResult:
-        with pd.ExcelFile(filepath) as excel_file:
-            self._seen_files.add(filepath)
-            self._seen_sheets.update(map(str, excel_file.sheet_names))
-            metadata: MetadataRaw | None
-            if self.metadata is not None:
-                metadata = self.metadata
-            else:
-                metadata = self._read_metadata(excel_file, filepath)
-                if metadata is None:
-                    # The reading of metadata failed, so we can't continue
-                    return None
-
-            sheets, read_info_by_sheet = self._read_sheets(excel_file, metadata.role)
-            if sheets is None or self.issue_list.has_errors:
+    def read(self, excel_file: pd.ExcelFile, filepath: Path) -> None | ReadResult:
+        self._seen_files.add(filepath)
+        self._seen_sheets.update(map(str, excel_file.sheet_names))
+        metadata: MetadataRaw | None
+        if self.metadata is not None:
+            metadata = self.metadata
+        else:
+            metadata = self._read_metadata(excel_file, filepath)
+            if metadata is None:
+                # The reading of metadata failed, so we can't continue
                 return None
-            sheets["Metadata"] = dict(metadata)
 
-            return ReadResult(sheets, read_info_by_sheet, metadata)
+        sheets, read_info_by_sheet = self._read_sheets(excel_file, metadata.role)
+        if sheets is None or self.issue_list.has_errors:
+            return None
+        sheets["Metadata"] = dict(metadata)
+
+        return ReadResult(sheets, read_info_by_sheet, metadata)
 
     def _read_metadata(self, excel_file: ExcelFile, filepath: Path) -> MetadataRaw | None:
         if self.metadata_sheet_name not in excel_file.sheet_names:
@@ -232,17 +231,21 @@ class ExcelImporter(BaseImporter):
             issue_list.append(issues.spreadsheet_file.SpreadsheetNotFoundError(self.filepath))
             return self._return_or_raise(issue_list, errors)
 
-        user_reader = SpreadsheetReader(issue_list)
-        user_read = user_reader.read(self.filepath)
-        if user_read is None or issue_list.has_errors:
-            return self._return_or_raise(issue_list, errors)
+        with pd.ExcelFile(self.filepath) as excel_file:
+            user_reader = SpreadsheetReader(issue_list)
 
-        last_read: ReadResult | None = None
-        if any(sheet_name.startswith("Last") for sheet_name in user_reader.seen_sheets):
-            last_read = SpreadsheetReader(issue_list, required=False, sheet_prefix="Last").read(self.filepath)
-        reference_read: ReadResult | None = None
-        if any(sheet_name.startswith("Ref") for sheet_name in user_reader.seen_sheets):
-            reference_read = SpreadsheetReader(issue_list, sheet_prefix="Ref").read(self.filepath)
+            user_read = user_reader.read(excel_file, self.filepath)
+            if user_read is None or issue_list.has_errors:
+                return self._return_or_raise(issue_list, errors)
+
+            last_read: ReadResult | None = None
+            if any(sheet_name.startswith("Last") for sheet_name in user_reader.seen_sheets):
+                last_read = SpreadsheetReader(issue_list, required=False, sheet_prefix="Last").read(
+                    excel_file, self.filepath
+                )
+            reference_read: ReadResult | None = None
+            if any(sheet_name.startswith("Ref") for sheet_name in user_reader.seen_sheets):
+                reference_read = SpreadsheetReader(issue_list, sheet_prefix="Ref").read(excel_file, self.filepath)
 
         if issue_list.has_errors:
             return self._return_or_raise(issue_list, errors)

cognite/neat/rules/issues/dms.py

@@ -432,6 +432,26 @@ class ChangingViewError(DMSSchemaError):
         return output
 
 
+@dataclass(frozen=True)
+class EntityIDNotDMSCompliantWarning(DMSSchemaWarning):
+    description = "The entity ID, {entity_id} of type {entity_type}, is not DMS compliant. Violating regex {regex}"
+    fix = "Change the entity ID to be DMS compliant"
+    error_name: ClassVar[str] = "EntityIDNotDMSCompliantWarning"
+    entity_id: str
+    entity_type: str
+    regex: str
+
+    def message(self) -> str:
+        return self.description.format(entity_id=self.entity_id, entity_type=self.entity_type, regex=self.regex)
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["entity_id"] = self.entity_id
+        output["dms_type"] = self.entity_type
+        output["regex"] = self.regex
+        return output
+
+
 @dataclass(frozen=True)
 class EmptyContainerWarning(DMSSchemaWarning):
     description = "The container is empty"

cognite/neat/rules/issues/importing.py

@@ -126,6 +126,21 @@ class UnknownPropertyWarning(ValidationWarning):
         return f"{prefix} This will be ignored in the imports."
 
 
+@dataclass(frozen=True)
+class PropertyRedefinedWarning(ValidationWarning):
+    description = "Property, {property}, redefined in {class_}. This will be ignored in the imports."
+    fix = "Check if the property is defined only once."
+
+    property_id: str
+    class_id: str
+
+    def dump(self) -> dict[str, str]:
+        return {"property_id": self.property_id, "class_id": self.class_id}
+
+    def message(self) -> str:
+        return self.description.format(property=self.property_id, class_=self.class_id)
+
+
 @dataclass(frozen=True)
 class UnknownValueTypeWarning(ModelImportWarning):
     description = "Unknown value type. This limits validation done by NEAT. "