cognite-neat 0.88.2__py3-none-any.whl → 0.88.3__py3-none-any.whl

cognite/neat/rules/importers/_dms2rules.py

@@ -19,14 +19,13 @@ from cognite.client.data_classes.data_modeling.views import (
 from cognite.client.utils import ms_to_datetime
 
 from cognite.neat.issues import IssueList, NeatIssue
-from cognite.neat.issues.errors.resources import ResourceNotFoundError
-from cognite.neat.issues.neat_warnings.properties import (
+from cognite.neat.issues.errors import FileTypeUnexpectedError, ResourceMissingIdentifierError, ResourceRetrievalError
+from cognite.neat.issues.warnings import (
+    PropertyNotFoundWarning,
     PropertyTypeNotSupportedWarning,
-    ReferredPropertyNotFoundWarning,
+    ResourceNotFoundWarning,
 )
-from cognite.neat.issues.neat_warnings.resources import ReferredResourceNotFoundWarning
-from cognite.neat.rules import issues
-from cognite.neat.rules.importers._base import BaseImporter, Rules, _handle_issues
+from cognite.neat.rules.importers._base import BaseImporter, VerifiedRules, _handle_issues
 from cognite.neat.rules.models import (
     DataModelType,
     DMSRules,
@@ -109,9 +108,9 @@ class DMSImporter(BaseImporter):
             return cls(
                 DMSSchema(),
                 [
-                    ResourceNotFoundError[dm.DataModelId](
+                    ResourceRetrievalError(
                         dm.DataModelId.load(reference_model_id),  # type: ignore[arg-type]
-                        "DataModel",
+                        "data model",
                         "Data Model is missing in CDF",
                     )
                 ],
@@ -124,8 +123,8 @@ class DMSImporter(BaseImporter):
                 return cls(
                     DMSSchema(),
                     [
-                        ResourceNotFoundError[dm.DataModelId](
-                            dm.DataModelId.load(reference_model_id), "DataModel", "Data Model is missing in CDF"
+                        ResourceRetrievalError(
+                            dm.DataModelId.load(reference_model_id), "data model", "Data Model is missing in CDF"
                         )
                     ],
                 )
@@ -198,29 +197,29 @@ class DMSImporter(BaseImporter):
     @classmethod
     def from_zip_file(cls, zip_file: str | Path) -> "DMSImporter":
         if Path(zip_file).suffix != ".zip":
-            return cls(DMSSchema(), [issues.fileread.InvalidFileFormatError(Path(zip_file), [".zip"])])
+            return cls(DMSSchema(), [FileTypeUnexpectedError(Path(zip_file), frozenset([".zip"]))])
         issue_list = IssueList()
         with _handle_issues(issue_list) as _:
             schema = DMSSchema.from_zip(zip_file)
         return cls(schema, issue_list)
 
     @overload
-    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
+    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> VerifiedRules: ...
 
     @overload
     def to_rules(
         self, errors: Literal["continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList]: ...
+    ) -> tuple[VerifiedRules | None, IssueList]: ...
 
     def to_rules(
         self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
         if self.issue_list.has_errors:
             # In case there were errors during the import, the to_rules method will return None
             return self._return_or_raise(self.issue_list, errors)
 
         if not self.root_schema.data_model:
-            self.issue_list.append(ResourceNotFoundError[str]("Unknown", "DataModel", "Identifier is missing"))
+            self.issue_list.append(ResourceMissingIdentifierError("data model", type(self.root_schema).__name__))
             return self._return_or_raise(self.issue_list, errors)
         model = self.root_schema.data_model
         with _handle_issues(
@@ -321,11 +320,11 @@ class DMSImporter(BaseImporter):
     ) -> DMSProperty | None:
         if isinstance(prop, dm.MappedPropertyApply) and prop.container not in self._all_containers_by_id:
             self.issue_list.append(
-                ReferredResourceNotFoundWarning[dm.ContainerId, dm.PropertyId](
+                ResourceNotFoundWarning[dm.ContainerId, dm.PropertyId](
                     dm.ContainerId.load(prop.container),
-                    "Container",
+                    "container",
                     view_entity.to_property_id(prop_id),
-                    "View Property",
+                    "view property",
                 )
             )
             return None
@@ -334,9 +333,7 @@ class DMSImporter(BaseImporter):
             and prop.container_property_identifier not in self._all_containers_by_id[prop.container].properties
         ):
             self.issue_list.append(
-                ReferredPropertyNotFoundWarning[dm.ContainerId, dm.ViewId](
-                    prop.container, "Container", view_entity.as_id(), "View", prop_id
-                ),
+                PropertyNotFoundWarning(prop.container, "container", prop_id, view_entity.as_id(), "view"),
             )
             return None
         if not isinstance(
@@ -348,7 +345,7 @@ class DMSImporter(BaseImporter):
             | MultiReverseDirectRelationApply,
         ):
             self.issue_list.append(
-                PropertyTypeNotSupportedWarning[dm.ViewId](view_entity.as_id(), "View", prop_id, type(prop).__name__)
+                PropertyTypeNotSupportedWarning[dm.ViewId](view_entity.as_id(), "view", prop_id, type(prop).__name__)
             )
             return None
 
@@ -414,7 +411,7 @@ class DMSImporter(BaseImporter):
                 return DataType.load(container_prop.type._type)
         else:
             self.issue_list.append(
-                PropertyTypeNotSupportedWarning[dm.ViewId](view_entity.as_id(), "View", prop_id, type(prop).__name__)
+                PropertyTypeNotSupportedWarning[dm.ViewId](view_entity.as_id(), "view", prop_id, type(prop).__name__)
             )
             return None
 
@@ -475,7 +472,7 @@ class DMSImporter(BaseImporter):
             else:
                 self.issue_list.append(
                     PropertyTypeNotSupportedWarning[dm.ContainerId](
-                        prop.container, "Container", prop_id, type(constraint_obj).__name__
+                        prop.container, "container", prop_id, type(constraint_obj).__name__
                     )
                 )
         return unique_constraints or None

cognite/neat/rules/importers/_dtdl2rules/dtdl_converter.py

@@ -2,10 +2,12 @@ from collections import Counter
 from collections.abc import Callable, Sequence
 
 from cognite.neat.issues import IssueList, NeatIssue
-from cognite.neat.issues.errors.properties import PropertyTypeNotSupportedError
-from cognite.neat.issues.errors.resources import MissingIdentifierError, ResourceNotFoundError
-from cognite.neat.issues.neat_warnings.properties import PropertyTypeNotSupportedWarning
-from cognite.neat.issues.neat_warnings.resources import ResourceTypeNotSupportedWarning
+from cognite.neat.issues.errors import (
+    PropertyTypeNotSupportedError,
+    ResourceMissingIdentifierError,
+    ResourceNotFoundError,
+)
+from cognite.neat.issues.warnings import PropertyTypeNotSupportedWarning, ResourceTypeNotSupportedWarning
 from cognite.neat.rules.importers._dtdl2rules.spec import (
     DTMI,
     Command,
@@ -78,8 +80,8 @@ class _DTDLConverter:
             convert_method(item, parent)
         else:
             self.issues.append(
-                ResourceTypeNotSupportedWarning[str](
-                    item.id_.model_dump() if item.id_ else item.display_name or "missing",
+                ResourceTypeNotSupportedWarning(
+                    item.identifier_with_fallback,
                     item.type,
                 ),
             )
@@ -134,8 +136,11 @@ class _DTDLConverter:
 
     def _missing_parent_warning(self, item: DTDLBaseWithName):
         self.issues.append(
-            ResourceNotFoundError[str](
-                (item.id_.model_dump() if item.id_ else item.display_name) or "missing", item.type, "parent missing"
+            ResourceNotFoundError(
+                "UNKNOWN",
+                "parent",
+                item.identifier_with_fallback,
+                item.type,
             )
         )
 
@@ -152,7 +157,7 @@ class _DTDLConverter:
         if item.request is None:
             self.issues.append(
                 ResourceTypeNotSupportedWarning[str](
-                    item.id_.model_dump() if item.id_ else item.display_name or "missing",
+                    item.identifier_with_fallback,
                     f"{item.type}.request",
                 ),
             )
@@ -206,8 +211,8 @@ class _DTDLConverter:
             else:
                 # Falling back to json
                 self.issues.append(
-                    MissingIdentifierError(
-                        "Unknown",
+                    ResourceMissingIdentifierError(
+                        "unknown",
                         item.target.model_dump(),
                     )
                 )
@@ -231,7 +236,7 @@ class _DTDLConverter:
     def convert_object(self, item: Object, _: str | None) -> None:
         if item.id_ is None:
             self.issues.append(
-                MissingIdentifierError(
+                ResourceMissingIdentifierError(
                     resource_type=item.type,
                     name=item.display_name,
                 )
@@ -272,8 +277,8 @@ class _DTDLConverter:
             return _DATA_TYPE_BY_NAME[input_type.casefold()]()
         elif isinstance(input_type, str):
             self.issues.append(
-                PropertyTypeNotSupportedError[str](
-                    (item.id_.model_dump() if item.id_ else item.display_name) or "missing",
+                PropertyTypeNotSupportedError(
+                    item.identifier_with_fallback,
                     item.type,
                     "schema",
                     input_type,
@@ -283,7 +288,7 @@ class _DTDLConverter:
         elif isinstance(input_type, Object | Interface):
             if input_type.id_ is None:
                 self.issues.append(
-                    MissingIdentifierError(
+                    ResourceMissingIdentifierError(
                         input_type.type,
                         input_type.display_name,
                     )
@@ -296,8 +301,8 @@ class _DTDLConverter:
         else:
             self.issues.append(
                 PropertyTypeNotSupportedWarning(
-                    item.id_.model_dump() if item.id_ else item.display_name or "missing",
-                    item.type,
+                    item.identifier_with_fallback,
+                    item.type,  # type: ignore[arg-type]
                     "schema",
                     input_type.type if input_type else "missing",
                 )

cognite/neat/rules/importers/_dtdl2rules/dtdl_importer.py

@@ -7,15 +7,20 @@ from typing import Literal, overload
 from pydantic import ValidationError
 
 from cognite.neat.issues import IssueList, NeatIssue
-from cognite.neat.rules import issues
-from cognite.neat.rules._shared import Rules
+from cognite.neat.issues.warnings import (
+    FileItemNotSupportedWarning,
+    FileMissingRequiredFieldWarning,
+    FileReadWarning,
+    FileTypeUnexpectedWarning,
+    NeatValueWarning,
+)
+from cognite.neat.rules._shared import VerifiedRules
 from cognite.neat.rules.importers._base import BaseImporter, _handle_issues
 from cognite.neat.rules.importers._dtdl2rules.dtdl_converter import _DTDLConverter
 from cognite.neat.rules.importers._dtdl2rules.spec import DTDL_CLS_BY_TYPE_BY_SPEC, DTDLBase, Interface
-from cognite.neat.rules.issues import ValidationIssue
 from cognite.neat.rules.models import InformationRules, RoleTypes, SchemaCompleteness, SheetList
 from cognite.neat.rules.models.information import InformationClass, InformationProperty
-from cognite.neat.utils.text import to_pascal
+from cognite.neat.utils.text import humanize_collection, to_pascal
 
 
 class DTDLImporter(BaseImporter):
@@ -46,11 +51,11 @@ class DTDLImporter(BaseImporter):
         self._schema_completeness = schema
 
     @classmethod
-    def _from_file_content(cls, file_content: str, filepath: Path) -> Iterable[DTDLBase | ValidationIssue]:
+    def _from_file_content(cls, file_content: str, filepath: Path) -> Iterable[DTDLBase | NeatIssue]:
         raw = json.loads(file_content)
         if isinstance(raw, dict):
             if (context := raw.get("@context")) is None:
-                yield issues.fileread.InvalidFileFormatWarning(filepath=filepath, reason="Missing '@context' key.")
+                yield FileMissingRequiredFieldWarning(filepath, "@context", "Missing '@context' key.")
                 return
             raw_list = [raw]
         elif isinstance(raw, list):
@@ -58,13 +63,11 @@ class DTDLImporter(BaseImporter):
                 (entry["@context"] for entry in raw if isinstance(entry, dict) and "@context" in entry), None
             )
             if context is None:
-                yield issues.fileread.InvalidFileFormatWarning(filepath=filepath, reason="Missing '@context' key.")
+                yield FileMissingRequiredFieldWarning(filepath, "@context", "Missing '@context' key.")
                 return
             raw_list = raw
         else:
-            yield issues.fileread.InvalidFileFormatWarning(
-                filepath=filepath, reason="Content is not an object or array."
-            )
+            yield FileTypeUnexpectedWarning(filepath, frozenset(["dict", "list"]), "Content is not an object or array.")
             return
 
         if isinstance(context, list):
@@ -74,23 +77,27 @@ class DTDLImporter(BaseImporter):
         try:
             cls_by_type = DTDL_CLS_BY_TYPE_BY_SPEC[spec_version]
         except KeyError:
-            yield issues.fileread.UnsupportedSpecWarning(filepath=filepath, version=spec_version, spec_name="DTDL")
+            yield NeatValueWarning(
+                f"Unsupported DTDL spec version: {spec_version} in {filepath}. "
+                f"Supported versions are {humanize_collection(DTDL_CLS_BY_TYPE_BY_SPEC.keys())}."
+                " The file will be skipped."
+            )
             return
 
         for item in raw_list:
             if not (type_ := item.get("@type")):
-                yield issues.fileread.InvalidFileFormatWarning(filepath=filepath, reason="Missing '@type' key.")
+                yield FileMissingRequiredFieldWarning(filepath, "@type", "Missing '@type' key.")
                 continue
             cls_ = cls_by_type.get(type_)
             if cls_ is None:
-                yield issues.fileread.UnknownItemWarning(reason=f"Unknown '@type' {type_}.", filepath=filepath)
+                yield FileItemNotSupportedWarning(f"Unknown '@type' {type_}.", filepath=filepath)
                 continue
             try:
                 yield cls_.model_validate(item)
             except ValidationError as e:
-                yield issues.fileread.InvalidFileFormatWarning(filepath=filepath, reason=str(e))
+                yield FileTypeUnexpectedWarning(filepath, frozenset([cls.__name__]), str(e))
             except Exception as e:
-                yield issues.fileread.BugInImporterWarning(filepath=filepath, error=str(e), importer_name=cls.__name__)
+                yield FileReadWarning(filepath=filepath, reason=str(e))
 
     @classmethod
     def from_directory(cls, directory: Path) -> "DTDLImporter":
@@ -112,23 +119,23 @@ class DTDLImporter(BaseImporter):
             for filepath in z.namelist():
                 if filepath.endswith(".json"):
                     for item in cls._from_file_content(z.read(filepath).decode(), Path(filepath)):
-                        if isinstance(item, ValidationIssue):
+                        if isinstance(item, NeatIssue):
                             issues.append(item)
                         else:
                             items.append(item)
         return cls(items, zip_file.stem, read_issues=issues)
 
     @overload
-    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
+    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> VerifiedRules: ...
 
     @overload
     def to_rules(
         self, errors: Literal["continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList]: ...
+    ) -> tuple[VerifiedRules | None, IssueList]: ...
 
     def to_rules(
         self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
         converter = _DTDLConverter(self._read_issues)
 
         converter.convert(self._items)

cognite/neat/rules/importers/_dtdl2rules/spec.py

@@ -13,6 +13,7 @@ from abc import ABC
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, TypeAlias
 
 from pydantic import BaseModel, Field, field_validator, model_serializer, model_validator
+from pydantic.fields import FieldInfo
 
 from cognite.neat.rules.models.entities import ClassEntity
 
@@ -134,6 +135,10 @@ class DTDLBase(BaseModel, ABC):
     display_name: str | None = Field(None, alias="displayName")
     description: str | None = None
 
+    @property
+    def identifier_with_fallback(self) -> str:
+        return (self.id_.model_dump() if self.id_ else self.display_name) or "MISSING"
+
 
 PrimitiveSchema: TypeAlias = Literal[
     "boolean", "date", "dateTime", "double", "duration", "float", "integer", "long", "string", "time"
@@ -317,6 +322,8 @@ class Interface(DTDLBase):
         if not isinstance(value, list):
             return value
         context = info.data.get("@context", cls.default_context)
+        if isinstance(context, FieldInfo):
+            context = context.default
         spec_version = context.rsplit(";", maxsplit=1)[1]
         try:
             cls_by_type = DTDL_CLS_BY_TYPE_BY_SPEC[spec_version]

cognite/neat/rules/importers/_rdf/_imf2rules/_imf2classes.py

@@ -53,7 +53,7 @@ def parse_imf_to_classes(graph: Graph, language: str = "en") -> list[dict]:
         BIND(IF(!bound(?parent) && ?type = imf:AttributeType, imf:Attribute, ?parent) AS ?parentClass)
 
         # Rebind the IRI of the IMF-type to the ?reference variable to align with dataframe column headers
-        # This is solely for readability, the ?imfClass could have been returnered directly instead of ?reference
+        # This is solely for readability, the ?imfClass could have been returned directly instead of ?reference
         BIND(?imfClass AS ?reference)
 
         FILTER (!isBlank(?class))

cognite/neat/rules/importers/_rdf/_imf2rules/_imf2rules.py

@@ -7,7 +7,7 @@ from typing import Literal, overload
 from rdflib import DC, DCTERMS, OWL, RDF, RDFS, SH, SKOS, Graph
 
 from cognite.neat.issues import IssueList
-from cognite.neat.rules.importers._base import BaseImporter, Rules
+from cognite.neat.rules.importers._base import BaseImporter, VerifiedRules
 from cognite.neat.rules.models import InformationRules, RoleTypes
 from cognite.neat.rules.models.data_types import _XSD_TYPES
 
@@ -36,22 +36,24 @@ class IMFImporter(BaseImporter):
     """
 
     def __init__(self, filepath: Path):
-        self.owl_filepath = filepath
+        self.filepath = filepath
 
     @overload
-    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
+    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> VerifiedRules: ...
 
     @overload
     def to_rules(
         self, errors: Literal["continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList]: ...
+    ) -> tuple[VerifiedRules | None, IssueList]: ...
 
     def to_rules(
-        self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList] | Rules:
+        self,
+        errors: Literal["raise", "continue"] = "continue",
+        role: RoleTypes | None = None,
+    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
         graph = Graph()
         try:
-            graph.parse(self.owl_filepath)
+            graph.parse(self.filepath)
         except Exception as e:
             raise Exception(f"Could not parse owl file: {e}") from e
 

cognite/neat/rules/importers/_rdf/_inference2rules.py

@@ -6,17 +6,17 @@ from typing import Literal, cast, overload
 from rdflib import Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 
-import cognite.neat.rules.issues as issues
 from cognite.neat.constants import DEFAULT_NAMESPACE, get_default_prefixes
-from cognite.neat.graph.stores import NeatGraphStore
 from cognite.neat.issues import IssueList
-from cognite.neat.rules.importers._base import BaseImporter, Rules, _handle_issues
+from cognite.neat.issues.errors import FileReadError
+from cognite.neat.rules.importers._base import BaseImporter, VerifiedRules, _handle_issues
 from cognite.neat.rules.models import InformationRules, RoleTypes
 from cognite.neat.rules.models._base import MatchType
 from cognite.neat.rules.models.information import (
     InformationMetadata,
     InformationRulesInput,
 )
+from cognite.neat.store import NeatGraphStore
 from cognite.neat.utils.rdf_ import get_namespace, remove_namespace_from_uri, uri_to_short_form
 
 ORDERED_CLASSES_QUERY = """SELECT ?class (count(?s) as ?instances )
@@ -106,8 +106,8 @@ class InferenceImporter(BaseImporter):
         graph = Graph()
         try:
             graph.parse(filepath)
-        except Exception:
-            issue_list.append(issues.fileread.FileReadError(filepath))
+        except Exception as e:
+            issue_list.append(FileReadError(filepath, str(e)))
 
         return cls(
             issue_list,
@@ -148,20 +148,20 @@ class InferenceImporter(BaseImporter):
         raise NotImplementedError("JSON file format is not supported yet.")
 
     @overload
-    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
+    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> VerifiedRules: ...
 
     @overload
     def to_rules(
         self,
         errors: Literal["continue"] = "continue",
         role: RoleTypes | None = None,
-    ) -> tuple[Rules | None, IssueList]: ...
+    ) -> tuple[VerifiedRules | None, IssueList]: ...
 
     def to_rules(
         self,
         errors: Literal["raise", "continue"] = "continue",
         role: RoleTypes | None = None,
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
         """
         Creates `Rules` object from the data for target role.
         """

cognite/neat/rules/importers/_rdf/_owl2rules/_owl2classes.py

@@ -34,6 +34,7 @@ def parse_owl_classes(graph: Graph, language: str = "en") -> list[dict]:
         FILTER (!bound(?parentClass) || !isBlank(?parentClass))
         FILTER (!bound(?name) || LANG(?name) = "" || LANGMATCHES(LANG(?name), "en"))
         FILTER (!bound(?description) || LANG(?description) = "" || LANGMATCHES(LANG(?description), "en"))
+        BIND(?class AS ?reference)
     }
     """
 

cognite/neat/rules/importers/_rdf/_owl2rules/_owl2properties.py

@@ -40,6 +40,7 @@ def parse_owl_properties(graph: Graph, language: str = "en") -> list[dict]:
         FILTER (!bound(?description) || LANG(?description) = "" || LANGMATCHES(LANG(?description), "en"))
         BIND(IF(bound(?minCount), ?minCount, 0) AS ?minCount)
         BIND(IF(bound(?maxCount), ?maxCount, 1) AS ?maxCount)
+        BIND(?property AS ?reference)
     }
     """
 

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

@@ -7,7 +7,7 @@ from typing import Literal, overload
 from rdflib import DC, DCTERMS, OWL, RDF, RDFS, SKOS, Graph
 
 from cognite.neat.issues import IssueList
-from cognite.neat.rules.importers._base import BaseImporter, Rules
+from cognite.neat.rules.importers._base import BaseImporter, VerifiedRules
 from cognite.neat.rules.importers._rdf._shared import make_components_compliant
 from cognite.neat.rules.models import InformationRules, RoleTypes
 
@@ -38,18 +38,18 @@ class OWLImporter(BaseImporter):
         self.owl_filepath = filepath
 
     @overload
-    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
+    def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> VerifiedRules: ...
 
     @overload
     def to_rules(
         self, errors: Literal["continue"] = "continue", role: RoleTypes | None = None
-    ) -> tuple[Rules | None, IssueList]: ...
+    ) -> tuple[VerifiedRules | None, IssueList]: ...
 
     def to_rules(
         self,
         errors: Literal["raise", "continue"] = "continue",
         role: RoleTypes | None = None,
-    ) -> tuple[Rules | None, IssueList] | Rules:
+    ) -> tuple[VerifiedRules | None, IssueList] | VerifiedRules:
         graph = Graph()
         try:
             graph.parse(self.owl_filepath)

cognite/neat/rules/importers/_rdf/_shared.py

@@ -23,13 +23,13 @@ def parse_raw_classes_dataframe(query_results: list[tuple]) -> pd.DataFrame:
             "Comment",
         ],
     )
+
     if df.empty:
         return df
 
     # # remove NaNs
     df.replace(np.nan, "", regex=True, inplace=True)
 
-    df.Reference = df.Class
     df.Class = df.Class.apply(lambda x: remove_namespace_from_uri(x))
     df["Match Type"] = len(df) * [MatchType.exact]
     df["Comment"] = len(df) * [None]
@@ -202,7 +202,7 @@ def parse_raw_properties_dataframe(query_results: list[tuple]) -> pd.DataFrame:
         return df
 
     df.replace(np.nan, "", regex=True, inplace=True)
-    df.Reference = df.Reference if df.Reference.unique() else df.Property.copy(deep=True)
+
     df.Class = df.Class.apply(lambda x: remove_namespace_from_uri(x))
     df.Property = df.Property.apply(lambda x: remove_namespace_from_uri(x))
     df["Value Type"] = df["Value Type"].apply(lambda x: remove_namespace_from_uri(x))
@@ -231,7 +231,7 @@ def clean_up_properties(df: pd.DataFrame) -> pd.DataFrame:
                     "Min Count": property_grouped_df["Min Count"].unique()[0],
                     "Max Count": property_grouped_df["Max Count"].unique()[0],
                     "Default": property_grouped_df["Default"].unique()[0],
-                    "Reference": property_grouped_df["Reference"].unique()[0] or property_,
+                    "Reference": property_grouped_df["Reference"].unique()[0],
                     "Match Type": property_grouped_df["Match Type"].unique()[0],
                     "Comment": property_grouped_df["Comment"].unique()[0],
                     "_property_type": property_grouped_df["_property_type"].unique()[0],