cognite-neat 0.85.4__tar.gz → 0.85.6__tar.gz

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.85.4
+Version: 0.85.6
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

cognite_neat-0.85.6/cognite/neat/_version.py

@@ -0,0 +1 @@
+__version__ = "0.85.6"

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/constants.py

@@ -22,14 +22,6 @@ PREFIXES = {
     "owl": OWL._NS,
     "xsd": XSD._NS,
     "pav": Namespace("http://purl.org/pav/"),
-    "cim": Namespace("http://iec.ch/TC57/2013/CIM-schema-cim16#"),
-    "icim": Namespace("http://iec.ch/TC57/2013/CIM-schema-cim16-info#"),
-    "entsoe": Namespace("http://entsoe.eu/CIM/SchemaExtension/3/1#"),
-    "entsoe2": Namespace("http://entsoe.eu/CIM/SchemaExtension/3/2#"),
-    "md": Namespace("http://iec.ch/TC57/61970-552/ModelDescription/1#"),
-    "pti": Namespace("http://www.pti-us.com/PTI_CIM-schema-cim16#"),
-    "tnt": Namespace("http://purl.org/cognite/tnt#"),
-    "neat": DEFAULT_NAMESPACE,
 }
 
 

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/graph/loaders/_rdf2dms.py

@@ -82,7 +82,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         except Exception as e:
             issues.append(
                 loader_issues.FailedConvertError(
-                    identifier=rules.metadata.as_identifier(), target_format="read DMS model", reason=str(e)
+                    identifier=rules.metadata.as_identifier(),
+                    target_format="read DMS model",
+                    reason=str(e),
                 )
             )
         return cls(graph_store, data_model, instance_space, {}, issues)
@@ -199,7 +201,11 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         return pydantic_cls, edge_by_property, issues
 
     def _create_node(
-        self, identifier: str, properties: dict[str, list[str]], pydantic_cls: type[Model], view_id: dm.ViewId
+        self,
+        identifier: str,
+        properties: dict[str, list[str]],
+        pydantic_cls: type[Model],
+        view_id: dm.ViewId,
     ) -> dm.InstanceApply:
         created = pydantic_cls.model_validate(properties)
 
