cognite-neat 0.76.0__py3-none-any.whl → 0.76.2__py3-none-any.whl

cognite/neat/_version.py

@@ -1 +1 @@
-__version__ = "0.76.0"
+__version__ = "0.76.2"

cognite/neat/app/api/routers/core.py

@@ -9,7 +9,7 @@ from fastapi import APIRouter, UploadFile
 
 from cognite.neat.app.api.configuration import NEAT_APP
 from cognite.neat.rules import exporters, importers
-from cognite.neat.rules.models.rules import DMSRules, RoleTypes
+from cognite.neat.rules.models import DMSRules, RoleTypes
 
 router = APIRouter()
 

cognite/neat/app/api/routers/rules.py

@@ -12,7 +12,7 @@ from cognite.neat.legacy.rules import importers as legacy_importers
 from cognite.neat.legacy.rules.models._base import EntityTypes
 from cognite.neat.legacy.rules.models.rules import Class, Classes, Metadata, Properties, Property, Rules
 from cognite.neat.rules import importers
-from cognite.neat.rules.models.rules import RoleTypes
+from cognite.neat.rules.models import RoleTypes
 from cognite.neat.workflows.steps.data_contracts import RulesData
 from cognite.neat.workflows.steps.lib.current.rules_exporter import RulesToExcel
 from cognite.neat.workflows.steps.lib.current.rules_importer import ExcelToRules

cognite/neat/graph/extractors/_mock_graph_generator.py

@@ -14,10 +14,10 @@ from rdflib import RDF, Literal, Namespace, URIRef
 
 from cognite.neat.graph.models import Triple
 from cognite.neat.rules.analysis import InformationArchitectRulesAnalysis
+from cognite.neat.rules.models import DMSRules, InformationRules
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
-from cognite.neat.rules.models.rules import DMSRules, InformationRules
-from cognite.neat.rules.models.rules._information_rules import InformationProperty
+from cognite.neat.rules.models.information import InformationProperty
 from cognite.neat.utils.utils import remove_namespace
 
 from ._base import BaseExtractor

cognite/neat/rules/_shared.py

@@ -1,5 +1,5 @@
 from typing import TypeAlias
 
-from cognite.neat.rules.models.rules import DMSRules, DomainRules, InformationRules
+from cognite.neat.rules.models import DMSRules, DomainRules, InformationRules
 
 Rules: TypeAlias = DomainRules | InformationRules | DMSRules

cognite/neat/rules/analysis/_information_rules.py

@@ -7,10 +7,10 @@ from typing import Any, cast
 import pandas as pd
 from pydantic import ValidationError
 
+from cognite.neat.rules.models import SchemaCompleteness
+from cognite.neat.rules.models._rdfpath import TransformationRuleType
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes, ParentClassEntity, ReferenceEntity
-from cognite.neat.rules.models.rdfpath import TransformationRuleType
-from cognite.neat.rules.models.rules._base import SchemaCompleteness
-from cognite.neat.rules.models.rules._information_rules import InformationClass, InformationProperty, InformationRules
+from cognite.neat.rules.models.information import InformationClass, InformationProperty, InformationRules
 from cognite.neat.utils.utils import get_inheritance_path
 
 from ._base import BaseAnalysis, DataModelingScenario

cognite/neat/rules/exporters/_base.py

@@ -6,7 +6,7 @@ from typing import Generic, TypeVar
 from cognite.client import CogniteClient
 
 from cognite.neat.rules._shared import Rules
-from cognite.neat.rules.models.rules import DMSRules, InformationRules, RoleTypes
+from cognite.neat.rules.models import DMSRules, InformationRules, RoleTypes
 
 from ._models import UploadResult
 

cognite/neat/rules/exporters/_rules2dms.py

@@ -11,10 +11,8 @@ from cognite.client.exceptions import CogniteAPIError
 from cognite.neat.rules import issues
 from cognite.neat.rules._shared import Rules
 from cognite.neat.rules.issues import IssueList
