cognite-neat 0.77.1__tar.gz → 0.77.3__tar.gz

{cognite_neat-0.77.1 → cognite_neat-0.77.3}/PKG-INFO

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

cognite_neat-0.77.3/cognite/neat/_version.py

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

{cognite_neat-0.77.1 → cognite_neat-0.77.3}/cognite/neat/rules/exporters/_rules2excel.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import itertools
-from datetime import datetime
+import json
+from datetime import datetime, timezone
 from pathlib import Path
 from types import GenericAlias
 from typing import Any, ClassVar, Literal, cast, get_args
@@ -14,14 +15,14 @@ from openpyxl.worksheet.worksheet import Worksheet
 from cognite.neat.rules._shared import Rules
 from cognite.neat.rules.models import (
     DataModelType,
-    DMSRules,
-    DomainRules,
     ExtensionCategory,
-    InformationRules,
     RoleTypes,
     SchemaCompleteness,
     SheetEntity,
 )
+from cognite.neat.rules.models.dms import DMSMetadata
+from cognite.neat.rules.models.domain import DomainMetadata
+from cognite.neat.rules.models.information import InformationMetadata
 
 from ._base import BaseExporter
 
@@ -34,9 +35,6 @@ class ExcelExporter(BaseExporter[Workbook]):
             on the different styles.
         output_role: The role to use for the exported spreadsheet. If provided, the rules will be converted to
             this role formate before being written to excel. If not provided, the role from the rules will be used.
-        new_model_id: The new model ID to use for the exported spreadsheet. This is only applicable if the input
-            rules have 'is_reference' set. If provided, the model ID will be used to automatically create the
-            new metadata sheet in the Excel file.
         dump_as: This determines how the rules are written to the Excel file. An Excel file has up to three sets of
            sheets: user, last, and reference. The user sheets are used for inputting rules from a user. The last sheets
            are used for the last version of the same model as the user, while the reference sheets are used for
@@ -49,6 +47,10 @@ class ExcelExporter(BaseExporter[Workbook]):
                change a model that has already been published to CDF and that model is in production.
              * "reference": The rules are written to the reference sheets. This is typically used when you want to build
                a new solution on top of an enterprise model.
+        new_model_id: The new model ID to use for the exported spreadsheet. This is only applicable if the input
+            rules have 'is_reference' set. If provided, the model ID will be used to automatically create the
+            new metadata sheet in the Excel file. The model id is expected to be a tuple of (prefix, title)
+            (space, external_id) for InformationRules and DMSRules respectively.
 
     The following styles are available:
 
@@ -74,8 +76,8 @@ class ExcelExporter(BaseExporter[Workbook]):
         self,
         styling: Style = "default",
         output_role: RoleTypes | None = None,
-        new_model_id: tuple[str, str, str] | None = None,
         dump_as: DumpOptions = "user",
+        new_model_id: tuple[str, str] | None = None,
     ):
         if styling not in self.style_options:
             raise ValueError(f"Invalid styling: {styling}. Valid options are {self.style_options}")
@@ -106,9 +108,11 @@ class ExcelExporter(BaseExporter[Workbook]):
         dumped_last_rules: dict[str, Any] | None = None
         dumped_reference_rules: dict[str, Any] | None = None
         if self.dump_as != "user":
-            # Writes empty reference sheets
+            action = {"last": "update", "reference": "create"}[self.dump_as]
+            metadata_creator = _MetadataCreator(action, self.new_model_id)  # type: ignore[arg-type]
+
             dumped_user_rules = {
-                "Metadata": self._create_metadata_sheet_user_rules(rules),
+                "Metadata": metadata_creator.create(rules.metadata),
             }
 
             if self.dump_as == "last":
@@ -234,82 +238,67 @@ class ExcelExporter(BaseExporter[Workbook]):
                 sheet.column_dimensions[selected_column.column_letter].width = max(current, max_length + 0.5)
         return None
 