@@ -233,7 +239,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 external_id = f"{identifier}.{prop}.{target}"
                 yield dm.EdgeApply(
                     space=self.instance_space,
-                    external_id=external_id if len(external_id) < 256 else create_sha256_hash(external_id),
+                    external_id=(external_id if len(external_id) < 256 else create_sha256_hash(external_id)),
                     type=edge.type,
                     start_node=dm.DirectRelationReference(self.instance_space, identifier),
                     end_node=dm.DirectRelationReference(self.instance_space, target),
@@ -290,5 +296,7 @@ def _triples2dictionary(
     """Converts list of triples to dictionary"""
     values_by_property_by_identifier: dict[str, dict[str, list[str]]] = defaultdict(lambda: defaultdict(list))
     for id_, property_, value in triples:
-        values_by_property_by_identifier[id_][property_].append(value)
+        # avoid issue with strings "None", "nan", "null" being treated as values
+        if value.lower() not in ["", "None", "nan", "null"]:
+            values_by_property_by_identifier[id_][property_].append(value)
     return values_by_property_by_identifier

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/legacy/graph/examples/__init__.py

@@ -5,3 +5,6 @@ from pathlib import Path
 # https://github.com/pydata/xarray/blob/main/xarray/tutorial.py
 # Currently there are simple paths to the examples which are then easily loaded in the notebooks
 nordic44_knowledge_graph = Path(__file__).parent / "Knowledge-Graph-Nordic44.xml"
+nordic44_knowledge_graph_dirty = (
+    Path(__file__).parent / "Knowledge-Graph-Nordic44-dirty.xml"
+)

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/legacy/graph/extractors/_dexpi.py

@@ -3,7 +3,7 @@ from pathlib import Path
 
 from rdflib import Namespace
 
-from cognite.neat.constants import PREFIXES
+from cognite.neat.constants import DEFAULT_NAMESPACE
 from cognite.neat.graph.extractors._dexpi import DexpiExtractor
 from cognite.neat.legacy.graph.models import Triple
 
@@ -31,7 +31,7 @@ class DexpiXML(BaseExtractor):
         base_namespace: str | None = None,
     ):
         self.filepath = Path(filepath)
-        self.namespace = Namespace(base_namespace) if isinstance(base_namespace, str | Namespace) else PREFIXES["neat"]
+        self.namespace = Namespace(base_namespace) if isinstance(base_namespace, str | Namespace) else DEFAULT_NAMESPACE
 
     def extract(self) -> set[Triple]:
         """

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/legacy/graph/loaders/core/rdf_to_assets.py

@@ -271,7 +271,7 @@ def _class2asset_instance(
     if "name" in remapped_class_instance and remapped_class_instance["name"] == "":
         remapped_class_instance["name"] = empty_name_default
     # To maintain shape across of all assets of specific type we are adding missing metadata
-    # keys as empty strings, this was request by Statnett
+    # keys as empty strings, this was request by a customer
     # Generally this is bad practice, but more of a workaround of their bad data
     if missing_metadata and add_missing_metadata:
         msg = f"Adding missing metadata keys with values set to empty string for {class_}"

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/legacy/rules/examples/__init__.py

@@ -12,7 +12,7 @@ power_grid_containers = _EXAMPLES / "power-grid-containers.yaml"
 power_grid_data_model = _EXAMPLES / "power-grid-model.yaml"
 simple_example = _EXAMPLES / "sheet2cdf-transformation-rules.xlsx"
 source_to_solution_mapping = _EXAMPLES / "source-to-solution-mapping-rules.xlsx"
-nordic44 = _EXAMPLES / "Rules-Nordic44-to-TNT.xlsx"
+nordic44 = _EXAMPLES / "Rules-Nordic44.xlsx"
 nordic44_graphql = _EXAMPLES / "Rules-Nordic44-to-graphql.xlsx"
 skos = _EXAMPLES / "skos-rules.xlsx"
 wind_energy_ontology = _EXAMPLES / "wind-energy.owl"

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/legacy/workflows/examples/Extract_RDF_Graph_and_Generate_Assets/workflow.yaml

@@ -24,7 +24,7 @@ steps:
       pos_y: 77
   - complex_configs: {}
     configs:
-      file_name: Rules-Nordic44-to-TNT.xlsx
+      file_name: Rules-Nordic44.xlsx
       validation_report_file: rules_validation_report.txt
       validation_report_storage_dir: rules_validation_report
       version: ""

cognite_neat-0.85.6/cognite/neat/rules/analysis/__init__.py

@@ -0,0 +1,6 @@
+from ._information_rules import (
+    AssetArchitectRulesAnalysis,
+    InformationArchitectRulesAnalysis,
+)
+
+__all__ = ["InformationArchitectRulesAnalysis", "AssetArchitectRulesAnalysis"]

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/rules/analysis/_base.py

@@ -1,15 +1,9 @@
-import sys
 from abc import ABC, abstractmethod
 from typing import Generic, TypeVar
 
 from cognite.neat.rules._shared import Rules
 from cognite.neat.rules.models.entities import ClassEntity
 
-if sys.version_info >= (3, 11):
-    from enum import StrEnum
-else:
-    from backports.strenum import StrEnum
-
 T_Rules = TypeVar("T_Rules", bound=Rules)
 
 
@@ -17,9 +11,3 @@ class BaseAnalysis(ABC, Generic[T_Rules]):
     @abstractmethod
     def subset_rules(self, desired_classes: set[ClassEntity]) -> T_Rules:
         raise NotImplementedError()
-
-
-class DataModelingScenario(StrEnum):
-    from_scratch = "from scratch"
-    build_solution = "build solution"
-    extend_reference = "extend reference"

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/rules/analysis/_information_rules.py

@@ -2,25 +2,37 @@ import itertools
 import logging
 import warnings
 from collections import defaultdict
-from typing import Any
+from typing import Any, Generic, TypeVar
 
 import pandas as pd
 from pydantic import ValidationError
 
 from cognite.neat.rules.models import SchemaCompleteness
 from cognite.neat.rules.models._rdfpath import RDFPath
-from cognite.neat.rules.models.entities import ClassEntity, EntityTypes, ParentClassEntity, ReferenceEntity
-from cognite.neat.rules.models.information import InformationClass, InformationProperty, InformationRules
+from cognite.neat.rules.models.asset import AssetClass, AssetProperty, AssetRules
+from cognite.neat.rules.models.entities import (
+    AssetEntity,
+    ClassEntity,
+    EntityTypes,
+    ParentClassEntity,
+    ReferenceEntity,
+    RelationshipEntity,
+)
+from cognite.neat.rules.models.information import (
+    InformationClass,
+    InformationProperty,
+    InformationRules,
+)
 from cognite.neat.utils.utils import get_inheritance_path
 
-from ._base import BaseAnalysis
+T_Rules = TypeVar("T_Rules", InformationRules, AssetRules)
+T_Property = TypeVar("T_Property", InformationProperty, AssetProperty)
+T_Class = TypeVar("T_Class", InformationClass, AssetClass)
 
 
-class InformationArchitectRulesAnalysis(BaseAnalysis):
-    """Assumes analysis over only the complete schema"""
-
-    def __init__(self, rules: InformationRules):
-        self.rules = rules
+class _SharedAnalysis(Generic[T_Rules, T_Property, T_Class]):
+    def __init__(self, rules: T_Rules):
+        self.rules: T_Rules = rules
 
     @property
     def directly_referred_classes(self) -> set[ClassEntity]:
@@ -65,9 +77,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
         return class_subclass_pairs
 
-    def classes_with_properties(
-        self, consider_inheritance: bool = False
-    ) -> dict[ClassEntity, list[InformationProperty]]:
+    def classes_with_properties(self, consider_inheritance: bool = False) -> dict[ClassEntity, list[T_Property]]:
         """Returns classes that have been defined in the data model.
 
         Args:
@@ -85,10 +95,10 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
             it will not be included in the returned dictionary.
         """
 
-        class_property_pairs: dict[ClassEntity, list[InformationProperty]] = defaultdict(list)
+        class_property_pairs: dict[ClassEntity, list[T_Property]] = defaultdict(list)
 
         for property_ in self.rules.properties:
-            class_property_pairs[property_.class_].append(property_)
+            class_property_pairs[property_.class_].append(property_)  # type: ignore
 
         if consider_inheritance:
             class_parent_pairs = self.class_parent_pairs()
@@ -106,7 +116,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
     def _add_inherited_properties(
         cls,
         class_: ClassEntity,
-        class_property_pairs: dict[ClassEntity, list[InformationProperty]],
+        class_property_pairs: dict[ClassEntity, list[T_Property]],
         class_parent_pairs: dict[ClassEntity, list[ParentClassEntity]],
     ):
         inheritance_path = get_inheritance_path(class_, class_parent_pairs)
@@ -130,7 +140,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
     def class_property_pairs(
         self, only_rdfpath: bool = False, consider_inheritance: bool = False
-    ) -> dict[ClassEntity, dict[str, InformationProperty]]:
+    ) -> dict[ClassEntity, dict[str, T_Property]]:
         """Returns a dictionary of classes with a dictionary of properties associated with them.
 
         Args:
@@ -193,7 +203,14 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
             Dataframe with the class linkage of the data model
         """
 
-        class_linkage = pd.DataFrame(columns=["source_class", "target_class", "connecting_property", "max_occurrence"])
+        class_linkage = pd.DataFrame(
+            columns=[
+                "source_class",
+                "target_class",
+                "connecting_property",
+                "max_occurrence",
+            ]
+        )
 
         class_property_pairs = self.classes_with_properties(consider_inheritance)
         properties = list(itertools.chain.from_iterable(class_property_pairs.values()))
@@ -286,21 +303,21 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
     def as_property_dict(
         self,
-    ) -> dict[str, list[InformationProperty]]:
+    ) -> dict[str, list[T_Property]]:
         """This is used to capture all definitions of a property in the data model."""
-        property_dict: dict[str, list[InformationProperty]] = defaultdict(list)
+        property_dict: dict[str, list[T_Property]] = defaultdict(list)
         for definition in self.rules.properties:
-            property_dict[definition.property_].append(definition)
+            property_dict[definition.property_].append(definition)  # type: ignore
         return property_dict
 
-    def as_class_dict(self) -> dict[str, InformationClass]:
+    def as_class_dict(self) -> dict[str, T_Class]:
         """This is to simplify access to classes through dict."""
-        class_dict: dict[str, InformationClass] = {}
+        class_dict: dict[str, T_Class] = {}
         for definition in self.rules.classes:
-            class_dict[str(definition.class_.suffix)] = definition
+            class_dict[str(definition.class_.suffix)] = definition  # type: ignore
         return class_dict
 
-    def subset_rules(self, desired_classes: set[ClassEntity]) -> InformationRules:
+    def subset_rules(self, desired_classes: set[ClassEntity]) -> T_Rules:
         """
         Subset rules to only include desired classes and their properties.
 
@@ -352,7 +369,8 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
         if impossible_classes:
             logging.warning(f"Could not find the following classes defined in the data model: {impossible_classes}")
             warnings.warn(
-                f"Could not find the following classes defined in the data model: {impossible_classes}", stacklevel=2
+                f"Could not find the following classes defined in the data model: {impossible_classes}",
+                stacklevel=2,
             )
 
         reduced_data_model: dict[str, Any] = {
@@ -373,8 +391,79 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
                 reduced_data_model["properties"].extend(properties)
 
         try:
-            return InformationRules(**reduced_data_model)
+            return type(self.rules)(**reduced_data_model)
         except ValidationError as e:
             warnings.warn(f"Reduced data model is not complete: {e}", stacklevel=2)
             reduced_data_model["metadata"].schema_ = SchemaCompleteness.partial
-            return InformationRules.model_construct(**reduced_data_model)
+            return type(self.rules).model_construct(**reduced_data_model)
+
+
+class InformationArchitectRulesAnalysis(_SharedAnalysis[InformationRules, InformationProperty, InformationClass]):
+    """Assumes analysis over only the complete schema"""
+
+    ...
+
+
+class AssetArchitectRulesAnalysis(_SharedAnalysis[AssetRules, AssetProperty, AssetClass]):
+    """Assumes analysis over only the complete schema"""
+
+    def class_property_pairs(
+        self,
+        only_rdfpath: bool = False,
+        consider_inheritance: bool = False,
+        implementation_type: EntityTypes = EntityTypes.asset,
+    ) -> dict[ClassEntity, dict[str, AssetProperty]]:
+        class_property_pairs = {}
+
+        T_implementation = AssetEntity if implementation_type == EntityTypes.asset else RelationshipEntity
+
+        for class_, properties in self.classes_with_properties(consider_inheritance).items():
+            processed_properties = {}
+            for property_ in properties:
+                if property_.property_ in processed_properties:
+                    # TODO: use appropriate Warning class from _exceptions.py
+                    # if missing make one !
+                    warnings.warn(
+                        f"Property {property_.property_} for {class_} has been defined more than once!"
+                        " Only the first definition will be considered, skipping the rest..",
+                        stacklevel=2,
+                    )
+                    continue
+
+                if (
+                    property_.implementation
+                    and any(isinstance(implementation, T_implementation) for implementation in property_.implementation)
+                    and (not only_rdfpath or (only_rdfpath and isinstance(property_.transformation, RDFPath)))
+                ):
+                    implementation = [
+                        implementation
+                        for implementation in property_.implementation
+                        if isinstance(implementation, T_implementation)
+                    ]
+
+                    processed_properties[property_.property_] = property_.model_copy(
+                        deep=True, update={"implementation": implementation}
+                    )
+
+            if processed_properties:
+                class_property_pairs[class_] = processed_properties
+
+        return class_property_pairs
+
+    def asset_definition(
+        self, only_rdfpath: bool = False, consider_inheritance: bool = False
+    ) -> dict[ClassEntity, dict[str, AssetProperty]]:
+        return self.class_property_pairs(
+            consider_inheritance=consider_inheritance,
+            only_rdfpath=only_rdfpath,
+            implementation_type=EntityTypes.asset,
+        )
+
+    def relationship_definition(
+        self, only_rdfpath: bool = False, consider_inheritance: bool = False
+    ) -> dict[ClassEntity, dict[str, AssetProperty]]:
+        return self.class_property_pairs(
+            consider_inheritance=consider_inheritance,
+            only_rdfpath=only_rdfpath,
+            implementation_type=EntityTypes.relationship,
+        )

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/rules/exporters/_rules2excel.py

@@ -143,9 +143,15 @@ class ExcelExporter(BaseExporter[Workbook]):
 
         return workbook
 
-    def _write_sheets(self, workbook: Workbook, dumped_rules: dict[str, Any], rules: Rules, sheet_prefix: str = ""):
+    def _write_sheets(
+        self,
+        workbook: Workbook,
+        dumped_rules: dict[str, Any],
+        rules: Rules,
+        sheet_prefix: str = "",
+    ):
         for sheet_name, headers in rules.headers_by_sheet(by_alias=True).items():
-            if sheet_name in ("Metadata", "prefixes", "Reference", "Last"):
+            if sheet_name in ("Metadata", "Prefixes", "Reference", "Last"):
                 continue
             sheet = workbook.create_sheet(f"{sheet_prefix}{sheet_name}")
 
@@ -273,7 +279,9 @@ class _MetadataCreator:
 
         new_metadata = self._create_new_info(now)
         if isinstance(metadata, DMSMetadata):
-            from cognite.neat.rules.models.information._converter import _InformationRulesConverter
+            from cognite.neat.rules.models.information._converter import (
+                _InformationRulesConverter,
+            )
 
             output_metadata: DMSMetadata | InformationMetadata = _InformationRulesConverter._convert_metadata_to_dms(
                 new_metadata

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/rules/importers/_base.py

@@ -10,7 +10,11 @@ from pydantic import ValidationError
 from rdflib import Namespace
 
 from cognite.neat.rules._shared import Rules
-from cognite.neat.rules.issues.base import IssueList, NeatValidationError, ValidationWarning
+from cognite.neat.rules.issues.base import (
+    IssueList,
+    NeatValidationError,
+    ValidationWarning,
+)
 from cognite.neat.rules.models import AssetRules, DMSRules, InformationRules, RoleTypes
 from cognite.neat.utils.auxiliary import class_html_doc
 
@@ -30,7 +34,9 @@ class BaseImporter(ABC):
 
     @abstractmethod
     def to_rules(
-        self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
+        self,
+        errors: Literal["raise", "continue"] = "continue",
+        role: RoleTypes | None = None,
     ) -> tuple[Rules | None, IssueList] | Rules:
         """
         Creates `Rules` object from the data for target role.

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/rules/importers/_inference2rules.py

@@ -91,7 +91,9 @@ class InferenceImporter(BaseImporter):
     ) -> tuple[Rules | None, IssueList]: ...
 
     def to_rules(
-        self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
+        self,
+        errors: Literal["raise", "continue"] = "continue",
+        role: RoleTypes | None = None,
     ) -> tuple[Rules | None, IssueList] | Rules:
         """
         Creates `Rules` object from the data for target role.
@@ -103,9 +105,6 @@ class InferenceImporter(BaseImporter):
 
         rules_dict = self._to_rules_components()
 
-        # adding additional prefix
-        rules_dict["prefixes"][rules_dict["metadata"]["prefix"]] = rules_dict["metadata"]["namespace"]
-
         with _handle_issues(self.issue_list) as future:
             rules: InformationRules
             rules = InformationRulesInput.load(rules_dict).as_rules()
@@ -134,7 +133,10 @@ class InferenceImporter(BaseImporter):
         """
         classes: dict[str, dict] = {}
         properties: dict[str, dict] = {}
-        prefixes: dict[str, Namespace] = PREFIXES
+        prefixes: dict[str, Namespace] = PREFIXES.copy()
+
+        # 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]
@@ -246,7 +248,7 @@ class InferenceImporter(BaseImporter):
             created=datetime.now(),
             updated=datetime.now(),
             description="Inferred model from knowledge graph",
-            prefix="neat",
+            prefix="inferred",
             namespace=DEFAULT_NAMESPACE,
         )
 
@@ -262,6 +264,10 @@ class InferenceImporter(BaseImporter):
     def _read_value_type_occurrence_from_comment(cls, value_type: str, comment: str) -> int:
         return int(
             cast(
-                re.Match, re.search(rf"with value type <{value_type}> which occurs <(\d+)> times in the graph", comment)
+                re.Match,
+                re.search(
+                    rf"with value type <{value_type}> which occurs <(\d+)> times in the graph",
+                    comment,
+                ),
             ).group(1)
         )

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/rules/issues/spreadsheet.py

@@ -7,6 +7,7 @@ from typing import Any, ClassVar
 from cognite.client.data_classes import data_modeling as dm
 from cognite.client.data_classes.data_modeling import ContainerId, ViewId
 from pydantic_core import ErrorDetails
+from rdflib import Namespace
 
 from cognite.neat.issues import MultiValueError
 from cognite.neat.utils.spreadsheet import SpreadsheetRead
@@ -23,6 +24,7 @@ __all__ = [
     "InvalidRowError",
     "InvalidPropertyError",
     "InvalidClassError",
+    "PrefixNamespaceCollisionError",
     "InvalidContainerError",
     "InvalidViewError",
     "InvalidRowUnknownSheetError",
@@ -44,13 +46,18 @@ class InvalidSheetError(NeatValidationError, ABC):
     @classmethod
     @abstractmethod
     def from_pydantic_error(
-        cls, error: ErrorDetails, read_info_by_sheet: dict[str, SpreadsheetRead] | None = None
+        cls,
+        error: ErrorDetails,
+        read_info_by_sheet: dict[str, SpreadsheetRead] | None = None,
     ) -> Self:
         raise NotImplementedError
 
     @classmethod
     def from_pydantic_errors(
-        cls, errors: list[ErrorDetails], read_info_by_sheet: dict[str, SpreadsheetRead] | None = None, **kwargs: Any
+        cls,
+        errors: list[ErrorDetails],
+        read_info_by_sheet: dict[str, SpreadsheetRead] | None = None,
+        **kwargs: Any,
     ) -> "list[NeatValidationError]":
         output: list[NeatValidationError] = []
         for error in errors:
@@ -100,16 +107,26 @@ class InvalidRowError(InvalidSheetError, ABC):
     def __lt__(self, other: object) -> bool:
         if not isinstance(other, InvalidRowError):
             return NotImplemented
-        return (self.sheet_name, self.row, self.column) < (other.sheet_name, other.row, other.column)
+        return (self.sheet_name, self.row, self.column) < (
+            other.sheet_name,
+            other.row,
+            other.column,
+        )
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, InvalidRowError):
             return NotImplemented
-        return (self.sheet_name, self.row, self.column) == (other.sheet_name, other.row, other.column)
+        return (self.sheet_name, self.row, self.column) == (
+            other.sheet_name,
+            other.row,
+            other.column,
+        )
 
     @classmethod
     def from_pydantic_error(
-        cls, error: ErrorDetails, read_info_by_sheet: dict[str, SpreadsheetRead] | None = None
+        cls,
+        error: ErrorDetails,
+        read_info_by_sheet: dict[str, SpreadsheetRead] | None = None,
     ) -> Self:
         sheet_name, _, row, column, *__ = error["loc"]
         reader = (read_info_by_sheet or {}).get(str(sheet_name), SpreadsheetRead())
@@ -173,7 +190,9 @@ class InvalidRowUnknownSheetError(InvalidRowError):
 
     @classmethod
     def from_pydantic_error(
-        cls, error: ErrorDetails, read_info_by_sheet: dict[str, SpreadsheetRead] | None = None
+        cls,
+        error: ErrorDetails,
+        read_info_by_sheet: dict[str, SpreadsheetRead] | None = None,
     ) -> Self:
         sheet_name, _, row, column, *__ = error["loc"]
         reader = (read_info_by_sheet or {}).get(str(sheet_name), SpreadsheetRead())
@@ -294,6 +313,27 @@ class ParentClassesNotDefinedError(NeatValidationError):
         return f"Parent classes {', '.join(self.classes[0])} are not defined. This may be a mistake."
 
 
+@dataclass(frozen=True)
+class PrefixNamespaceCollisionError(NeatValidationError):
+    description = "Same namespaces are assigned to different prefixes."
+    fix = "Make sure that each unique namespace is assigned to a unique prefix"
+
+    namespaces: list[Namespace]
+    prefixes: list[str]
+
+    def dump(self) -> dict[str, list[str]]:
+        output = super().dump()
+        output["prefixes"] = self.prefixes
+        output["namespaces"] = self.namespaces
+        return output
+
+    def message(self) -> str:
+        return (
+            f"Namespaces {', '.join(self.namespaces)} are assigned multiple times."
+            f" Impacted prefixes: {', '.join(self.prefixes)}."
+        )
+
+
 @dataclass(frozen=True)
 class ValueTypeNotDefinedError(NeatValidationError):
     description = "Value types referred by properties are not defined in Rules."

{cognite_neat-0.85.4 → cognite_neat-0.85.6}/cognite/neat/rules/models/information/_rules.py

@@ -259,7 +259,7 @@ class InformationRules(BaseRules):
     metadata: InformationMetadata = Field(alias="Metadata")
     properties: SheetList[InformationProperty] = Field(alias="Properties")
     classes: SheetList[InformationClass] = Field(alias="Classes")
-    prefixes: dict[str, Namespace] = Field(default_factory=lambda: PREFIXES.copy())
+    prefixes: dict[str, Namespace] = Field(default_factory=lambda: PREFIXES.copy(), alias="Prefixes")
     last: "InformationRules | None" = Field(None, alias="Last")
     reference: "InformationRules | None" = Field(None, alias="Reference")
 
@@ -267,6 +267,8 @@ class InformationRules(BaseRules):
     def parse_str(cls, values: Any) -> Any:
         if isinstance(values, dict):
             return {key: Namespace(value) if isinstance(value, str) else value for key, value in values.items()}
+        elif values is None:
+            values = PREFIXES.copy()
         return values
 
     @model_validator(mode="after")