-from cognite.neat.rules.models.rules import InformationRules
-from cognite.neat.rules.models.rules._base import ExtensionCategory, SheetList
-from cognite.neat.rules.models.rules._dms_architect_rules import DMSContainer, DMSRules
-from cognite.neat.rules.models.rules._dms_schema import DMSSchema, PipelineSchema
+from cognite.neat.rules.models import InformationRules
+from cognite.neat.rules.models.dms import DMSRules, DMSSchema, PipelineSchema
 from cognite.neat.utils.cdf_loaders import (
     ContainerLoader,
     DataModelingLoader,
@@ -116,47 +114,9 @@ class DMSExporter(CDFExporter[DMSSchema]):
             dms_rules = rules.as_dms_architect_rules()
         else:
             raise ValueError(f"{type(rules).__name__} cannot be exported to DMS")
-
-        is_solution_model = (
-            dms_rules.reference and dms_rules.metadata.external_id != dms_rules.reference.metadata.external_id
+        return dms_rules.as_schema(
+            include_ref=True, include_pipeline=self.export_pipeline, instance_space=self.instance_space
         )
-        is_new_model = dms_rules.reference is None
-        if is_new_model or is_solution_model:
-            return dms_rules.as_schema(False, self.export_pipeline, self.instance_space)
-
-        # This is an extension of an existing model.
-        reference_rules = cast(DMSRules, dms_rules.reference).model_copy(deep=True)
-        reference_schema = reference_rules.as_schema(include_ref=False, include_pipeline=self.export_pipeline)
-
-        # Todo Move this to an appropriate location
-        # Merging Reference with User Rules
-        combined_rules = dms_rules.model_copy(deep=True)
-        existing_containers = {container.class_ for container in combined_rules.containers or []}
-        if combined_rules.containers is None:
-            combined_rules.containers = SheetList[DMSContainer](data=[])
-        for container in reference_rules.containers or []:
-            if container.class_ not in existing_containers:
-                container.reference = None
-                combined_rules.containers.append(container)
-        existing_views = {view.class_ for view in combined_rules.views}
-        for view in reference_rules.views:
-            if view.class_ not in existing_views:
-                view.reference = None
-                combined_rules.views.append(view)
-        existing_properties = {(property_.class_, property_.property_) for property_ in combined_rules.properties}
-        for property_ in reference_rules.properties:
-            if (property_.class_, property_.property_) not in existing_properties:
-                property_.reference = None
-                combined_rules.properties.append(property_)
-
-        schema = combined_rules.as_schema(True, self.export_pipeline, self.instance_space)
-
-        if dms_rules.metadata.extension in (ExtensionCategory.addition, ExtensionCategory.reshape):
-            # We do not freeze views as they might be changed, even for addition,
-            # in case, for example, new properties are added. The validation will catch this.
-            schema.frozen_ids.update(set(reference_schema.containers.as_ids()))
-            schema.frozen_ids.update(set(reference_schema.node_types.as_ids()))
-        return schema
 
     def delete_from_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> Iterable[UploadResult]:
         schema, to_export = self._prepare_schema_and_exporters(rules, client)
@@ -165,8 +125,7 @@ class DMSExporter(CDFExporter[DMSSchema]):
         # as they are sorted in the order of creation and we need to delete them in reverse order
         for all_items, loader in reversed(to_export):
             all_item_ids = loader.get_ids(all_items)
-            skipped = sum(1 for item_id in all_item_ids if item_id in schema.frozen_ids)
-            item_ids = [item_id for item_id in all_item_ids if item_id not in schema.frozen_ids]
+            item_ids = [item_id for item_id in all_item_ids]
             cdf_items = loader.retrieve(item_ids)
             cdf_item_by_id = {loader.get_id(item): item for item in cdf_items}
             items = [item for item in all_items if loader.get_id(item) in item_ids]
@@ -200,7 +159,7 @@ class DMSExporter(CDFExporter[DMSSchema]):
             yield UploadResult(
                 name=loader.resource_name,
                 deleted=deleted,
-                skipped=skipped,
+                skipped=0,
                 failed_deleted=failed_deleted,
                 error_messages=error_messages,
             )
@@ -215,8 +174,7 @@ class DMSExporter(CDFExporter[DMSSchema]):
         for all_items, loader in to_export:
             issue_list = IssueList()
             all_item_ids = loader.get_ids(all_items)
-            skipped = sum(1 for item_id in all_item_ids if item_id in schema.frozen_ids)
-            item_ids = [item_id for item_id in all_item_ids if item_id not in schema.frozen_ids]
+            item_ids = [item_id for item_id in all_item_ids]
             cdf_items = loader.retrieve(item_ids)
             cdf_item_by_id = {loader.get_id(item): item for item in cdf_items}
             items = [item for item in all_items if loader.get_id(item) in item_ids]
@@ -243,6 +201,7 @@ class DMSExporter(CDFExporter[DMSSchema]):
 
             created = len(to_create)
             failed_created = 0
+            skipped = 0
 
             if self.existing_handling in ["update", "force"]:
                 changed = len(to_update)

cognite/neat/rules/exporters/_rules2excel.py

@@ -12,8 +12,14 @@ from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
 from openpyxl.worksheet.worksheet import Worksheet
 
 from cognite.neat.rules._shared import Rules
-from cognite.neat.rules.models.rules import DMSRules, DomainRules, InformationRules
-from cognite.neat.rules.models.rules._base import RoleTypes, SchemaCompleteness, SheetEntity
+from cognite.neat.rules.models import (
+    DMSRules,
+    DomainRules,
+    InformationRules,
+    RoleTypes,
+    SchemaCompleteness,
+    SheetEntity,
+)
 
 from ._base import BaseExporter
 
@@ -113,7 +119,7 @@ class ExcelExporter(BaseExporter[Workbook]):
 
     def _write_sheets(self, workbook: Workbook, dumped_rules: dict[str, Any], rules: Rules, is_reference: bool = False):
         for sheet_name, headers in rules.headers_by_sheet(by_alias=True).items():
-            if sheet_name in ("Metadata", "prefixes", "Reference", "is_reference"):
+            if sheet_name in ("Metadata", "prefixes", "Reference", "Last"):
                 continue
             if is_reference:
                 sheet = workbook.create_sheet(f"Ref{sheet_name}")

cognite/neat/rules/exporters/_rules2ontology.py

@@ -11,10 +11,10 @@ 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 InformationArchitectRulesAnalysis
+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
-from cognite.neat.rules.models.rules import DMSRules
-from cognite.neat.rules.models.rules._information_rules import (
+from cognite.neat.rules.models.information import (
     InformationClass,
     InformationMetadata,
     InformationProperty,

cognite/neat/rules/exporters/_rules2yaml.py

@@ -6,7 +6,7 @@ from typing import Literal, get_args
 import yaml
 
 from cognite.neat.rules._shared import Rules
-from cognite.neat.rules.models.rules._base import RoleTypes
+from cognite.neat.rules.models import RoleTypes
 
 from ._base import BaseExporter
 

cognite/neat/rules/exporters/_validation.py

@@ -4,8 +4,8 @@ from typing import Literal, overload
 
 from cognite.neat.exceptions import wrangle_warnings
 from cognite.neat.rules import exceptions
-from cognite.neat.rules.models.rules import InformationRules
-from cognite.neat.rules.models.rules._types._base import DMS_PROPERTY_ID_COMPLIANCE_REGEX, VIEW_ID_COMPLIANCE_REGEX
+from cognite.neat.rules.models import InformationRules
+from cognite.neat.rules.models._types._base import DMS_PROPERTY_ID_COMPLIANCE_REGEX, VIEW_ID_COMPLIANCE_REGEX
 
 
 @overload

cognite/neat/rules/importers/_base.py

@@ -11,7 +11,7 @@ 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.models.rules import DMSRules, InformationRules, RoleTypes
+from cognite.neat.rules.models import DMSRules, InformationRules, RoleTypes
 
 
 class BaseImporter(ABC):

cognite/neat/rules/importers/_dms2rules.py

@@ -2,7 +2,7 @@ from collections import Counter
 from collections.abc import Sequence
 from datetime import datetime
 from pathlib import Path
-from typing import Literal, cast, overload
+from typing import Any, Literal, cast, overload
 
 from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
@@ -20,7 +20,22 @@ from cognite.client.utils import ms_to_datetime
 from cognite.neat.rules import issues
 from cognite.neat.rules.importers._base import BaseImporter, Rules, _handle_issues
 from cognite.neat.rules.issues import IssueList, ValidationIssue
+from cognite.neat.rules.models import (
+    DataModelType,
+    DMSRules,
+    DMSSchema,
+    ExtensionCategory,
+    RoleTypes,
+    SchemaCompleteness,
+    SheetList,
+)
 from cognite.neat.rules.models.data_types import DataType
+from cognite.neat.rules.models.dms import (
+    DMSContainer,
+    DMSMetadata,
+    DMSProperty,
+    DMSView,
+)
 from cognite.neat.rules.models.entities import (
     ClassEntity,
     ContainerEntity,
@@ -29,15 +44,6 @@ from cognite.neat.rules.models.entities import (
     ViewEntity,
     ViewPropertyEntity,
 )
-from cognite.neat.rules.models.rules import DMSRules, DMSSchema, RoleTypes
-from cognite.neat.rules.models.rules._base import DataModelType, ExtensionCategory, SchemaCompleteness
-from cognite.neat.rules.models.rules._dms_architect_rules import (
-    DMSContainer,
-    DMSMetadata,
-    DMSProperty,
-    DMSView,
-    SheetList,
-)
 
 
 class DMSImporter(BaseImporter):
@@ -47,10 +53,17 @@ class DMSImporter(BaseImporter):
         read_issues: Sequence[ValidationIssue] | None = None,
         metadata: DMSMetadata | None = None,
     ):
-        self.schema = schema
+        # Calling this root schema to distinguish it from
+        # * User Schema
+        # * Reference Schema
+        self.root_schema = schema
         self.metadata = metadata
         self.issue_list = IssueList(read_issues)
-        self._container_by_id = {container.as_id(): container for container in schema.containers}
+        self._all_containers_by_id = {container.as_id(): container for container in schema.containers}
+        if self.root_schema.reference:
+            self._all_containers_by_id.update(
+                {container.as_id(): container for container in self.root_schema.reference.containers}
+            )
 
     @classmethod
     def from_data_model_id(cls, client: CogniteClient, data_model_id: DataModelIdentifier) -> "DMSImporter":
@@ -134,130 +147,102 @@ class DMSImporter(BaseImporter):
             # 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 len(self.schema.data_models) == 0:
+        if len(self.root_schema.data_models) == 0:
             self.issue_list.append(issues.importing.NoDataModelError("No data model found."))
             return self._return_or_raise(self.issue_list, errors)
 
-        if len(self.schema.data_models) > 2:
+        with _handle_issues(
+            self.issue_list,
+        ) as future:
+            schema_completeness = SchemaCompleteness.complete
+            data_model_type = DataModelType.enterprise
+            reference: DMSRules | None = None
+            if ref_schema := self.root_schema.reference:
+                # Reference should always be an enterprise model.
+                reference = DMSRules(
+                    **self._create_rule_components(
+                        ref_schema, self._create_default_metadata(ref_schema.views), DataModelType.enterprise
+                    )
+                )
+                schema_completeness = SchemaCompleteness.extended
+                data_model_type = DataModelType.solution
+
+            user_rules = DMSRules(
+                **self._create_rule_components(self.root_schema, self.metadata, data_model_type, schema_completeness),
+                reference=reference,
+            )
+
+        if future.result == "failure" or self.issue_list.has_errors:
+            return self._return_or_raise(self.issue_list, errors)
+
+        return self._to_output(user_rules, self.issue_list, errors, role)
+
+    def _create_rule_components(
+        self,
+        schema: DMSSchema,
+        metadata: DMSMetadata | None = None,
+        data_model_type: DataModelType | None = None,
+        schema_completeness: SchemaCompleteness | None = None,
+    ) -> dict[str, Any]:
+        if len(schema.data_models) > 2:
             # Creating a DataModelEntity to convert the data model id to a string.
             self.issue_list.append(
                 issues.importing.MultipleDataModelsWarning(
-                    [str(DataModelEntity.from_id(model.as_id())) for model in self.schema.data_models]
+                    [str(DataModelEntity.from_id(model.as_id())) for model in schema.data_models]
                 )
             )
 
-        data_model = self.schema.data_models[0]
+        data_model = schema.data_models[0]
 
         properties = SheetList[DMSProperty]()
-        ref_properties = SheetList[DMSProperty]()
-        for view in self.schema.views:
+        for view in schema.views:
             view_id = view.as_id()
             view_entity = ViewEntity.from_id(view_id)
             class_entity = view_entity.as_class()
             for prop_id, prop in (view.properties or {}).items():
                 dms_property = self._create_dms_property(prop_id, prop, view_entity, class_entity)
                 if dms_property is not None:
-                    if view_id in self.schema.frozen_ids:
-                        ref_properties.append(dms_property)
-                    else:
-                        properties.append(dms_property)
+                    properties.append(dms_property)
 
         data_model_view_ids: set[dm.ViewId] = {
             view.as_id() if isinstance(view, dm.View | dm.ViewApply) else view for view in data_model.views or []
         }
 
-        metadata = self.metadata or DMSMetadata.from_data_model(data_model)
-        metadata.data_model_type = self._infer_data_model_type(metadata.space)
-        if ref_properties:
-            metadata.schema_ = SchemaCompleteness.extended
-
-        with _handle_issues(
-            self.issue_list,
-        ) as future:
-            user_rules = DMSRules(
-                metadata=metadata,
-                properties=properties,
-                containers=SheetList[DMSContainer](
-                    data=[
-                        DMSContainer.from_container(container)
-                        for container in self.schema.containers
-                        if container.as_id() not in self.schema.frozen_ids
-                    ]
-                ),
-                views=SheetList[DMSView](
-                    data=[
-                        DMSView.from_view(view, in_model=view.as_id() in data_model_view_ids)
-                        for view in self.schema.views
-                        if view.as_id() not in self.schema.frozen_ids
-                    ]
-                ),
-                reference=self._create_reference_rules(ref_properties),
-            )
-
-        if future.result == "failure" or self.issue_list.has_errors:
-            return self._return_or_raise(self.issue_list, errors)
-
-        return self._to_output(user_rules, self.issue_list, errors, role)
-
-    def _create_reference_rules(self, properties: SheetList[DMSProperty]) -> DMSRules | None:
-        if not properties:
-            return None
-
-        if len(self.schema.data_models) == 2:
-            data_model = self.schema.data_models[1]
-            data_model_view_ids: set[dm.ViewId] = {
-                view.as_id() if isinstance(view, dm.View | dm.ViewApply) else view for view in data_model.views or []
-            }
-            metadata = self._create_metadata_from_model(data_model)
-        else:
-            data_model_view_ids = set()
-            now = datetime.now().replace(microsecond=0)
-            space = Counter(prop.view.space for prop in properties).most_common(1)[0][0]
-            metadata = DMSMetadata(
-                schema_=SchemaCompleteness.complete,
-                extension=ExtensionCategory.addition,
-                space=space,
-                external_id="Unknown",
-                version="0.1.0",
-                creator=["Unknown"],
-                created=now,
-                updated=now,
-            )
-
-        metadata.data_model_type = DataModelType.enterprise
-        return DMSRules(
+        metadata = metadata or DMSMetadata.from_data_model(data_model)
+        if data_model_type is not None:
+            metadata.data_model_type = data_model_type
+        if schema_completeness is not None:
+            metadata.schema_ = schema_completeness
+        return dict(
             metadata=metadata,
             properties=properties,
-            views=SheetList[DMSView](
-                data=[
-                    DMSView.from_view(view, in_model=not data_model_view_ids or (view.as_id() in data_model_view_ids))
-                    for view in self.schema.views
-                    if view.as_id() in self.schema.frozen_ids
-                ]
-            ),
             containers=SheetList[DMSContainer](
-                data=[
-                    DMSContainer.from_container(container)
-                    for container in self.schema.containers
-                    if container.as_id() in self.schema.frozen_ids
-                ]
+                data=[DMSContainer.from_container(container) for container in schema.containers]
+            ),
+            views=SheetList[DMSView](
+                data=[DMSView.from_view(view, in_model=view.as_id() in data_model_view_ids) for view in schema.views]
             ),
-            reference=None,
         )
 
-    def _infer_data_model_type(self, space: str) -> DataModelType:
-        if self.schema.referenced_spaces() - {space}:
-            # If the data model has containers, views, node types in another space
-            # we assume it is a solution model.
-            return DataModelType.solution
-        else:
-            # All containers, views, node types are in the same space as the data model
-            return DataModelType.enterprise
+    @classmethod
+    def _create_default_metadata(cls, views: Sequence[dm.View | dm.ViewApply]) -> DMSMetadata:
+        now = datetime.now().replace(microsecond=0)
+        space = Counter(view.space for view in views).most_common(1)[0][0]
+        return DMSMetadata(
+            schema_=SchemaCompleteness.complete,
+            extension=ExtensionCategory.addition,
+            space=space,
+            external_id="Unknown",
+            version="0.1.0",
+            creator=["Unknown"],
+            created=now,
+            updated=now,
+        )
 
     def _create_dms_property(
         self, prop_id: str, prop: ViewPropertyApply, view_entity: ViewEntity, class_entity: ClassEntity
     ) -> DMSProperty | None:
-        if isinstance(prop, dm.MappedPropertyApply) and prop.container not in self._container_by_id:
+        if isinstance(prop, dm.MappedPropertyApply) and prop.container not in self._all_containers_by_id:
             self.issue_list.append(
                 issues.importing.MissingContainerWarning(
                     view_id=str(view_entity),
@@ -268,7 +253,7 @@ class DMSImporter(BaseImporter):
             return None
         if (
             isinstance(prop, dm.MappedPropertyApply)
-            and prop.container_property_identifier not in self._container_by_id[prop.container].properties
+            and prop.container_property_identifier not in self._all_containers_by_id[prop.container].properties
         ):
             self.issue_list.append(
                 issues.importing.MissingContainerPropertyWarning(
@@ -315,7 +300,7 @@ class DMSImporter(BaseImporter):
 
     def _container_prop_unsafe(self, prop: dm.MappedPropertyApply) -> dm.ContainerProperty:
         """This method assumes you have already checked that the container with property exists."""
-        return self._container_by_id[prop.container].properties[prop.container_property_identifier]
+        return self._all_containers_by_id[prop.container].properties[prop.container_property_identifier]
 
     def _get_relation_type(self, prop: ViewPropertyApply) -> Literal["edge", "reverse", "direct"] | None:
         if isinstance(prop, SingleEdgeConnectionApply | MultiEdgeConnectionApply) and prop.direction == "outwards":
@@ -380,7 +365,7 @@ class DMSImporter(BaseImporter):
     def _get_index(self, prop: ViewPropertyApply, prop_id) -> list[str] | None:
         if not isinstance(prop, dm.MappedPropertyApply):
             return None
-        container = self._container_by_id[prop.container]
+        container = self._all_containers_by_id[prop.container]
         index: list[str] = []
         for index_name, index_obj in (container.indexes or {}).items():
             if isinstance(index_obj, BTreeIndex | InvertedIndex) and prop_id in index_obj.properties:
@@ -390,7 +375,7 @@ class DMSImporter(BaseImporter):
     def _get_constraint(self, prop: ViewPropertyApply, prop_id: str) -> list[str] | None:
         if not isinstance(prop, dm.MappedPropertyApply):
             return None
-        container = self._container_by_id[prop.container]
+        container = self._all_containers_by_id[prop.container]
         unique_constraints: list[str] = []
         for constraint_name, constraint_obj in (container.constraints or {}).items():
             if isinstance(constraint_obj, dm.RequiresConstraint):

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

@@ -23,7 +23,7 @@ from cognite.neat.rules.importers._dtdl2rules.spec import (
 from cognite.neat.rules.issues import IssueList, ValidationIssue
 from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_NAME, DataType, Json, String
 from cognite.neat.rules.models.entities import ClassEntity, ParentClassEntity
-from cognite.neat.rules.models.rules._information_rules import InformationClass, InformationProperty
+from cognite.neat.rules.models.information import InformationClass, InformationProperty
 
 
 class _DTDLConverter:

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

@@ -12,9 +12,8 @@ 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 IssueList, ValidationIssue
-from cognite.neat.rules.models.rules import InformationRules, RoleTypes
-from cognite.neat.rules.models.rules._base import SchemaCompleteness, SheetList
-from cognite.neat.rules.models.rules._information_rules import InformationClass, InformationProperty
+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
 
 

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

@@ -4,7 +4,7 @@ import numpy as np
 import pandas as pd
 from rdflib import OWL, Graph
 
-from cognite.neat.rules.models.rules._base import MatchType
+from cognite.neat.rules.models._base import MatchType
 from cognite.neat.utils.utils import remove_namespace
 
 

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

@@ -4,8 +4,8 @@ import re
 from rdflib import Graph, Namespace
 
 from cognite.neat.constants import DEFAULT_NAMESPACE
-from cognite.neat.rules.models.rules._base import RoleTypes, SchemaCompleteness
-from cognite.neat.rules.models.rules._types._base import (
+from cognite.neat.rules.models import RoleTypes, SchemaCompleteness
+from cognite.neat.rules.models._types._base import (
     PREFIX_COMPLIANCE_REGEX,
     VERSION_COMPLIANCE_REGEX,
 )

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

@@ -4,7 +4,7 @@ import numpy as np
 import pandas as pd
 from rdflib import Graph
 
-from cognite.neat.rules.models.rules._base import MatchType
+from cognite.neat.rules.models._base import MatchType
 from cognite.neat.utils.utils import remove_namespace
 
 from ._owl2classes import _data_type_property_class, _object_property_class, _thing_class

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

@@ -10,8 +10,8 @@ from rdflib import DC, DCTERMS, OWL, RDF, RDFS, SKOS, Graph
 
 from cognite.neat.rules.importers._base import BaseImporter, Rules
 from cognite.neat.rules.issues import IssueList
+from cognite.neat.rules.models import InformationRules, RoleTypes
 from cognite.neat.rules.models.data_types import _XSD_TYPES
-from cognite.neat.rules.models.rules import InformationRules, RoleTypes
 
 from ._owl2classes import parse_owl_classes
 from ._owl2metadata import parse_owl_metadata

cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -13,9 +13,15 @@ from pandas import ExcelFile
 
 from cognite.neat.rules import issues
 from cognite.neat.rules.issues import IssueList
-from cognite.neat.rules.models.rules import RULES_PER_ROLE, DMSRules, DomainRules, InformationRules
-from cognite.neat.rules.models.rules._base import RoleTypes, SchemaCompleteness
-from cognite.neat.rules.models.rules._dms_rules_write import DMSRulesWrite
+from cognite.neat.rules.models import (
+    RULES_PER_ROLE,
+    DMSRules,
+    DomainRules,
+    InformationRules,
+    RoleTypes,
+    SchemaCompleteness,
+)
+from cognite.neat.rules.models.dms import DMSRulesInput
 from cognite.neat.utils.auxiliary import local_import
 from cognite.neat.utils.spreadsheet import SpreadsheetRead, read_individual_sheet
 
@@ -227,7 +233,7 @@ class ExcelImporter(BaseImporter):
         ) as future:
             rules: Rules
             if rules_cls is DMSRules:
-                rules = DMSRulesWrite.load(sheets).as_read()
+                rules = DMSRulesInput.load(sheets).as_rules()
             else:
                 rules = rules_cls.model_validate(sheets)  # type: ignore[attr-defined]
 

cognite/neat/rules/importers/_yaml2rules.py

@@ -5,8 +5,8 @@ import yaml
 
 from cognite.neat.rules import issues
 from cognite.neat.rules.issues import IssueList, NeatValidationError, ValidationIssue
-from cognite.neat.rules.models.rules import RULES_PER_ROLE, DMSRules, RoleTypes
-from cognite.neat.rules.models.rules._dms_rules_write import DMSRulesWrite
+from cognite.neat.rules.models import RULES_PER_ROLE, DMSRules, RoleTypes
+from cognite.neat.rules.models.dms import DMSRulesInput
 
 from ._base import BaseImporter, Rules, _handle_issues
 
@@ -98,7 +98,7 @@ class YAMLImporter(BaseImporter):
         with _handle_issues(issue_list) as future:
             rules: Rules
             if rules_model is DMSRules:
-                rules = DMSRulesWrite.load(self.raw_data).as_read()
+                rules = DMSRulesInput.load(self.raw_data).as_rules()
             else:
                 rules = rules_model.model_validate(self.raw_data)