-    def _create_metadata_sheet_user_rules(self, rules: Rules) -> dict[str, Any]:
-        metadata: dict[str, Any] = {
-            field_alias: None for field_alias in rules.metadata.model_dump(by_alias=True).keys()
-        }
-        if "creator" in metadata:
-            metadata["creator"] = "YOUR NAME"
-
-        if isinstance(rules, DomainRules):
-            return metadata
-        elif isinstance(rules, DMSRules):
-            existing_model_id = (rules.metadata.space, rules.metadata.external_id, rules.metadata.version)
-        elif isinstance(rules, InformationRules):
-            existing_model_id = (rules.metadata.prefix, rules.metadata.name, rules.metadata.version)
-        else:
-            raise ValueError(f"Unsupported rules type: {type(rules)}")
-        existing_metadata = rules.metadata.model_dump(by_alias=True)
-        if isinstance(existing_metadata["created"], datetime):
-            metadata["created"] = existing_metadata["created"].replace(tzinfo=None)
-        if isinstance(existing_metadata["updated"], datetime):
-            metadata["updated"] = existing_metadata["updated"].replace(tzinfo=None)
-        # Excel does not support timezone in datetime strings
-        now_iso = datetime.now().replace(tzinfo=None).isoformat()
-        is_info = isinstance(rules, InformationRules)
-        is_dms = isinstance(rules, DMSRules)
-        is_extension = self.new_model_id is not None or rules.reference is not None
-        is_solution = rules.metadata.data_model_type == DataModelType.solution
-
-        if is_solution and self.new_model_id:
-            metadata["prefix" if is_info else "space"] = self.new_model_id[0]  # type: ignore[index]
-            metadata["title" if is_info else "externalId"] = self.new_model_id[1]  # type: ignore[index]
-            metadata["version"] = self.new_model_id[2]  # type: ignore[index]
-        elif is_solution and self.dump_as == "reference" and rules.reference:
-            metadata["prefix" if is_info else "space"] = "YOUR_PREFIX"
-            metadata["title" if is_info else "externalId"] = "YOUR_TITLE"
-            metadata["version"] = "1"
-        else:
-            metadata["prefix" if is_info else "space"] = existing_model_id[0]
-            metadata["title" if is_info else "externalId"] = existing_model_id[1]
-            metadata["version"] = existing_model_id[2]
-
-        if is_solution and is_info and self.new_model_id:
-            metadata["namespace"] = f"http://purl.org/{self.new_model_id[0]}/"  # type: ignore[index]
-        elif is_info:
-            metadata["namespace"] = existing_metadata["namespace"]
-
-        if is_solution and is_dms and self.new_model_id:
-            metadata["name"] = self.new_model_id[1]  # type: ignore[index]
-
-        if is_solution:
-            metadata["created"] = now_iso
-        else:
-            metadata["created"] = existing_metadata["created"]
-
-        if is_solution or is_extension:
-            metadata["updated"] = now_iso
-        else:
-            metadata["updated"] = existing_metadata["updated"]
 
-        if is_solution:
-            metadata["creator"] = "YOUR NAME"
-        else:
-            metadata["creator"] = existing_metadata["creator"]
-
-        if not is_solution:
-            metadata["description"] = existing_metadata["description"]
+class _MetadataCreator:
+    creator_name = "<YOUR NAME>"
 
-        if is_extension:
-            metadata["schema"] = SchemaCompleteness.extended.value
-        else:
-            metadata["schema"] = SchemaCompleteness.complete.value
-
-        if is_solution:
-            metadata["dataModelType"] = DataModelType.solution.value
+    def __init__(
+        self,
+        action: Literal["create", "update"],
+        new_model_id: tuple[str, str] | None = None,
+    ):
+        self.action = action
+        self.new_model_id = new_model_id or ("YOUR_PREFIX", "YOUR_TITLE")
+
+    def create(self, metadata: DomainMetadata | InformationMetadata | DMSMetadata) -> dict[str, Any]:
+        now = datetime.now(timezone.utc).replace(microsecond=0, tzinfo=None)
+        if self.action == "update":
+            output = json.loads(metadata.model_dump_json(by_alias=True))
+            # This is the same for Information and DMS
+            output["updated"] = now.isoformat()
+            output["schema"] = SchemaCompleteness.extended.value
+            output["extension"] = ExtensionCategory.addition.value
+            if value := output.get("creator"):
+                output["creator"] = f"{value}, {self.creator_name}"
+            else:
+                output["creator"] = self.creator_name
+            return output
+
+        # Action "create"
+        if isinstance(metadata, DomainMetadata):
+            output = {field_alias: None for field_alias in metadata.model_dump(by_alias=True).keys()}
+            output["role"] = metadata.role.value
+            output["creator"] = self.creator_name
+            return output
+
+        new_metadata = self._create_new_info(now)
+        if isinstance(metadata, DMSMetadata):
+            from cognite.neat.rules.models.information._converter import _InformationRulesConverter
+
+            output_metadata: DMSMetadata | InformationMetadata = _InformationRulesConverter._convert_metadata_to_dms(
+                new_metadata
+            )
+        elif isinstance(metadata, InformationMetadata):
+            output_metadata = new_metadata
         else:
-            metadata["dataModelType"] = DataModelType.enterprise.value
-
-        metadata["extension"] = ExtensionCategory.addition.value
-        metadata["role"] = (self.output_role and self.output_role.value) or rules.metadata.role.value
-        return metadata
+            raise ValueError(f"Bug in Neat: Unknown metadata type: {type(metadata)}")
+
+        created = json.loads(output_metadata.model_dump_json(by_alias=True))
+        created.pop("extension", None)
+        return created
+
+    def _create_new_info(self, now: datetime) -> InformationMetadata:
+        prefix = self.new_model_id[0]
+        return InformationMetadata(
+            data_model_type=DataModelType.solution,
+            schema_=SchemaCompleteness.extended,
+            extension=ExtensionCategory.addition,
+            prefix=prefix,
+            namespace=f"http://purl.org/neat/{prefix}/",  # type: ignore[arg-type]
+            description=None,
+            version="1",
+            created=now,
+            updated=now,
+            creator=[self.creator_name],
+            name=self.new_model_id[1],
+        )

{cognite_neat-0.77.1 → cognite_neat-0.77.3}/cognite/neat/rules/importers/_dms2rules.py

@@ -61,8 +61,10 @@ class DMSImporter(BaseImporter):
         self.ref_metadata = ref_metadata
         self.issue_list = IssueList(read_issues)
         self._all_containers_by_id = schema.containers.copy()
+        self._all_view_ids = set(self.root_schema.views.keys())
         if self.root_schema.reference:
             self._all_containers_by_id.update(self.root_schema.reference.containers)
+            self._all_view_ids.update(self.root_schema.reference.views.keys())
 
     @classmethod
     def from_data_model_id(
@@ -100,15 +102,17 @@ class DMSImporter(BaseImporter):
         else:
             ref_model = None
 
-        try:
+        issue_list = IssueList()
+        with _handle_issues(issue_list) as result:
             schema = DMSSchema.from_data_model(client, user_model, ref_model)
-        except Exception as e:
-            return cls(DMSSchema(), [issues.importing.APIError(str(e))])
+
+        if result.result == "failure" or issue_list.has_errors:
+            return cls(DMSSchema(), issue_list)
 
         metadata = cls._create_metadata_from_model(user_model)
         ref_metadata = cls._create_metadata_from_model(ref_model) if ref_model else None
 
-        return cls(schema, [], metadata, ref_metadata)
+        return cls(schema, issue_list, metadata, ref_metadata)
 
     @classmethod
     def _find_model_in_list(
@@ -361,7 +365,7 @@ class DMSImporter(BaseImporter):
         elif isinstance(prop, dm.MappedPropertyApply):
             container_prop = self._container_prop_unsafe(cast(dm.MappedPropertyApply, prop))
             if isinstance(container_prop.type, dm.DirectRelation):
-                if prop.source is None:
+                if prop.source is None or prop.source not in self._all_view_ids:
                     # The warning is issued when the DMS Rules are created.
                     return DMSUnknownEntity()
                 else:

{cognite_neat-0.77.1 → cognite_neat-0.77.3}/cognite/neat/rules/issues/dms.py

@@ -30,6 +30,7 @@ __all__ = [
     "HasDataFilterAppliedToTooManyContainersWarning",
     "ReverseRelationMissingOtherSideWarning",
     "NodeTypeFilterOnParentViewWarning",
+    "MissingViewInModelWarning",
     "ChangingContainerError",
     "ChangingViewError",
 ]
@@ -293,6 +294,24 @@ class ViewMapsToTooManyContainersWarning(DMSSchemaWarning):
         return output
 
 
+@dataclass(frozen=True)
+class MissingViewInModelWarning(DMSSchemaWarning):
+    description = "The data model contains view pointing to views not present in the data model"
+    fix = "Add the view(s) to the data model"
+    error_name: ClassVar[str] = "MissingViewInModel"
+    data_model_id: dm.DataModelId
+    view_ids: set[dm.ViewId]
+
+    def message(self) -> str:
+        return f"The view(s) {self.view_ids} are missing in the data model {self.data_model_id}"
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["data_model_id"] = self.data_model_id.dump()
+        output["view_id"] = [view_id.dump() for view_id in self.view_ids]
+        return output
+
+
 @dataclass(frozen=True)
 class ContainerPropertyUsedMultipleTimesError(DMSSchemaError):
     description = "The container property is used multiple times by the same view property"
@@ -507,6 +526,26 @@ class HasDataFilterAppliedToTooManyContainersWarning(DMSSchemaWarning):
         return output
 
 
+@dataclass(frozen=True)
+class RawFilterAppliedToViewWarning(DMSSchemaWarning):
+    description = "Raw filter is applied to a view, which is against the neat data modeling lifecycle."
+    fix = "Do not use raw filter, instead use HasData filter or nodeType filter or change the data model design."
+    error_name: ClassVar[str] = "RawFilterAppliedToView"
+    view_id: dm.ViewId
+
+    def message(self) -> str:
+        return (
+            f"RawFilter applied to the view {self.view_id}."
+            " The usage of RawFilter is against the neat team recommendations and the neat data modeling lifecycle."
+            " When opting for raw filter, the user is responsible for any errors that arise in neat."
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["view_id"] = self.view_id.dump()
+        return output
+
+
 @dataclass(frozen=True)
 class NodeTypeFilterOnParentViewWarning(DMSSchemaWarning):
     description = (

{cognite_neat-0.77.1 → cognite_neat-0.77.3}/cognite/neat/rules/issues/importing.py

@@ -1,5 +1,6 @@
 from abc import ABC
 from dataclasses import dataclass
+from typing import Any
 
 from .base import NeatValidationError, ValidationWarning
 
@@ -23,6 +24,7 @@ __all__ = [
     "MissingIdentifierError",
     "UnsupportedPropertyTypeError",
     "APIError",
+    "FailedImportWarning",
 ]
 
 
@@ -259,6 +261,20 @@ class APIWarning(ModelImportWarning):
         return {"error_message": self.error_message}
 
 
+@dataclass(frozen=True)
+class FailedImportWarning(ModelImportWarning):
+    description = "Failed to import part of the model."
+    fix = "No fix is available."
+
+    identifier: set[str]
+
+    def message(self) -> str:
+        return f"Failed to import: {self.identifier}. This will be skipped."
+
+    def dump(self) -> dict[str, Any]:
+        return {"identifier": list(self.identifier)}
+
+
 @dataclass(frozen=True)
 class ModelImportError(NeatValidationError, ABC):
     description = "An error was raised during importing."

{cognite_neat-0.77.1 → cognite_neat-0.77.3}/cognite/neat/rules/models/dms/_converter.py

@@ -1,6 +1,5 @@
 import warnings
-from datetime import datetime
-from typing import cast
+from typing import TYPE_CHECKING, cast
 
 from rdflib import Namespace
 
@@ -20,7 +19,10 @@ from cognite.neat.rules.models.entities import (
 )
 from cognite.neat.rules.models.information._rules import InformationRules
 
-from ._rules import DMSProperty, DMSRules, DMSView
+from ._rules import DMSMetadata, DMSProperty, DMSRules, DMSView
+
+if TYPE_CHECKING:
+    from cognite.neat.rules.models.information._rules import InformationMetadata
 
 
 class _DMSRulesConverter:
@@ -32,31 +34,16 @@ class _DMSRulesConverter:
 
     def as_information_architect_rules(
         self,
-        created: datetime | None = None,
-        updated: datetime | None = None,
-        name: str | None = None,
-        namespace: Namespace | None = None,
     ) -> "InformationRules":
         from cognite.neat.rules.models.information._rules import (
             InformationClass,
-            InformationMetadata,
             InformationProperty,
             InformationRules,
         )
 
         dms = self.dms.metadata
-        prefix = dms.space
 
-        metadata = InformationMetadata(
-            schema_=dms.schema_,
-            prefix=prefix,
-            namespace=namespace or Namespace(f"https://purl.orgl/neat/{prefix}/"),
-            version=dms.version,
-            name=name or dms.name or "Missing name",
-            creator=dms.creator,
-            created=dms.created or created or datetime.now(),
-            updated=dms.updated or updated or datetime.now(),
-        )
+        metadata = self._convert_metadata_to_info(dms)
 
         classes = [
             InformationClass(
@@ -111,6 +98,23 @@ class _DMSRulesConverter:
             reference=self.dms.reference.as_information_architect_rules() if self.dms.reference else None,
         )
 
+    @classmethod
+    def _convert_metadata_to_info(cls, metadata: DMSMetadata) -> "InformationMetadata":
+        from cognite.neat.rules.models.information._rules import InformationMetadata
+
+        prefix = metadata.space
+        return InformationMetadata(
+            schema_=metadata.schema_,
+            prefix=prefix,
+            namespace=Namespace(f"https://purl.orgl/neat/{prefix}/"),
+            version=metadata.version,
+            description=metadata.description,
+            name=metadata.name or metadata.external_id,
+            creator=metadata.creator,
+            created=metadata.created,
+            updated=metadata.updated,
+        )
+
     @classmethod
     def _get_class_reference(cls, view: DMSView) -> ReferenceEntity | None:
         parents_other_namespace = [parent for parent in view.implements or [] if parent.prefix != view.class_.prefix]

{cognite_neat-0.77.1 → cognite_neat-0.77.3}/cognite/neat/rules/models/dms/_rules_input.py

@@ -237,7 +237,7 @@ class DMSViewInput:
     description: str | None = None
     implements: str | None = None
     reference: str | None = None
-    filter_: Literal["hasData", "nodeType"] | None = None
+    filter_: Literal["hasData", "nodeType", "rawFilter"] | None = None
     in_model: bool = True
 
     @classmethod

{cognite_neat-0.77.1 → cognite_neat-0.77.3}/cognite/neat/rules/models/dms/_schema.py

@@ -12,6 +12,7 @@ from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes import DatabaseWrite, DatabaseWriteList, TransformationWrite, TransformationWriteList
 from cognite.client.data_classes.data_modeling import ViewApply
+from cognite.client.data_classes.data_modeling.views import ReverseDirectRelation
 from cognite.client.data_classes.transformations.common import Edges, EdgeType, Nodes, ViewInfo
 
 from cognite.neat.rules import issues
@@ -28,6 +29,7 @@ from cognite.neat.rules.issues.dms import (
     MissingSourceViewError,
     MissingSpaceError,
     MissingViewError,
+    MissingViewInModelWarning,
 )
 from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE
 from cognite.neat.utils.cdf_classes import (
@@ -146,8 +148,26 @@ class DMSSchema:
         space_write = space_read.as_write()
 
         view_loader = ViewLoader(client)
-        # We need to include parent views in the schema to make sure that the schema is valid.
+
         existing_view_ids = set(views.as_ids())
+
+        # We need to include all views the edges/direct relations are pointing to have a complete schema.
+        connection_referenced_view_ids: set[dm.ViewId] = set()
+        for view in views:
+            connection_referenced_view_ids |= cls._connection_references(view)
+        connection_referenced_view_ids = connection_referenced_view_ids - existing_view_ids
+        if connection_referenced_view_ids:
+            warnings.warn(
+                MissingViewInModelWarning(data_model.as_id(), connection_referenced_view_ids), UserWarning, stacklevel=2
+            )
+            connection_referenced_views = view_loader.retrieve(list(connection_referenced_view_ids))
+            if failed := connection_referenced_view_ids - set(connection_referenced_views.as_ids()):
+                warnings.warn(
+                    issues.importing.FailedImportWarning({repr(v) for v in failed}), UserWarning, stacklevel=2
+                )
+            views.extend(connection_referenced_views)
+
+        # We need to include parent views in the schema to make sure that the schema is valid.
         parent_view_ids = {parent for view in views for parent in view.implements or []}
         parents = view_loader.retrieve_all_parents(list(parent_view_ids - existing_view_ids))
         views.extend([parent for parent in parents if parent.as_id() not in existing_view_ids])
@@ -203,6 +223,21 @@ class DMSSchema:
             reference=ref_schema,
         )
 
+    @classmethod
+    def _connection_references(cls, view: dm.View) -> set[dm.ViewId]:
+        view_ids: set[dm.ViewId] = set()
+        for prop in (view.properties or {}).values():
+            if isinstance(prop, dm.MappedProperty) and isinstance(prop.type, dm.DirectRelation):
+                if prop.source:
+                    view_ids.add(prop.source)
+            elif isinstance(prop, dm.EdgeConnection):
+                view_ids.add(prop.source)
+                if prop.edge_source:
+                    view_ids.add(prop.edge_source)
+            elif isinstance(prop, ReverseDirectRelation):
+                view_ids.add(prop.source)
+        return view_ids
+
     @classmethod
     def from_directory(cls, directory: str | Path) -> Self:
         """Load a schema from a directory containing YAML files.

{cognite_neat-0.77.1 → cognite_neat-0.77.3}/cognite/neat/rules/models/dms/_validation.py

@@ -8,6 +8,7 @@ from cognite.neat.rules.issues import IssueList
 from cognite.neat.rules.models._base import ExtensionCategory, SchemaCompleteness
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import ContainerEntity
+from cognite.neat.rules.models.wrapped_entities import RawFilter
 
 from ._rules import DMSProperty, DMSRules
 
@@ -25,6 +26,7 @@ class DMSPostValidation:
         self.issue_list = IssueList()
 
     def validate(self) -> IssueList:
+        self._validate_best_practices()
         self._consistent_container_properties()
         self._referenced_views_and_containers_are_existing()
         self._validate_extension()
@@ -241,6 +243,15 @@ class DMSPostValidation:
                         )
                     )
 
+    def _validate_best_practices(self) -> None:
+        for view in self.views:
+            if view.filter_ and isinstance(view.filter_, RawFilter):
+                self.issue_list.append(
+                    issues.dms.RawFilterAppliedToViewWarning(
+                        view_id=view.view.as_id(),
+                    )
+                )
+
     @staticmethod
     def _changed_attributes_and_properties(
         new_dumped: dict[str, Any], existing_dumped: dict[str, Any]

{cognite_neat-0.77.1 → cognite_neat-0.77.3}/cognite/neat/rules/models/information/_converter.py

@@ -1,14 +1,11 @@
 import re
 from collections import defaultdict
-from datetime import datetime
-from typing import Literal
+from typing import TYPE_CHECKING, Literal
 
 from cognite.neat.rules.models._base import (
-    DataModelType,
     SheetList,
 )
 from cognite.neat.rules.models.data_types import DataType
-from cognite.neat.rules.models.dms._rules import DMSProperty, DMSRules, DMSView
 from cognite.neat.rules.models.domain import DomainRules
 from cognite.neat.rules.models.entities import (
     ClassEntity,
@@ -22,6 +19,9 @@ from cognite.neat.rules.models.entities import (
 
 from ._rules import InformationClass, InformationMetadata, InformationProperty, InformationRules
 
+if TYPE_CHECKING:
+    from cognite.neat.rules.models.dms._rules import DMSMetadata, DMSProperty, DMSRules
+
 
 class _InformationRulesConverter:
     def __init__(self, information: InformationRules):
@@ -30,30 +30,18 @@ class _InformationRulesConverter:
     def as_domain_rules(self) -> DomainRules:
         raise NotImplementedError("DomainRules not implemented yet")
 
-    def as_dms_architect_rules(self, created: datetime | None = None, updated: datetime | None = None) -> "DMSRules":
+    def as_dms_architect_rules(self) -> "DMSRules":
         from cognite.neat.rules.models.dms._rules import (
             DMSContainer,
-            DMSMetadata,
             DMSProperty,
             DMSRules,
+            DMSView,
         )
 
         info_metadata = self.information.metadata
         default_version = info_metadata.version
         default_space = self._to_space(info_metadata.prefix)
-        space = self._to_space(info_metadata.prefix)
-
-        metadata = DMSMetadata(
-            schema_=info_metadata.schema_,
-            space=space,
-            data_model_type=DataModelType.solution if self.information.reference else DataModelType.enterprise,
-            version=info_metadata.version,
-            external_id=info_metadata.name.replace(" ", "_").lower(),
-            creator=info_metadata.creator,
-            name=info_metadata.name,
-            created=created or datetime.now(),
-            updated=updated or datetime.now(),
-        )
+        metadata = self._convert_metadata_to_dms(info_metadata)
 
         properties_by_class: dict[str, list[DMSProperty]] = defaultdict(list)
         for prop in self.information.properties:
@@ -111,6 +99,26 @@ class _InformationRulesConverter:
             reference=self.information.reference.as_dms_architect_rules() if self.information.reference else None,
         )
 
+    @classmethod
+    def _convert_metadata_to_dms(cls, metadata: InformationMetadata) -> "DMSMetadata":
+        from cognite.neat.rules.models.dms._rules import (
+            DMSMetadata,
+        )
+
+        space = cls._to_space(metadata.prefix)
+
+        return DMSMetadata(
+            schema_=metadata.schema_,
+            space=space,
+            data_model_type=metadata.data_model_type,
+            version=metadata.version,
+            external_id=metadata.name.replace(" ", "_").lower(),
+            creator=metadata.creator,
+            name=metadata.name,
+            created=metadata.created,
+            updated=metadata.updated,
+        )
+
     @classmethod
     def _as_dms_property(cls, prop: InformationProperty, default_space: str, default_version: str) -> "DMSProperty":
         """This creates the first"""

{cognite_neat-0.77.1 → cognite_neat-0.77.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cognite-neat"
-version = "0.77.1"
+version = "0.77.3"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [
@@ -129,7 +129,7 @@ twine = "*"
 pytest = { version = ">=8.0, <8.1" }
 pytest-cov = "*"
 pytest-notebook = "*"
-pytest-freezegun = "*"
+freezegun = "^1.5.1"
 pytest-xdist = "^3.6.1"
 pre-commit = "*"
 safety = "*"

cognite_neat-0.77.1/cognite/neat/_version.py

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