cognite-neat 0.92.2__py3-none-any.whl → 0.93.0__py3-none-any.whl

cognite/neat/{rules → _rules}/importers/_rdf/_inference2rules.py

@@ -3,23 +3,21 @@ from datetime import datetime
 from pathlib import Path
 from typing import cast
 
-from rdflib import RDF, Graph, Namespace, URIRef
+from rdflib import RDF
 from rdflib import Literal as RdfLiteral
 
-from cognite.neat.constants import DEFAULT_NAMESPACE, get_default_prefixes
-from cognite.neat.issues import IssueList
-from cognite.neat.issues.errors import FileReadError
-from cognite.neat.issues.warnings import PropertyValueTypeUndefinedWarning
-from cognite.neat.rules._shared import ReadRules
-from cognite.neat.rules.importers._base import BaseImporter
-from cognite.neat.rules.models._base_rules import MatchType
-from cognite.neat.rules.models.entities._single_value import UnknownEntity
-from cognite.neat.rules.models.information import (
-    InformationInputRules,
+from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._issues.warnings import PropertyValueTypeUndefinedWarning
+from cognite.neat._rules.models._base_rules import MatchType
+from cognite.neat._rules.models.data_types import AnyURI
+from cognite.neat._rules.models.entities._single_value import UnknownEntity
+from cognite.neat._rules.models.information import (
     InformationMetadata,
 )
-from cognite.neat.store import NeatGraphStore
-from cognite.neat.utils.rdf_ import get_namespace, remove_namespace_from_uri, uri_to_short_form
+from cognite.neat._store import NeatGraphStore
+from cognite.neat._utils.rdf_ import remove_namespace_from_uri
+
+from ._base import DEFAULT_NON_EXISTING_NODE_TYPE, BaseRDFImporter
 
 ORDERED_CLASSES_QUERY = """SELECT ?class (count(?s) as ?instances )
                            WHERE { ?s a ?class . }
@@ -36,7 +34,7 @@ INSTANCE_PROPERTIES_DEFINITION = """SELECT ?property (count(?property) as ?occur
                                     GROUP BY ?property ?dataType ?objectType"""
 
 
-class InferenceImporter(BaseImporter[InformationInputRules]):
+class InferenceImporter(BaseRDFImporter):
     """Infers rules from a triple store.
 
     Rules inference through analysis of knowledge graph provided in various formats.
@@ -50,62 +48,32 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
         prefix: Prefix to be used for the inferred model
     """
 
-    def __init__(
-        self,
-        issue_list: IssueList,
-        graph: Graph,
-        max_number_of_instance: int = -1,
-        prefix: str = "inferred",
-    ) -> None:
-        self.issue_list = issue_list
-        self.graph = graph
-        self.max_number_of_instance = max_number_of_instance
-        self.prefix = prefix
-
     @classmethod
     def from_graph_store(
         cls,
         store: NeatGraphStore,
-        max_number_of_instance: int = -1,
         prefix: str = "inferred",
+        max_number_of_instance: int = -1,
+        non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
     ) -> "InferenceImporter":
-        issue_list = IssueList(title="Inferred from graph store")
-
-        return cls(
-            issue_list,
-            store.graph,
-            max_number_of_instance=max_number_of_instance,
-            prefix=prefix,
-        )
+        return super().from_graph_store(store, prefix, max_number_of_instance, non_existing_node_type)
 
     @classmethod
-    def from_rdf_file(
+    def from_file(
         cls,
         filepath: Path,
-        max_number_of_instance: int = -1,
         prefix: str = "inferred",
+        max_number_of_instance: int = -1,
+        non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
     ) -> "InferenceImporter":
-        issue_list = IssueList(title=f"'{filepath.name}'")
-
-        graph = Graph()
-        try:
-            graph.parse(filepath)
-        except Exception as e:
-            issue_list.append(FileReadError(filepath, str(e)))
-
-        return cls(
-            issue_list,
-            graph,
-            max_number_of_instance=max_number_of_instance,
-            prefix=prefix,
-        )
+        return super().from_file(filepath, prefix, max_number_of_instance, non_existing_node_type)
 
     @classmethod
     def from_json_file(
         cls,
         filepath: Path,
-        max_number_of_instance: int = -1,
         prefix: str = "inferred",
+        max_number_of_instance: int = -1,
     ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
 
@@ -113,8 +81,8 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
     def from_yaml_file(
         cls,
         filepath: Path,
-        max_number_of_instance: int = -1,
         prefix: str = "inferred",
+        max_number_of_instance: int = -1,
     ) -> "InferenceImporter":
         raise NotImplementedError("YAML file format is not supported yet.")
 
@@ -122,27 +90,11 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
     def from_xml_file(
         cls,
         filepath: Path,
-        max_number_of_instance: int = -1,
         prefix: str = "inferred",
+        max_number_of_instance: int = -1,
     ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
 
-    def to_rules(
-        self,
-    ) -> ReadRules[InformationInputRules]:
-        """
-        Creates `Rules` object from the data for target role.
-        """
-
-        if self.issue_list.has_errors:
-            # In case there were errors during the import, the to_rules method will return None
-            return ReadRules(None, self.issue_list, {})
-
-        rules_dict = self._to_rules_components()
-
-        rules = InformationInputRules.load(rules_dict)
-        return ReadRules(rules, self.issue_list, {})
-
     def _to_rules_components(
         self,
     ) -> dict:
@@ -157,16 +109,10 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
         """
         classes: dict[str, dict] = {}
         properties: dict[str, dict] = {}
-        prefixes: dict[str, Namespace] = get_default_prefixes()
         count_by_value_type_by_property: dict[str, dict[str, int]] = defaultdict(Counter)
 
-        # Adds default namespace to prefixes
-        prefixes[self._default_metadata().prefix] = self._default_metadata().namespace
-
         # Infers all the classes in the graph
         for class_uri, no_instances in self.graph.query(ORDERED_CLASSES_QUERY):  # type: ignore[misc]
-            self._add_uri_namespace_to_prefixes(cast(URIRef, class_uri), prefixes)
-
             if (class_id := remove_namespace_from_uri(class_uri)) in classes:
                 # handles cases when class id is already present in classes
                 class_id = f"{class_id}_{len(classes)+1}"
@@ -195,27 +141,24 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
 
                     property_id = remove_namespace_from_uri(property_uri)
 
-                    self._add_uri_namespace_to_prefixes(cast(URIRef, property_uri), prefixes)
-
                     if value_type_uri := (data_type_uri or object_type_uri):
-                        self._add_uri_namespace_to_prefixes(cast(URIRef, value_type_uri), prefixes)
-
                         value_type_id = remove_namespace_from_uri(value_type_uri)
 
                     # this handles situations when property points to node that is not present in graph
                     else:
-                        value_type_id = str(UnknownEntity())
-
-                        self.issue_list.append(
-                            PropertyValueTypeUndefinedWarning(
-                                resource_type="Property",
-                                identifier=f"{class_id}{property_id}",
-                                property_name=property_id,
-                                default_action="Remove the property from the rules",
-                                recommended_action="Make sure that graph is complete",
-                            )
+                        value_type_id = str(self.non_existing_node_type)
+
+                        issue = PropertyValueTypeUndefinedWarning(
+                            resource_type="Property",
+                            identifier=f"{class_id}:{property_id}",
+                            property_name=property_id,
+                            default_action="Remove the property from the rules",
+                            recommended_action="Make sure that graph is complete",
                         )
 
+                        if issue not in self.issue_list:
+                            self.issue_list.append(issue)
+
                     id_ = f"{class_id}:{property_id}"
 
                     definition = {
@@ -224,10 +167,6 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
                         "max_count": cast(RdfLiteral, occurrence).value,
                         "value_type": value_type_id,
                         "reference": property_uri,
-                        "transformation": (
-                            f"{uri_to_short_form(class_definition['reference'], prefixes)}"
-                            f"({uri_to_short_form(cast(URIRef, property_uri), prefixes)})"
-                        ),
                     }
 
                     count_by_value_type_by_property[id_][value_type_id] += 1
@@ -279,20 +218,8 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
             "metadata": self._default_metadata().model_dump(),
             "classes": list(classes.values()),
             "properties": list(properties.values()),
-            "prefixes": prefixes,
         }
 
-    @classmethod
-    def _add_uri_namespace_to_prefixes(cls, URI: URIRef, prefixes: dict[str, Namespace]):
-        """Add URI to prefixes dict if not already present
-
-        Args:
-            URI: URI from which namespace is being extracted
-            prefixes: Dict of prefixes and namespaces
-        """
-        if Namespace(get_namespace(URI)) not in prefixes.values():
-            prefixes[f"prefix-{len(prefixes)+1}"] = Namespace(get_namespace(URI))
-
     def _default_metadata(self):
         return InformationMetadata(
             name="Inferred Model",

cognite/neat/{rules → _rules}/importers/_rdf/_owl2rules/_owl2classes.py

@@ -2,7 +2,7 @@ from typing import cast
 
 from rdflib import Graph
 
-from cognite.neat.rules.importers._rdf._shared import (
+from cognite.neat._rules.importers._rdf._shared import (
     clean_up_classes,
     make_classes_compliant,
     parse_raw_classes_dataframe,

cognite/neat/{rules → _rules}/importers/_rdf/_owl2rules/_owl2metadata.py

@@ -1,10 +1,10 @@
 from rdflib import Graph, Namespace
 
-from cognite.neat.constants import DEFAULT_NAMESPACE
-from cognite.neat.rules.importers._rdf._shared import make_metadata_compliant
-from cognite.neat.rules.models import RoleTypes, SchemaCompleteness
-from cognite.neat.utils.collection_ import remove_none_elements_from_set
-from cognite.neat.utils.rdf_ import convert_rdflib_content
+from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._rules.importers._rdf._shared import make_metadata_compliant
+from cognite.neat._rules.models import RoleTypes, SchemaCompleteness
+from cognite.neat._utils.collection_ import remove_none_elements_from_set
+from cognite.neat._utils.rdf_ import convert_rdflib_content
 
 
 def parse_owl_metadata(graph: Graph) -> dict:

cognite/neat/{rules → _rules}/importers/_rdf/_owl2rules/_owl2properties.py

@@ -2,7 +2,7 @@ from typing import cast
 
 from rdflib import Graph
 
-from cognite.neat.rules.importers._rdf._shared import (
+from cognite.neat._rules.importers._rdf._shared import (
     clean_up_properties,
     make_properties_compliant,
     parse_raw_properties_dataframe,

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

@@ -0,0 +1,39 @@
+"""This module performs importing of various formats to one of serializations for which
+there are loaders to TransformationRules pydantic class."""
+
+from cognite.neat._rules.importers._rdf._base import BaseRDFImporter
+from cognite.neat._rules.importers._rdf._shared import make_components_compliant
+
+from ._owl2classes import parse_owl_classes
+from ._owl2metadata import parse_owl_metadata
+from ._owl2properties import parse_owl_properties
+
+
+class OWLImporter(BaseRDFImporter):
+    """Convert OWL ontology to tables/ transformation rules / Excel file.
+
+        Args:
+            filepath: Path to OWL ontology
+
+    !!! Note
+        OWL Ontologies are information models which completeness varies. As such, constructing functional
+        data model directly will often be impossible, therefore the produced Rules object will be ill formed.
+        To avoid this, neat will automatically attempt to make the imported rules compliant by adding default
+        values for missing information, attaching dangling properties to default containers based on the
+        property type, etc.
+
+        One has to be aware that NEAT will be opinionated about how to make the ontology
+        compliant, and that the resulting rules may not be what you expect.
+
+    """
+
+    def _to_rules_components(
+        self,
+    ) -> dict:
+        components = {
+            "Metadata": parse_owl_metadata(self.graph),
+            "Classes": parse_owl_classes(self.graph),
+            "Properties": parse_owl_properties(self.graph),
+        }
+
+        return make_components_compliant(components)

cognite/neat/{rules → _rules}/importers/_rdf/_shared.py

@@ -4,10 +4,10 @@ import numpy as np
 import pandas as pd
 from rdflib import OWL, Literal, Namespace
 
-from cognite.neat.rules.models._base_rules import MatchType
-from cognite.neat.rules.models.data_types import _XSD_TYPES
-from cognite.neat.utils.rdf_ import remove_namespace_from_uri
-from cognite.neat.utils.regex_patterns import PATTERNS
+from cognite.neat._rules._constants import PATTERNS
+from cognite.neat._rules.models._base_rules import MatchType
+from cognite.neat._rules.models.data_types import _XSD_TYPES
+from cognite.neat._utils.rdf_ import remove_namespace_from_uri
 
 
 def parse_raw_classes_dataframe(query_results: list[tuple]) -> pd.DataFrame:

cognite/neat/{rules → _rules}/importers/_spreadsheet2rules.py

@@ -11,23 +11,25 @@ from typing import Literal, cast
 import pandas as pd
 from cognite.client.utils._importing import local_import
 from pandas import ExcelFile
+from rdflib import Namespace
 
-from cognite.neat.issues import IssueList
-from cognite.neat.issues.errors import (
+from cognite.neat._issues import IssueList
+from cognite.neat._issues.errors import (
     FileMissingRequiredFieldError,
     FileNotFoundNeatError,
     FileReadError,
     PropertyDefinitionDuplicatedError,
 )
-from cognite.neat.rules._shared import ReadRules, T_InputRules
-from cognite.neat.rules.models import (
+from cognite.neat._issues.warnings import FileMissingRequiredFieldWarning
+from cognite.neat._rules._shared import ReadRules, T_InputRules
+from cognite.neat._rules.models import (
     INPUT_RULES_BY_ROLE,
     VERIFIED_RULES_BY_ROLE,
     RoleTypes,
     SchemaCompleteness,
 )
-from cognite.neat.utils.spreadsheet import SpreadsheetRead, read_individual_sheet
-from cognite.neat.utils.text import humanize_collection
+from cognite.neat._utils.spreadsheet import SpreadsheetRead, read_individual_sheet
+from cognite.neat._utils.text import humanize_collection
 
 from ._base import BaseImporter
 
@@ -93,6 +95,7 @@ class ReadResult:
     sheets: dict[str, dict | list]
     read_info_by_sheet: dict[str, SpreadsheetRead]
     metadata: MetadataRaw
+    prefixes: dict[str, Namespace] | None = None
 
     @property
     def role(self) -> RoleTypes:
@@ -122,6 +125,10 @@ class SpreadsheetReader:
     def metadata_sheet_name(self) -> str:
         return f"{self._sheet_prefix}Metadata"
 
+    @property
+    def prefixes_sheet_name(self) -> str:
+        return "Prefixes"
+
     @property
     def seen_sheets(self) -> set[str]:
         if not self._seen_files:
@@ -149,6 +156,14 @@ class SpreadsheetReader:
             return None
         sheets["Metadata"] = dict(metadata)
 
+        # Special case for reading prefixes as they are suppose to be read only once
+        if (
+            self.prefixes_sheet_name in excel_file.sheet_names
+            and not self._sheet_prefix
+            and (prefixes := self._read_prefixes(excel_file, filepath))
+        ):
+            sheets["Prefixes"] = prefixes
+
         return ReadResult(sheets, read_info_by_sheet, metadata)
 
     def _read_metadata(self, excel_file: ExcelFile, filepath: Path) -> MetadataRaw | None:
@@ -163,6 +178,25 @@ class SpreadsheetReader:
             return None
         return metadata
 
+    def _read_prefixes(self, excel_file: ExcelFile, filepath: Path) -> dict[str, Namespace] | None:
+        if self.prefixes_sheet_name not in excel_file.sheet_names:
+            return None
+
+        else:
+            prefixes = {}
+
+            for row in read_individual_sheet(excel_file, "Prefixes", expected_headers=["Prefix", "Namespace"]):
+                if "Prefix" in row and "Namespace" in row:
+                    prefixes[row["Prefix"]] = row["Namespace"]
+                else:
+                    if "Prefix" not in row:
+                        self.issue_list.append(FileMissingRequiredFieldWarning(filepath, "prefixes", "prefix"))
+                    if "Namespace" not in row:
+                        self.issue_list.append(FileMissingRequiredFieldWarning(filepath, "prefixes", "namespace"))
+                    return None
+
+            return prefixes
+
     def _read_sheets(
         self, excel_file: ExcelFile, read_role: RoleTypes
     ) -> tuple[dict[str, dict | list] | None, dict[str, SpreadsheetRead]]:

cognite/neat/{rules → _rules}/importers/_yaml2rules.py

@@ -3,16 +3,16 @@ from typing import Any, cast
 
 import yaml
 
-from cognite.neat.issues import IssueList, NeatIssue
-from cognite.neat.issues.errors import (
+from cognite.neat._issues import IssueList, NeatIssue
+from cognite.neat._issues.errors import (
     FileMissingRequiredFieldError,
     FileNotAFileError,
     FileNotFoundNeatError,
     FileTypeUnexpectedError,
 )
-from cognite.neat.issues.warnings import NeatValueWarning
-from cognite.neat.rules._shared import ReadRules, T_InputRules
-from cognite.neat.rules.models import INPUT_RULES_BY_ROLE, RoleTypes
+from cognite.neat._issues.warnings import NeatValueWarning
+from cognite.neat._rules._shared import ReadRules, T_InputRules
+from cognite.neat._rules.models import INPUT_RULES_BY_ROLE, RoleTypes
 
 from ._base import BaseImporter
 

cognite/neat/{rules → _rules}/models/__init__.py

@@ -1,8 +1,8 @@
-from cognite.neat.rules.models.asset._rules import AssetRules
-from cognite.neat.rules.models.asset._rules_input import AssetInputRules
-from cognite.neat.rules.models.domain import DomainInputRules, DomainRules
-from cognite.neat.rules.models.information._rules import InformationRules
-from cognite.neat.rules.models.information._rules_input import InformationInputRules
+from cognite.neat._rules.models.asset._rules import AssetRules
+from cognite.neat._rules.models.asset._rules_input import AssetInputRules
+from cognite.neat._rules.models.domain import DomainInputRules, DomainRules
+from cognite.neat._rules.models.information._rules import InformationRules
+from cognite.neat._rules.models.information._rules_input import InformationInputRules
 
 from ._base_rules import DataModelType, ExtensionCategory, RoleTypes, SchemaCompleteness, SheetList, SheetRow
 from .dms._rules import DMSRules

cognite/neat/{rules → _rules}/models/_base_input.py

@@ -18,6 +18,8 @@ from dataclasses import Field, dataclass, fields, is_dataclass
 from types import GenericAlias, UnionType
 from typing import Any, Generic, TypeVar, Union, cast, get_args, get_origin, overload
 
+import pandas as pd
+
 from ._base_rules import BaseRules, SchemaModel
 
 if sys.version_info >= (3, 11):
@@ -40,14 +42,14 @@ class InputRules(Generic[T_BaseRules], ABC):
 
     @classmethod
     @overload
-    def load(cls, data: dict[str, Any]) -> Self: ...
+    def load(cls: "type[T_InputRules]", data: dict[str, Any]) -> "T_InputRules": ...
 
     @classmethod
     @overload
-    def load(cls, data: None) -> None: ...
+    def load(cls: "type[T_InputRules]", data: None) -> None: ...
 
     @classmethod
-    def load(cls, data: dict | None) -> Self | None:
+    def load(cls: "type[T_InputRules]", data: dict | None) -> "T_InputRules | None":
         if data is None:
             return None
         return cls._load(data)
@@ -62,15 +64,20 @@ class InputRules(Generic[T_BaseRules], ABC):
             if isinstance(type_, str) and type_.startswith(cls.__name__):
                 type_ = cls
 
+            candidate: type
             if is_dataclass(type_):
-                candidate = type_
+                candidate = type_  # type: ignore[assignment]
             elif isinstance(type_, GenericAlias) and type_.__origin__ is list and is_dataclass(type_.__args__[0]):
-                candidate = type_.__args__[0]
+                candidate = type_.__args__[0]  # type: ignore[assignment]
+
+            # this handles prefixes
+            elif isinstance(type_, GenericAlias) and type_.__origin__ is dict:
+                candidate = type_  # type: ignore[assignment]
             else:
                 continue
 
-            if hasattr(candidate, "_load"):
-                output[field_.name] = candidate
+            output[field_.name] = candidate
+
         return output
 
     @classmethod
@@ -88,10 +95,16 @@ class InputRules(Generic[T_BaseRules], ABC):
             else:
                 continue
 
-            if isinstance(value, dict):
-                args[field_name] = field_type._load(value)  # type: ignore[attr-defined]
-            elif isinstance(value, list) and value and isinstance(value[0], dict):
-                args[field_name] = [field_type._load(item) for item in value]  # type: ignore[attr-defined]
+            # Handles the case where the field is a dataclass
+            if hasattr(field_type, "_load"):
+                if isinstance(value, dict):
+                    args[field_name] = field_type._load(value)  # type: ignore[attr-defined]
+                elif isinstance(value, list) and value and isinstance(value[0], dict):
+                    args[field_name] = [field_type._load(item) for item in value]  # type: ignore[attr-defined]
+            # Handles the case where the field holds non-dataclass values, e.g. a prefixes dict
+            else:
+                args[field_name] = value
+
         return cls(**args)
 
     def _dataclass_fields(self) -> list[Field]:
@@ -114,6 +127,9 @@ class InputRules(Generic[T_BaseRules], ABC):
         return output
 
 
+T_InputRules = TypeVar("T_InputRules", bound=InputRules)
+
+
 @dataclass
 class InputComponent(ABC, Generic[T_RuleModel]):
     @classmethod
@@ -160,3 +176,6 @@ class InputComponent(ABC, Generic[T_RuleModel]):
             for name, field_ in self._get_verified_cls().model_fields.items()
             if not field_.exclude
         }
+
+    def _repr_html_(self) -> str:
+        return pd.DataFrame([self.dump()])._repr_html_()  # type: ignore[operator]

cognite/neat/{rules → _rules}/models/_base_rules.py

@@ -24,6 +24,8 @@ from pydantic import (
 from pydantic.main import IncEx
 from pydantic_core import core_schema
 
+from cognite.neat._rules.models._types import ClassEntityType, InformationPropertyType
+
 if sys.version_info >= (3, 11):
     from enum import StrEnum
     from typing import Self
@@ -108,6 +110,14 @@ class SchemaModel(BaseModel):
         """Returns a set of mandatory fields for the model."""
         return _get_required_fields(cls, use_alias)
 
+    @field_validator("*", mode="before")
+    def strip_string(cls, value: Any) -> Any:
+        if isinstance(value, str):
+            return value.strip()
+        elif isinstance(value, list):
+            return [entry.strip() if isinstance(entry, str) else entry for entry in value]
+        return value
+
 
 class BaseMetadata(SchemaModel):
     """
@@ -200,7 +210,7 @@ class BaseRules(SchemaModel, ABC):
         as_reference: bool = False,
         mode: Literal["python", "json"] = "python",
         by_alias: bool = False,
-        exclude: IncEx = None,
+        exclude: IncEx | None = None,
         exclude_none: bool = False,
         exclude_unset: bool = False,
         exclude_defaults: bool = False,
@@ -236,7 +246,7 @@ class BaseRules(SchemaModel, ABC):
         if entities_exclude_defaults:
             context["metadata"] = self.metadata
 
-        exclude_input: IncEx
+        exclude_input: IncEx | None
         if self.reference is None:
             exclude_input = exclude
         else:
@@ -279,12 +289,6 @@ class BaseRules(SchemaModel, ABC):
 
 
 class SheetRow(SchemaModel):
-    @field_validator("*", mode="before")
-    def strip_string(cls, value: Any) -> Any:
-        if isinstance(value, str):
-            return value.strip()
-        return value
-
     @abstractmethod
     def _identifier(self) -> tuple[Hashable, ...]:
         raise NotImplementedError()
@@ -346,3 +350,13 @@ ExtensionCategoryType = Annotated[
     ),
     BeforeValidator(lambda v: ExtensionCategory(v) if isinstance(v, str) else v),
 ]
+
+
+# Immutable such that this can be used as a key in a dictionary
+class PropertyRef(BaseModel, frozen=True):
+    class_: ClassEntityType = Field(alias="Class")
+    property_: InformationPropertyType = Field(alias="Property")
+
+
+class ClassRef(BaseModel, frozen=True):
+    class_: ClassEntityType = Field(alias="Class")

cognite/neat/{rules → _rules}/models/_rdfpath.py

@@ -8,7 +8,7 @@ from typing import ClassVar, Literal
 
 from pydantic import BaseModel, field_validator, model_serializer
 
-from cognite.neat.issues.errors import NeatValueError
+from cognite.neat._issues.errors import NeatValueError
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum