cognite-neat 0.76.3__py3-none-any.whl → 0.77.1__py3-none-any.whl

cognite/neat/_version.py

@@ -1 +1 @@
-__version__ = "0.76.3"
+__version__ = "0.77.1"

cognite/neat/rules/exporters/_rules2dms.py

@@ -5,7 +5,14 @@ from typing import Literal, TypeAlias, cast
 
 from cognite.client import CogniteClient
 from cognite.client.data_classes._base import CogniteResource, CogniteResourceList
-from cognite.client.data_classes.data_modeling import DataModelApply, DataModelId
+from cognite.client.data_classes.data_modeling import (
+    ContainerApplyList,
+    DataModelApply,
+    DataModelApplyList,
+    DataModelId,
+    SpaceApplyList,
+    ViewApplyList,
+)
 from cognite.client.exceptions import CogniteAPIError
 
 from cognite.neat.rules import issues
@@ -114,9 +121,7 @@ class DMSExporter(CDFExporter[DMSSchema]):
             dms_rules = rules.as_dms_architect_rules()
         else:
             raise ValueError(f"{type(rules).__name__} cannot be exported to DMS")
-        return dms_rules.as_schema(
-            include_ref=True, include_pipeline=self.export_pipeline, instance_space=self.instance_space
-        )
+        return dms_rules.as_schema(include_pipeline=self.export_pipeline, instance_space=self.instance_space)
 
     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)
@@ -266,13 +271,13 @@ class DMSExporter(CDFExporter[DMSSchema]):
         schema = self.export(rules)
         to_export: list[tuple[CogniteResourceList, ResourceLoader]] = []
         if self.export_components.intersection({"all", "spaces"}):
-            to_export.append((schema.spaces, SpaceLoader(client)))
+            to_export.append((SpaceApplyList(schema.spaces.values()), SpaceLoader(client)))
         if self.export_components.intersection({"all", "containers"}):
-            to_export.append((schema.containers, ContainerLoader(client)))
+            to_export.append((ContainerApplyList(schema.containers.values()), ContainerLoader(client)))
         if self.export_components.intersection({"all", "views"}):
-            to_export.append((schema.views, ViewLoader(client, self.existing_handling)))
+            to_export.append((ViewApplyList(schema.views.values()), ViewLoader(client, self.existing_handling)))
         if self.export_components.intersection({"all", "data_models"}):
-            to_export.append((schema.data_models, DataModelLoader(client)))
+            to_export.append((DataModelApplyList([schema.data_model]), DataModelLoader(client)))
         if isinstance(schema, PipelineSchema):
             to_export.append((schema.databases, RawDatabaseLoader(client)))
             to_export.append((schema.raw_tables, RawTableLoader(client)))

cognite/neat/rules/importers/_dms2rules.py

@@ -6,7 +6,7 @@ from typing import Any, Literal, cast, overload
 
 from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
-from cognite.client.data_classes.data_modeling import DataModelIdentifier
+from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
 from cognite.client.data_classes.data_modeling.containers import BTreeIndex, InvertedIndex
 from cognite.client.data_classes.data_modeling.views import (
     MultiEdgeConnectionApply,
@@ -39,7 +39,6 @@ from cognite.neat.rules.models.dms import (
 from cognite.neat.rules.models.entities import (
     ClassEntity,
     ContainerEntity,
-    DataModelEntity,
     DMSUnknownEntity,
     ViewEntity,
     ViewPropertyEntity,
@@ -52,56 +51,92 @@ class DMSImporter(BaseImporter):
         schema: DMSSchema,
         read_issues: Sequence[ValidationIssue] | None = None,
         metadata: DMSMetadata | None = None,
+        ref_metadata: DMSMetadata | None = None,
     ):
         # Calling this root schema to distinguish it from
         # * User Schema
         # * Reference Schema
         self.root_schema = schema
         self.metadata = metadata
+        self.ref_metadata = ref_metadata
         self.issue_list = IssueList(read_issues)
-        self._all_containers_by_id = {container.as_id(): container for container in schema.containers}
+        self._all_containers_by_id = schema.containers.copy()
         if self.root_schema.reference:
-            self._all_containers_by_id.update(
-                {container.as_id(): container for container in self.root_schema.reference.containers}
-            )
+            self._all_containers_by_id.update(self.root_schema.reference.containers)
 
     @classmethod
-    def from_data_model_id(cls, client: CogniteClient, data_model_id: DataModelIdentifier) -> "DMSImporter":
+    def from_data_model_id(
+        cls,
+        client: CogniteClient,
+        data_model_id: DataModelIdentifier,
+        reference_model_id: DataModelIdentifier | None = None,
+    ) -> "DMSImporter":
         """Create a DMSImporter ready to convert the given data model to rules.
 
         Args:
             client: Instantiated CogniteClient to retrieve data model.
+            reference_model_id: The reference data model to retrieve. This is the data model that
+                the given data model is built on top of, typically, an enterprise data model.
             data_model_id: Data Model to retrieve.
 
         Returns:
             DMSImporter: DMSImporter instance
         """
-        data_models = client.data_modeling.data_models.retrieve(data_model_id, inline_views=True)
-        if len(data_models) == 0:
+        data_model_ids = [data_model_id, reference_model_id] if reference_model_id else [data_model_id]
+        data_models = client.data_modeling.data_models.retrieve(data_model_ids, inline_views=True)
+
+        user_models = cls._find_model_in_list(data_models, data_model_id)
+        if len(user_models) == 0:
             return cls(DMSSchema(), [issues.importing.NoDataModelError(f"Data model {data_model_id} not found")])
-        data_model = data_models.latest_version()
+        user_model = user_models.latest_version()
+
+        if reference_model_id:
+            ref_models = cls._find_model_in_list(data_models, reference_model_id)
+            if len(ref_models) == 0:
+                return cls(
+                    DMSSchema(), [issues.importing.NoDataModelError(f"Data model {reference_model_id} not found")]
+                )
+            ref_model: dm.DataModel[dm.View] | None = ref_models.latest_version()
+        else:
+            ref_model = None
 
         try:
-            schema = DMSSchema.from_data_model(client, data_model)
+            schema = DMSSchema.from_data_model(client, user_model, ref_model)
         except Exception as e:
             return cls(DMSSchema(), [issues.importing.APIError(str(e))])
 
-        created = ms_to_datetime(data_model.created_time)
-        updated = ms_to_datetime(data_model.last_updated_time)
+        metadata = cls._create_metadata_from_model(user_model)
+        ref_metadata = cls._create_metadata_from_model(ref_model) if ref_model else None
 
-        metadata = cls._create_metadata_from_model(data_model, created, updated)
+        return cls(schema, [], metadata, ref_metadata)
 
-        return cls(schema, [], metadata)
+    @classmethod
+    def _find_model_in_list(
+        cls, data_models: dm.DataModelList[dm.View], model_id: DataModelIdentifier
+    ) -> dm.DataModelList[dm.View]:
+        identifier = DataModelId.load(model_id)
+        return dm.DataModelList[dm.View](
+            [
+                model
+                for model in data_models
+                if (model.space, model.external_id) == (identifier.space, identifier.external_id)
+            ]
+        )
 
     @classmethod
     def _create_metadata_from_model(
         cls,
         model: dm.DataModel[dm.View] | dm.DataModelApply,
-        created: datetime | None = None,
-        updated: datetime | None = None,
     ) -> DMSMetadata:
         description, creator = DMSMetadata._get_description_and_creator(model.description)
-        now = datetime.now().replace(microsecond=0)
+
+        if isinstance(model, dm.DataModel):
+            created = ms_to_datetime(model.created_time)
+            updated = ms_to_datetime(model.last_updated_time)
+        else:
+            now = datetime.now().replace(microsecond=0)
+            created = now
+            updated = now
         return DMSMetadata(
             schema_=SchemaCompleteness.complete,
             extension=ExtensionCategory.addition,
@@ -109,8 +144,8 @@ class DMSImporter(BaseImporter):
             external_id=model.external_id,
             name=model.name or model.external_id,
             version=model.version or "0.1.0",
-            updated=updated or now,
-            created=created or now,
+            updated=updated,
+            created=created,
             creator=creator,
             description=description,
         )
@@ -147,28 +182,33 @@ 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.root_schema.data_models) == 0:
+        if not self.root_schema.data_model:
             self.issue_list.append(issues.importing.NoDataModelError("No data model found."))
             return self._return_or_raise(self.issue_list, errors)
-
+        model = self.root_schema.data_model
         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:
+            if (ref_schema := self.root_schema.reference) and (ref_model := ref_schema.data_model):
                 # Reference should always be an enterprise model.
                 reference = DMSRules(
                     **self._create_rule_components(
-                        ref_schema, self._create_default_metadata(ref_schema.views), DataModelType.enterprise
+                        ref_model,
+                        ref_schema,
+                        self.ref_metadata or self._create_default_metadata(list(ref_schema.views.values())),
+                        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),
+                **self._create_rule_components(
+                    model, self.root_schema, self.metadata, data_model_type, schema_completeness
+                ),
                 reference=reference,
             )
 
@@ -179,24 +219,14 @@ class DMSImporter(BaseImporter):
 
     def _create_rule_components(
         self,
+        data_model: dm.DataModelApply,
         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 schema.data_models]
-                )
-            )
-
-        data_model = schema.data_models[0]
-
         properties = SheetList[DMSProperty]()
-        for view in schema.views:
-            view_id = view.as_id()
+        for view_id, view in schema.views.items():
             view_entity = ViewEntity.from_id(view_id)
             class_entity = view_entity.as_class()
             for prop_id, prop in (view.properties or {}).items():
@@ -217,10 +247,13 @@ class DMSImporter(BaseImporter):
             metadata=metadata,
             properties=properties,
             containers=SheetList[DMSContainer](
-                data=[DMSContainer.from_container(container) for container in schema.containers]
+                data=[DMSContainer.from_container(container) for container in schema.containers.values()]
             ),
             views=SheetList[DMSView](
-                data=[DMSView.from_view(view, in_model=view.as_id() in data_model_view_ids) for view in schema.views]
+                data=[
+                    DMSView.from_view(view, in_model=view_id in data_model_view_ids)
+                    for view_id, view in schema.views.items()
+                ]
             ),
         )
 

cognite/neat/rules/models/dms/_exporter.py

@@ -22,6 +22,7 @@ from cognite.neat.rules.models.entities import (
     ViewPropertyEntity,
 )
 from cognite.neat.rules.models.wrapped_entities import DMSFilter, HasDataFilter, NodeTypeFilter
+from cognite.neat.utils.cdf_classes import ContainerApplyDict, NodeApplyDict, SpaceApplyDict, ViewApplyDict
 
 from ._rules import DMSMetadata, DMSProperty, DMSRules, DMSView
 from ._schema import DMSSchema, PipelineSchema
@@ -42,18 +43,18 @@ class _DMSExporter:
     def __init__(
         self,
         rules: DMSRules,
-        include_ref: bool = True,
         include_pipeline: bool = False,
         instance_space: str | None = None,
     ):
-        self.include_ref = include_ref
         self.include_pipeline = include_pipeline
         self.instance_space = instance_space
         self.rules = rules
         self._ref_schema = rules.reference.as_schema() if rules.reference else None
         if self._ref_schema:
             # We skip version as that will always be missing in the reference
-            self._ref_views_by_id = {dm.ViewId(view.space, view.external_id): view for view in self._ref_schema.views}
+            self._ref_views_by_id = {
+                dm.ViewId(view.space, view.external_id): view for view in self._ref_schema.views.values()
+            }
         else:
             self._ref_views_by_id = {}
 
@@ -67,7 +68,7 @@ class _DMSExporter:
         views_not_in_model = {view.view.as_id() for view in rules.views if not view.in_model}
         data_model = rules.metadata.as_data_model()
         data_model.views = sorted(
-            [view_id for view_id in views.as_ids() if view_id not in views_not_in_model],
+            [view_id for view_id in views.keys() if view_id not in views_not_in_model],
             key=lambda v: v.as_tuple(),  # type: ignore[union-attr]
         )
 
@@ -75,7 +76,7 @@ class _DMSExporter:
 
         output = DMSSchema(
             spaces=spaces,
-            data_models=dm.DataModelApplyList([data_model]),
+            data_model=data_model,
             views=views,
             containers=containers,
             node_types=node_types,
@@ -91,31 +92,30 @@ class _DMSExporter:
     def _create_spaces(
         self,
         metadata: DMSMetadata,
-        containers: dm.ContainerApplyList,
-        views: dm.ViewApplyList,
+        containers: ContainerApplyDict,
+        views: ViewApplyDict,
         data_model: dm.DataModelApply,
-    ) -> dm.SpaceApplyList:
-        used_spaces = {container.space for container in containers} | {view.space for view in views}
+    ) -> SpaceApplyDict:
+        used_spaces = {container.space for container in containers.values()} | {view.space for view in views.values()}
         if len(used_spaces) == 1:
             # We skip the default space and only use this space for the data model
             data_model.space = used_spaces.pop()
-            spaces = dm.SpaceApplyList([dm.SpaceApply(space=data_model.space)])
+            spaces = SpaceApplyDict([dm.SpaceApply(space=data_model.space)])
         else:
             used_spaces.add(metadata.space)
-            spaces = dm.SpaceApplyList([dm.SpaceApply(space=space) for space in used_spaces])
-        if self.instance_space and self.instance_space not in {space.space for space in spaces}:
-            spaces.append(dm.SpaceApply(space=self.instance_space, name=self.instance_space))
+            spaces = SpaceApplyDict([dm.SpaceApply(space=space) for space in used_spaces])
+        if self.instance_space and self.instance_space not in spaces:
+            spaces[self.instance_space] = dm.SpaceApply(space=self.instance_space, name=self.instance_space)
         return spaces
 
     def _create_views_with_node_types(
         self,
         view_properties_by_id: dict[dm.ViewId, list[DMSProperty]],
-    ) -> tuple[dm.ViewApplyList, dm.NodeApplyList]:
-        views = dm.ViewApplyList([dms_view.as_view() for dms_view in self.rules.views])
+    ) -> tuple[ViewApplyDict, NodeApplyDict]:
+        views = ViewApplyDict([dms_view.as_view() for dms_view in self.rules.views])
         dms_view_by_id = {dms_view.view.as_id(): dms_view for dms_view in self.rules.views}
 
-        for view in views:
-            view_id = view.as_id()
+        for view_id, view in views.items():
             view.properties = {}
             if not (view_properties := view_properties_by_id.get(view_id)):
                 continue
@@ -126,14 +126,13 @@ class _DMSExporter:
 
         data_model_type = self.rules.metadata.data_model_type
         unique_node_types: set[dm.NodeId] = set()
-        parent_views = {parent for view in views for parent in view.implements or []}
-        for view in views:
-            dms_view = dms_view_by_id.get(view.as_id())
-            dms_properties = view_properties_by_id.get(view.as_id(), [])
+        parent_views = {parent for view in views.values() for parent in view.implements or []}
+        for view_id, view in views.items():
+            dms_view = dms_view_by_id.get(view_id)
+            dms_properties = view_properties_by_id.get(view_id, [])
             view_filter = self._create_view_filter(view, dms_view, data_model_type, dms_properties)
 
             view.filter = view_filter.as_dms_filter()
-
             if isinstance(view_filter, NodeTypeFilter):
                 unique_node_types.update(view_filter.nodes)
                 if view.as_id() in parent_views:
@@ -153,7 +152,7 @@ class _DMSExporter:
                     issues.dms.HasDataFilterOnViewWithReferencesWarning(view.as_id(), list(references)), stacklevel=2
                 )
 
-        return views, dm.NodeApplyList(
+        return views, NodeApplyDict(
             [dm.NodeApply(space=node.space, external_id=node.external_id) for node in unique_node_types]
         )
 
@@ -176,7 +175,7 @@ class _DMSExporter:
     def _create_containers(
         self,
         container_properties_by_id: dict[dm.ContainerId, list[DMSProperty]],
-    ) -> dm.ContainerApplyList:
+    ) -> ContainerApplyDict:
         containers = dm.ContainerApplyList(
             [dms_container.as_container() for dms_container in self.rules.containers or []]
         )
@@ -231,9 +230,7 @@ class _DMSExporter:
                     for name, const in container.constraints.items()
                     if not (isinstance(const, dm.RequiresConstraint) and const.require in container_to_drop)
                 }
-        return dm.ContainerApplyList(
-            [container for container in containers if container.as_id() not in container_to_drop]
-        )
+        return ContainerApplyDict([container for container in containers if container.as_id() not in container_to_drop])
 
     def _gather_properties(self) -> tuple[dict[dm.ContainerId, list[DMSProperty]], dict[dm.ViewId, list[DMSProperty]]]:
         container_properties_by_id: dict[dm.ContainerId, list[DMSProperty]] = defaultdict(list)
@@ -256,6 +253,7 @@ class _DMSExporter:
         dms_properties: list[DMSProperty],
     ) -> DMSFilter:
         selected_filter_name = (dms_view and dms_view.filter_ and dms_view.filter_.name) or ""
+
         if dms_view and dms_view.filter_ and not dms_view.filter_.is_empty:
             # Has Explicit Filter, use it
             return dms_view.filter_

cognite/neat/rules/models/dms/_rules.py

@@ -41,7 +41,7 @@ from cognite.neat.rules.models.entities import (
     ViewEntityList,
     ViewPropertyEntity,
 )
-from cognite.neat.rules.models.wrapped_entities import HasDataFilter, NodeTypeFilter
+from cognite.neat.rules.models.wrapped_entities import HasDataFilter, NodeTypeFilter, RawFilter
 
 from ._schema import DMSSchema
 
@@ -257,7 +257,7 @@ class DMSView(SheetEntity):
     description: str | None = Field(alias="Description", default=None)
     implements: ViewEntityList | None = Field(None, alias="Implements")
     reference: URLEntity | ReferenceEntity | None = Field(alias="Reference", default=None, union_mode="left_to_right")
-    filter_: HasDataFilter | NodeTypeFilter | None = Field(None, alias="Filter")
+    filter_: HasDataFilter | NodeTypeFilter | RawFilter | None = Field(None, alias="Filter")
     in_model: bool = Field(True, alias="In Model")
     class_: ClassEntity = Field(alias="Class (linage)")
 
@@ -345,12 +345,10 @@ class DMSRules(BaseRules):
         space, version = self.metadata.space, self.metadata.version
         return _DMSRulesSerializer(info, space, version).clean(dumped)
 
-    def as_schema(
-        self, include_ref: bool = False, include_pipeline: bool = False, instance_space: str | None = None
-    ) -> DMSSchema:
+    def as_schema(self, include_pipeline: bool = False, instance_space: str | None = None) -> DMSSchema:
         from ._exporter import _DMSExporter
 
-        return _DMSExporter(self, include_ref, include_pipeline, instance_space).to_schema()
+        return _DMSExporter(self, include_pipeline, instance_space).to_schema()
 
     def as_information_architect_rules(self) -> "InformationRules":
         from ._converter import _DMSRulesConverter

cognite/neat/rules/models/dms/_schema.py

@@ -30,6 +30,13 @@ from cognite.neat.rules.issues.dms import (
     MissingViewError,
 )
 from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE
+from cognite.neat.utils.cdf_classes import (
+    CogniteResourceDict,
+    ContainerApplyDict,
+    NodeApplyDict,
+    SpaceApplyDict,
+    ViewApplyDict,
+)
 from cognite.neat.utils.cdf_loaders import ViewLoader
 from cognite.neat.utils.cdf_loaders.data_classes import RawTableWrite, RawTableWriteList
 from cognite.neat.utils.text import to_camel
@@ -43,12 +50,12 @@ else:
 
 @dataclass
 class DMSSchema:
-    data_models: dm.DataModelApplyList = field(default_factory=lambda: dm.DataModelApplyList([]))
-    spaces: dm.SpaceApplyList = field(default_factory=lambda: dm.SpaceApplyList([]))
-    views: dm.ViewApplyList = field(default_factory=lambda: dm.ViewApplyList([]))
-    containers: dm.ContainerApplyList = field(default_factory=lambda: dm.ContainerApplyList([]))
-    node_types: dm.NodeApplyList = field(default_factory=lambda: dm.NodeApplyList([]))
-    # The last schema is the previous version of the data model. In the case, extension=additio, this
+    data_model: dm.DataModelApply | None = None
+    spaces: SpaceApplyDict = field(default_factory=SpaceApplyDict)
+    views: ViewApplyDict = field(default_factory=ViewApplyDict)
+    containers: ContainerApplyDict = field(default_factory=ContainerApplyDict)
+    node_types: NodeApplyDict = field(default_factory=NodeApplyDict)
+    # The last schema is the previous version of the data model. In the case, extension=addition, this
     # should not be modified.
     last: "DMSSchema | None" = None
     # Reference is typically the Enterprise model, while this is the solution model.
@@ -57,29 +64,28 @@ class DMSSchema:
     _FIELD_NAME_BY_RESOURCE_TYPE: ClassVar[dict[str, str]] = {
         "container": "containers",
         "view": "views",
-        "datamodel": "data_models",
+        "datamodel": "data_model",
         "space": "spaces",
         "node": "node_types",
     }
 
     def _get_mapped_container_from_view(self, view_id: dm.ViewId) -> set[dm.ContainerId]:
         # index all views, including ones from reference
-        indexed_views = {
-            **{view.as_id(): view for view in self.views},
-            **({view.as_id(): view for view in self.reference.views} if self.reference else {}),
-        }
+        view_by_id = self.views.copy()
+        if self.reference:
+            view_by_id.update(self.reference.views)
 
-        if view_id not in indexed_views:
+        if view_id not in view_by_id:
             raise ValueError(f"View {view_id} not found")
 
-        indexed_implemented_views = {id_: view.implements for id_, view in indexed_views.items()}
+        indexed_implemented_views = {id_: view.implements for id_, view in view_by_id.items()}
         view_inheritance = get_inheritance_path(view_id, indexed_implemented_views)
 
-        directly_referenced_containers = indexed_views[view_id].referenced_containers()
+        directly_referenced_containers = view_by_id[view_id].referenced_containers()
         inherited_referenced_containers = set()
 
         for view_id in view_inheritance:
-            if implemented_view := indexed_views.get(view_id):
+            if implemented_view := view_by_id.get(view_id):
                 inherited_referenced_containers |= implemented_view.referenced_containers()
             else:
                 raise IncompleteSchemaError(missing_component=view_id).as_exception()
@@ -95,18 +101,49 @@ class DMSSchema:
         return cls.from_data_model(client, data_model)
 
     @classmethod
-    def from_data_model(cls, client: CogniteClient, data_model: dm.DataModel) -> "DMSSchema":
+    def from_data_model(
+        cls,
+        client: CogniteClient,
+        data_model: dm.DataModel[dm.View],
+        reference_model: dm.DataModel[dm.View] | None = None,
+    ) -> "DMSSchema":
+        """Create a schema from a data model.
+
+        If a reference model is provided, the schema will include a reference schema. To determine which views,
+        and containers to put in the reference schema, the following rule is applied:
+
+            If a view or container space is different from the data model space,
+            it will be included in the reference schema.*
+
+        *One exception to this rule is if a view is directly referenced by the data model. In this case, the view will
+        be included in the data model schema, even if the space is different.
+
+        Args:
+            client: The Cognite client used for retrieving components referenced by the data model.
+            data_model: The data model to create the schema from.
+            reference_model: (Optional) The reference model to include in the schema.
+                This is typically the Enterprise model.
+
+        Returns:
+            DMSSchema: The schema created from the data model.
+        """
         views = dm.ViewList(data_model.views)
+
+        data_model_write = data_model.as_write()
+        data_model_write.views = list(views.as_ids())
+
+        if reference_model:
+            views.extend(reference_model.views)
+
         container_ids = views.referenced_containers()
         containers = client.data_modeling.containers.retrieve(list(container_ids))
         cls._append_referenced_containers(client, containers)
 
-        space_read = client.data_modeling.spaces.retrieve(data_model.space)
-        if space_read is None:
-            raise ValueError(f"Space {data_model.space} not found")
-        space = space_read.as_write()
-        data_model_write = data_model.as_write()
-        data_model_write.views = list(views.as_write())
+        space_ids = [data_model.space, reference_model.space] if reference_model else [data_model.space]
+        space_read = client.data_modeling.spaces.retrieve(space_ids)
+        if len(space_read) != len(space_ids):
+            raise ValueError(f"Space(s) {space_read} not found")
+        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.
@@ -119,13 +156,51 @@ class DMSSchema:
         # as the read format contains all properties from all parents, while the write formate should not contain
         # properties from any parents.
         # The ViewLoader as_write method looks up parents and remove properties from them.
-        view_write = dm.ViewApplyList([view_loader.as_write(view) for view in views])
+        view_write = ViewApplyDict([view_loader.as_write(view) for view in views])
+
+        container_write = ContainerApplyDict(containers.as_write())
+        user_space = data_model.space
+        if reference_model:
+            user_model_view_ids = set(data_model_write.views)
+            ref_model_write = reference_model.as_write()
+            ref_model_write.views = [view.as_id() for view in reference_model.views]
+
+            ref_views = ViewApplyDict(
+                [
+                    view
+                    for view_id, view in view_write.items()
+                    if (view.space != user_space) or (view_id not in user_model_view_ids)
+                ]
+            )
+            view_write = ViewApplyDict(
+                [
+                    view
+                    for view_id, view in view_write.items()
+                    if view.space == user_space or view_id in user_model_view_ids
+                ]
+            )
+
+            ref_containers = ContainerApplyDict(
+                [container for container in container_write.values() if container.space != user_space]
+            )
+            container_write = ContainerApplyDict(
+                [container for container in container_write.values() if container.space == user_space]
+            )
 
+            ref_schema: DMSSchema | None = cls(
+                spaces=SpaceApplyDict([s for s in space_write if s.space != user_space]),
+                data_model=ref_model_write,
+                views=ref_views,
+                containers=ref_containers,
+            )
+        else:
+            ref_schema = None
         return cls(
-            spaces=dm.SpaceApplyList([space]),
-            data_models=dm.DataModelApplyList([data_model_write]),
+            spaces=SpaceApplyDict([s for s in space_write if s.space == user_space]),
+            data_model=data_model_write,
             views=view_write,
-            containers=containers.as_write(),
+            containers=container_write,
+            reference=ref_schema,
         )
 
     @classmethod
@@ -183,33 +258,32 @@ class DMSSchema:
         data_models = path_dir / "data_models"
         data_models.mkdir(parents=True, exist_ok=True)
         if "spaces" not in exclude_set:
-            for space in self.spaces:
+            for space in self.spaces.values():
                 (data_models / f"{space.space}.space.yaml").write_text(
                     space.dump_yaml(), newline=new_line, encoding=encoding
                 )
-        if "data_models" not in exclude_set:
-            for model in self.data_models:
-                (data_models / f"{model.external_id}.datamodel.yaml").write_text(
-                    model.dump_yaml(), newline=new_line, encoding=encoding
-                )
+        if "data_models" not in exclude_set and self.data_model:
+            (data_models / f"{self.data_model.external_id}.datamodel.yaml").write_text(
+                self.data_model.dump_yaml(), newline=new_line, encoding=encoding
+            )
         if "views" not in exclude_set and self.views:
             view_dir = data_models / "views"
             view_dir.mkdir(parents=True, exist_ok=True)
-            for view in self.views:
+            for view in self.views.values():
                 (view_dir / f"{view.external_id}.view.yaml").write_text(
                     view.dump_yaml(), newline=new_line, encoding=encoding
                 )
         if "containers" not in exclude_set and self.containers:
             container_dir = data_models / "containers"
             container_dir.mkdir(parents=True, exist_ok=True)
-            for container in self.containers:
+            for container in self.containers.values():
                 (container_dir / f"{container.external_id}.container.yaml").write_text(
                     container.dump_yaml(), newline=new_line, encoding=encoding
                 )
         if "node_types" not in exclude_set and self.node_types:
             node_dir = data_models / "nodes"
             node_dir.mkdir(parents=True, exist_ok=True)
-            for node in self.node_types:
+            for node in self.node_types.values():
                 (node_dir / f"{node.external_id}.node.yaml").write_text(
                     node.dump_yaml(), newline=new_line, encoding=encoding
                 )
@@ -263,21 +337,22 @@ class DMSSchema:
         exclude_set = exclude or set()
         with zipfile.ZipFile(zip_file, "w") as zip_ref:
             if "spaces" not in exclude_set:
-                for space in self.spaces:
+                for space in self.spaces.values():
                     zip_ref.writestr(f"data_models/{space.space}.space.yaml", space.dump_yaml())
-            if "data_models" not in exclude_set:
-                for model in self.data_models:
-                    zip_ref.writestr(f"data_models/{model.external_id}.datamodel.yaml", model.dump_yaml())
+            if "data_models" not in exclude_set and self.data_model:
+                zip_ref.writestr(
+                    f"data_models/{self.data_model.external_id}.datamodel.yaml", self.data_model.dump_yaml()
+                )
             if "views" not in exclude_set:
-                for view in self.views:
+                for view in self.views.values():
                     zip_ref.writestr(f"data_models/views/{view.external_id}.view.yaml", view.dump_yaml())
             if "containers" not in exclude_set:
-                for container in self.containers:
+                for container in self.containers.values():
                     zip_ref.writestr(
                         f"data_models/containers{container.external_id}.container.yaml", container.dump_yaml()
                     )
             if "node_types" not in exclude_set:
-                for node in self.node_types:
+                for node in self.node_types.values():
                     zip_ref.writestr(f"data_models/nodes/{node.external_id}.node.yaml", node.dump_yaml())
 
     @classmethod
@@ -308,10 +383,30 @@ class DMSSchema:
         loaded: dict[str, Any] = {}
         for attr in fields(cls):
             if items := data_dict.get(attr.name) or data_dict.get(to_camel(attr.name)):
-                try:
-                    loaded[attr.name] = attr.type.load(items)
-                except Exception as e:
-                    loaded[attr.name] = cls._load_individual_resources(items, attr, str(e), context.get(attr.name, []))
+                if attr.name == "data_model":
+                    if isinstance(items, list) and len(items) > 1:
+                        warnings.warn(
+                            issues.importing.MultipleDataModelsWarning(
+                                [item.get("externalId", "Unknown") for item in items]
+                            ),
+                            stacklevel=2,
+                        )
+                    item = items[0] if isinstance(items, list) else items
+                    try:
+                        loaded[attr.name] = dm.DataModelApply.load(item)
+                    except Exception as e:
+                        data_model_file = context.get(attr.name, [Path("UNKNOWN")])[0]
+                        warnings.warn(
+                            issues.fileread.FailedLoadWarning(data_model_file, dm.DataModelApply.__name__, str(e)),
+                            stacklevel=2,
+                        )
+                else:
+                    try:
+                        loaded[attr.name] = attr.type.load(items)
+                    except Exception as e:
+                        loaded[attr.name] = cls._load_individual_resources(
+                            items, attr, str(e), context.get(attr.name, [])
+                        )
         return cls(**loaded)
 
     @classmethod
@@ -353,9 +448,16 @@ class DMSSchema:
         cls_fields = sorted(fields(self), key=lambda f: f.name) if sort else fields(self)
         for attr in cls_fields:
             if items := getattr(self, attr.name):
-                items = sorted(items, key=self._to_sortable_identifier) if sort else items
                 key = to_camel(attr.name) if camel_case else attr.name
-                output[key] = [item.dump(camel_case=camel_case) for item in items]
+                if isinstance(items, CogniteResourceDict):
+                    if sort:
+                        output[key] = [
+                            item.dump(camel_case) for item in sorted(items.values(), key=self._to_sortable_identifier)
+                        ]
+                    else:
+                        output[key] = items.dump(camel_case)
+                else:
+                    output[key] = items.dump(camel_case=camel_case)
         return output
 
     @classmethod
@@ -376,19 +478,19 @@ class DMSSchema:
 
     def validate(self) -> list[DMSSchemaError]:
         errors: set[DMSSchemaError] = set()
-        defined_spaces = {space.space for space in self.spaces}
-        defined_containers = {container.as_id(): container for container in self.containers}
-        defined_views = {view.as_id() for view in self.views}
+        defined_spaces = self.spaces.copy()
+        defined_containers = self.containers.copy()
+        defined_views = self.views.copy()
         if self.reference:
-            defined_spaces |= {space.space for space in self.reference.spaces}
-            defined_containers |= {container.as_id(): container for container in self.reference.containers}
-            defined_views |= {view.as_id() for view in self.reference.views}
+            defined_spaces |= self.reference.spaces
+            defined_containers |= self.reference.containers
+            defined_views |= self.reference.views
 
-        for container in self.containers:
+        for container in self.containers.values():
             if container.space not in defined_spaces:
                 errors.add(MissingSpaceError(space=container.space, referred_by=container.as_id()))
 
-        for view in self.views:
+        for view in self.views.values():
             view_id = view.as_id()
             if view.space not in defined_spaces:
                 errors.add(MissingSpaceError(space=view.space, referred_by=view_id))
@@ -458,7 +560,8 @@ class DMSSchema:
                         )
                     )
 
-        for model in self.data_models:
+        if self.data_model:
+            model = self.data_model
             if model.space not in defined_spaces:
                 errors.add(MissingSpaceError(space=model.space, referred_by=model.as_id()))
 
@@ -506,16 +609,27 @@ class DMSSchema:
             )
         return None
 
-    def referenced_spaces(self) -> set[str]:
-        referenced_spaces = {container.space for container in self.containers}
-        referenced_spaces |= {view.space for view in self.views}
-        referenced_spaces |= {container.space for view in self.views for container in view.referenced_containers()}
-        referenced_spaces |= {parent.space for view in self.views for parent in view.implements or []}
-        referenced_spaces |= {node.space for node in self.node_types}
-        referenced_spaces |= {model.space for model in self.data_models}
-        referenced_spaces |= {view.space for model in self.data_models for view in model.views or []}
-        referenced_spaces |= {s.space for s in self.spaces}
+    def referenced_spaces(self, include_indirect_references: bool = True) -> set[str]:
+        """Get the spaces referenced by the schema.
 
+        Args:
+            include_indirect_references (bool): If True, the spaces referenced by as view.implements, and
+                view.referenced_containers will be included in the output.
+        Returns:
+            set[str]: The spaces referenced by the schema.
+        """
+        referenced_spaces = {view.space for view in self.views.values()}
+        referenced_spaces |= {container.space for container in self.containers.values()}
+        if include_indirect_references:
+            referenced_spaces |= {
+                container.space for view in self.views.values() for container in view.referenced_containers()
+            }
+            referenced_spaces |= {parent.space for view in self.views.values() for parent in view.implements or []}
+        referenced_spaces |= {node.space for node in self.node_types.values()}
+        if self.data_model:
+            referenced_spaces |= {self.data_model.space}
+            referenced_spaces |= {view.space for view in self.data_model.views or []}
+        referenced_spaces |= {s.space for s in self.spaces.values()}
         return referenced_spaces
 
 
@@ -625,19 +739,19 @@ class PipelineSchema(DMSSchema):
 
     @classmethod
     def from_dms(cls, schema: DMSSchema, instance_space: str | None = None) -> "PipelineSchema":
-        if not schema.data_models:
+        if not schema.data_model:
             raise ValueError("PipelineSchema must contain at least one data model")
-        first_data_model = schema.data_models[0]
+        first_data_model = schema.data_model
         # The database name is limited to 32 characters
         database_name = first_data_model.external_id[:32]
         instance_space = instance_space or first_data_model.space
         database = DatabaseWrite(name=database_name)
-        parent_views = {parent for view in schema.views for parent in view.implements or []}
-        container_by_id = {container.as_id(): container for container in schema.containers}
+        parent_views = {parent for view in schema.views.values() for parent in view.implements or []}
+        container_by_id = schema.containers.copy()
 
         transformations = TransformationWriteList([])
         raw_tables = RawTableWriteList([])
-        for view in schema.views:
+        for view in schema.views.values():
             if view.as_id() in parent_views:
                 # Skipping parents as they do not have their own data
                 continue
@@ -666,7 +780,7 @@ class PipelineSchema(DMSSchema):
 
         return cls(
             spaces=schema.spaces,
-            data_models=schema.data_models,
+            data_model=schema.data_model,
             views=schema.views,
             containers=schema.containers,
             transformations=transformations,

cognite/neat/rules/models/dms/_validation.py

@@ -164,10 +164,10 @@ class DMSPostValidation:
             # Everything is allowed
             return None
         # Is an extension of an existing model.
-        user_schema = self.rules.as_schema(include_ref=False)
+        user_schema = self.rules.as_schema()
         ref_schema = self.rules.reference.as_schema()
-        new_containers = {container.as_id(): container for container in user_schema.containers}
-        existing_containers = {container.as_id(): container for container in ref_schema.containers}
+        new_containers = user_schema.containers.copy()
+        existing_containers = ref_schema.containers.copy()
 
         for container_id, container in new_containers.items():
             existing_container = existing_containers.get(container_id)
@@ -193,8 +193,8 @@ class DMSPostValidation:
             # Reshape allows changes to views
             return None
 
-        new_views = {view.as_id(): view for view in user_schema.views}
-        existing_views = {view.as_id(): view for view in ref_schema.views}
+        new_views = user_schema.views.copy()
+        existing_views = ref_schema.views.copy()
         for view_id, view in new_views.items():
             existing_view = existing_views.get(view_id)
             if not existing_view or existing_view == view:
@@ -219,13 +219,13 @@ class DMSPostValidation:
 
         dms_schema = self.rules.as_schema()
 
-        for view in dms_schema.views:
-            mapped_containers = dms_schema._get_mapped_container_from_view(view.as_id())
+        for view_id, view in dms_schema.views.items():
+            mapped_containers = dms_schema._get_mapped_container_from_view(view_id)
 
             if mapped_containers and len(mapped_containers) > 10:
                 self.issue_list.append(
                     issues.dms.ViewMapsToTooManyContainersWarning(
-                        view_id=view.as_id(),
+                        view_id=view_id,
                         container_ids=mapped_containers,
                     )
                 )
@@ -236,7 +236,7 @@ class DMSPostValidation:
                 ):
                     self.issue_list.append(
                         issues.dms.HasDataFilterAppliedToTooManyContainersWarning(
-                            view_id=view.as_id(),
+                            view_id=view_id,
                             container_ids=mapped_containers,
                         )
                     )

cognite/neat/rules/models/wrapped_entities.py

@@ -1,3 +1,5 @@
+import json
+import re
 from abc import ABC, abstractmethod
 from collections.abc import Collection
 from functools import total_ordering
@@ -37,8 +39,19 @@ class WrappedEntity(BaseModel, ABC):
     def _parse(cls, data: str) -> dict:
         if data.casefold() == cls.name.casefold():
             return {"inner": None}
-        inner = data[len(cls.name) :].removeprefix("(").removesuffix(")")
-        return {"inner": [cls._inner_cls.load(entry.strip()) for entry in inner.split(",")]}
+
+        # raw filter case:
+        if cls.__name__ == "RawFilter":
+            if match := re.search(r"rawFilter\(([\s\S]*?)\)", data):
+                return {"filter": match.group(1), "inner": None}
+            else:
+                raise ValueError(f"Cannot parse {cls.name} from {data}. Ill formatted raw filter.")
+
+        # nodeType and hasData case:
+        elif inner := data[len(cls.name) :].removeprefix("(").removesuffix(")"):
+            return {"inner": [cls._inner_cls.load(entry.strip()) for entry in inner.split(",")]}
+        else:
+            raise ValueError(f"Cannot parse {cls.name} from {data}")
 
     @model_serializer(when_used="unless-none", return_type=str)
     def as_str(self) -> str:
@@ -164,3 +177,22 @@ class HasDataFilter(DMSFilter):
             # Sorting to ensure deterministic order
             containers=sorted(containers, key=lambda container: container.as_tuple())  # type: ignore[union-attr]
         )
+
+
+class RawFilter(DMSFilter):
+    name: ClassVar[str] = "rawFilter"
+    filter: str
+    inner: None = None  # type: ignore[assignment]
+
+    def as_dms_filter(self) -> dm.Filter:  # type: ignore[override]
+        try:
+            return dm.Filter.load(json.loads(self.filter))
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Error loading raw filter: {e}") from e
+
+    @property
+    def is_empty(self) -> bool:
+        return self.filter is None
+
+    def __repr__(self) -> str:
+        return self.filter

cognite/neat/utils/cdf_classes.py

@@ -0,0 +1,181 @@
+from abc import ABC, abstractmethod
+from collections.abc import (
+    ItemsView,
+    Iterable,
+    Iterator,
+    KeysView,
+    Mapping,
+    MutableMapping,
+    ValuesView,
+)
+from typing import Any, TypeVar, cast, final
+
+import pandas as pd
+import yaml
+from cognite.client.data_classes._base import T_CogniteResource
+from cognite.client.data_classes.data_modeling import (
+    ContainerApply,
+    ContainerId,
+    DataModelApply,
+    DataModelId,
+    NodeApply,
+    NodeId,
+    SpaceApply,
+    ViewApply,
+    ViewId,
+)
+from cognite.client.utils._auxiliary import load_yaml_or_json
+from cognite.client.utils._pandas_helpers import (
+    convert_nullable_int_cols,
+)
+
+T_ID = TypeVar("T_ID")
+
+
+# Inheriting from dict as we are extending it,
+# ref https://stackoverflow.com/questions/7148419/subclass-dict-userdict-dict-or-abc
+class CogniteResourceDict(dict, MutableMapping[T_ID, T_CogniteResource], ABC):
+    """CogniteResource stored in a mapping structure.
+
+    The serialization format of the CognitiveResourceDict is a list of dicts, where each dict
+    represents a CognitiveResource.
+
+    This means that the serialization methods .dump() and .load() return a list of dicts and
+    expects a list of dicts respectively.
+
+    In addition, the init method is slightly abused compared to a regular dict by allowing the input to be a
+    list of CognitiveResources.
+    """
+
+    _RESOURCE: type[T_CogniteResource]
+
+    def __init__(
+        self,
+        items: Iterable[T_CogniteResource]
+        | Iterable[tuple[T_ID, T_CogniteResource]]
+        | Mapping[T_ID, T_CogniteResource]
+        | None = None,
+    ) -> None:
+        if isinstance(items, Mapping):
+            super().__init__(items)
+        elif isinstance(items, Iterable):
+            super().__init__(item if isinstance(item, tuple) else (self._as_id(item), item) for item in items)  # type: ignore[arg-type]
+        else:
+            super().__init__()
+
+    @classmethod
+    @abstractmethod
+    def _as_id(cls, resource: T_CogniteResource) -> T_ID:
+        raise NotImplementedError
+
+    def dump(self, camel_case: bool = True) -> list[dict[str, Any]]:
+        return [value.dump(camel_case) for value in self.values()]
+
+    def dump_yaml(self) -> str:
+        return yaml.dump(self.dump(camel_case=True), sort_keys=False)
+
+    def to_pandas(self, camel_case: bool = False) -> pd.DataFrame:
+        df = pd.DataFrame(self.dump(camel_case=camel_case))
+        df = convert_nullable_int_cols(df)
+        return df
+
+    def _repr_html_(self) -> str:
+        # Pretty print the dataframe in Jupyter
+        return self.to_pandas()._repr_html_()  # type: ignore[operator]
+
+    @classmethod
+    @final
+    def load(cls: "type[T_CogniteResourceDict]", resource: Iterable[dict[str, Any]] | str) -> "T_CogniteResourceDict":
+        """Load a resource from a YAML/JSON string or iterable of dict."""
+        if isinstance(resource, str):
+            resource = load_yaml_or_json(resource)
+
+        if isinstance(resource, Iterable):
+            return cls._load(cast(Iterable, resource))
+
+        raise TypeError(f"Resource must be json or yaml str, or iterable of dicts, not {type(resource)}")
+
+    @classmethod
+    def _load(
+        cls: "type[T_CogniteResourceDict]",
+        resource_list: Iterable[dict[str, Any]],
+    ) -> "T_CogniteResourceDict":
+        resources = (cls._RESOURCE._load(resource) for resource in resource_list)
+        return cls({cls._as_id(resource): resource for resource in resources})  # type: ignore[abstract]
+
+    # The below methods are included to make better type hints in the IDE
+    def __getitem__(self, k: T_ID) -> T_CogniteResource:
+        return super().__getitem__(k)
+
+    def __setitem__(self, k: T_ID, v: T_CogniteResource) -> None:
+        super().__setitem__(k, v)
+
+    def __delitem__(self, k: T_ID) -> None:
+        super().__delitem__(k)
+
+    def __iter__(self) -> Iterator[T_ID]:
+        return super().__iter__()
+
+    def keys(self) -> KeysView[T_ID]:  # type: ignore[override]
+        return super().keys()
+
+    def values(self) -> ValuesView[T_CogniteResource]:  # type: ignore[override]
+        return super().values()
+
+    def items(self) -> ItemsView[T_ID, T_CogniteResource]:  # type: ignore[override]
+        return super().items()
+
+    def get(self, __key: T_ID, __default: Any = ...) -> T_CogniteResource:
+        return super().get(__key, __default)
+
+    def pop(self, __key: T_ID, __default: Any = ...) -> T_CogniteResource:
+        return super().pop(__key, __default)
+
+    def popitem(self) -> tuple[T_ID, T_CogniteResource]:
+        return super().popitem()
+
+    def copy(self) -> "CogniteResourceDict[T_ID, T_CogniteResource]":
+        return cast(CogniteResourceDict[T_ID, T_CogniteResource], super().copy())
+
+
+T_CogniteResourceDict = TypeVar("T_CogniteResourceDict", bound=CogniteResourceDict)
+
+
+class ViewApplyDict(CogniteResourceDict[ViewId, ViewApply]):
+    _RESOURCE = ViewApply
+
+    @classmethod
+    def _as_id(cls, resource: ViewApply) -> ViewId:
+        return resource.as_id()
+
+
+class SpaceApplyDict(CogniteResourceDict[str, SpaceApply]):
+    _RESOURCE = SpaceApply
+
+    @classmethod
+    def _as_id(cls, resource: SpaceApply) -> str:
+        return resource.space
+
+
+class ContainerApplyDict(CogniteResourceDict[ContainerId, ContainerApply]):
+    _RESOURCE = ContainerApply
+
+    @classmethod
+    def _as_id(cls, resource: ContainerApply) -> ContainerId:
+        return resource.as_id()
+
+
+class DataModelApplyDict(CogniteResourceDict[DataModelId, DataModelApply]):
+    _RESOURCE = DataModelApply
+
+    @classmethod
+    def _as_id(cls, resource: DataModelApply) -> DataModelId:
+        return resource.as_id()
+
+
+class NodeApplyDict(CogniteResourceDict[NodeId, NodeApply]):
+    _RESOURCE = NodeApply
+
+    @classmethod
+    def _as_id(cls, resource: NodeApply) -> NodeId:
+        return resource.as_id()

cognite/neat/workflows/steps/lib/current/rules_validator.py

@@ -78,9 +78,9 @@ class ValidateRulesAgainstCDF(Step):
             f"and {len(retrieved_views)} views from CDF."
         )
 
-        schema.spaces.extend(retrieved_spaces)
-        schema.containers.extend(retrieved_containers)
-        schema.views.extend(retrieved_views)
+        schema.spaces.update({space.space: space for space in retrieved_spaces})
+        schema.containers.update({container.as_id(): container for container in retrieved_containers})
+        schema.views.update({view.as_id(): view for view in retrieved_views})
 
         errors = schema.validate()
         if errors:

{cognite_neat-0.76.3.dist-info → cognite_neat-0.77.1.dist-info}/METADATA

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

{cognite_neat-0.76.3.dist-info → cognite_neat-0.77.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 cognite/neat/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
-cognite/neat/_version.py,sha256=OtWfvEnAHBJj0F1t4KUE2UmEyH4tIaTqHJzrcWyW6tI,23
+cognite/neat/_version.py,sha256=KAGTP0ql_FPeQE1WIVlTa-PVmeudJNxVGVpT_IPdAEg,23
 cognite/neat/app/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/app/api/asgi/metrics.py,sha256=nxFy7L5cChTI0a-zkCiJ59Aq8yLuIJp5c9Dg0wRXtV0,152
 cognite/neat/app/api/configuration.py,sha256=2U5M6M252swvQPQyooA1EBzFUZNtcTmuSaywfJDgckM,4232
@@ -165,14 +165,14 @@ cognite/neat/rules/exceptions.py,sha256=YLnsbXXJdDSr_szQoioEtOdqDV8PR7RdQjpMP2SW
 cognite/neat/rules/exporters/__init__.py,sha256=Gn3CjkVKHJF9Po1ZPH4wAJ-sRW9up7b2CpXm-eReV3Q,413
 cognite/neat/rules/exporters/_base.py,sha256=m63iw8xjlZbZAxGL8mn7pjGf1pW3rVv8C20_RSiu4t0,1511
 cognite/neat/rules/exporters/_models.py,sha256=vRd0P_YsrZ1eaAGGHfdTeFunaqHdaa0ZtnWiVZBR1nc,1976
-cognite/neat/rules/exporters/_rules2dms.py,sha256=BNznUtTdJ__M10I7QQf3_zdIQTET8SGFvHv5a-5louM,13529
+cognite/neat/rules/exporters/_rules2dms.py,sha256=US2IO4YTJSF_CDzau1dTpXyeHntJWVSPkMCQoUoKeC0,13688
 cognite/neat/rules/exporters/_rules2excel.py,sha256=K3D_AC6UZ-cG9ZFkqFvuDiMTdBC9ZUW9_IkkY9KsYW0,14934
 cognite/neat/rules/exporters/_rules2ontology.py,sha256=NWS3cn2927LQqW_PdQ-92OLIlmIKGNk7xh5yOMAyj94,20120
 cognite/neat/rules/exporters/_rules2yaml.py,sha256=sOSdnTJ5mXuyAJECdNnNsX6oLvgETptkpgPUQbK0n2w,3026
 cognite/neat/rules/exporters/_validation.py,sha256=OlKIyf4nhSDehJwFHDQ8Zdf6HpNfW7dSe2s67eywHu4,4078
 cognite/neat/rules/importers/__init__.py,sha256=zqNbGpvdVhYkLjWx1i9dJ3FXzYGtuQyTydUYsj-BndQ,408
 cognite/neat/rules/importers/_base.py,sha256=GUiJrYwJ25thI71iS9hCeP_iSZ0Vv8ou3z6MfD07FAk,4274
-cognite/neat/rules/importers/_dms2rules.py,sha256=HNUDix1xwNILpyb_wxwrOqnhSvdMiPKYfk4JL7AT6ks,16891
+cognite/neat/rules/importers/_dms2rules.py,sha256=UxAatq8WL0rYz4wcopY0wHcBE4JTf--FzflhMxymypY,18274
 cognite/neat/rules/importers/_dtdl2rules/__init__.py,sha256=CNR-sUihs2mnR1bPMKs3j3L4ds3vFTsrl6YycExZTfU,68
 cognite/neat/rules/importers/_dtdl2rules/_unit_lookup.py,sha256=wW4saKva61Q_i17guY0dc4OseJDQfqHy_QZBtm0OD6g,12134
 cognite/neat/rules/importers/_dtdl2rules/dtdl_converter.py,sha256=ysmWUxZ0npwrTB0uiH5jA0v37sfCwowGaYk17IyxPUU,12663
@@ -202,21 +202,22 @@ cognite/neat/rules/models/_types/_field.py,sha256=74WfCSVbTubpK4n4VsysQqCch6VI8I
 cognite/neat/rules/models/data_types.py,sha256=lanwkhwG8iHKfjYfia4v2SBTJrMeXOsqaVkVEP2QMXs,6078
 cognite/neat/rules/models/dms/__init__.py,sha256=Wzyqzz2ZIjpUbDg04CMuuIAw-f2A02DayNeqO9R-2Hw,491
 cognite/neat/rules/models/dms/_converter.py,sha256=x3u3jLnkknozoXXoAXXOWFHCsppqUwSvWv9wMOJ2F1Y,5706
-cognite/neat/rules/models/dms/_exporter.py,sha256=9EVToiib2QSxEXOzP7-xSlitpUlWSZTHar1HLIrtqxI,18908
-cognite/neat/rules/models/dms/_rules.py,sha256=CesPmLT4rC7rB_Q895nIV34lwfg3RC9NoU1wsz5l-hA,15599
+cognite/neat/rules/models/dms/_exporter.py,sha256=WTokr7gyjrpxW212kZpFfvd7zw09RRVPjAsxe_aizFo,18903
+cognite/neat/rules/models/dms/_rules.py,sha256=ZLdJLdAJGX1l5t1hChEic9TOHdculbWRhiLbUluZRRQ,15568
 cognite/neat/rules/models/dms/_rules_input.py,sha256=qfInh3JYf7XGEghxPOtIj7GY0f5_aVvnYeUBmfGV9mk,13620
-cognite/neat/rules/models/dms/_schema.py,sha256=cUAkIp7TCYVCshLZwQJcJMj_BduGSI3Y4_LwVxHUUUM,37463
+cognite/neat/rules/models/dms/_schema.py,sha256=6lJSLPoZAjFnbfFl6dmAJR0xlAsQKi_Obcxp8Lp_t-0,41973
 cognite/neat/rules/models/dms/_serializer.py,sha256=Zulj__rnaVNtrbGJPkn4dYMfMXWYyRmtNPR2Yb5zYW0,6668
-cognite/neat/rules/models/dms/_validation.py,sha256=QaNBqKi9YGqkYw_cwO_FcH3vRI2dXAORC6fjqV3D9HM,14290
+cognite/neat/rules/models/dms/_validation.py,sha256=rctt6ImSK5-fHhReH-BXbMlYu_EkTRYYE5c_JS-EQgM,14141
 cognite/neat/rules/models/domain.py,sha256=13OhG-XavE5ipU2ICaYaUhz60volkuVfbJrsp0PhaUU,2993
 cognite/neat/rules/models/entities.py,sha256=iBG84Jr1qQ7PvkMJUJzJ1oWApeONb1IACixdJSztUhk,16395
 cognite/neat/rules/models/information/__init__.py,sha256=KvbYxVk38qReGbGTrU_Y3P3Gz6Bfghk5lHSKs8DlTOI,195
 cognite/neat/rules/models/information/_converter.py,sha256=jzaIk7Q2CeU3TIGULEINwUNNyhWu-VdOW646EjH_FrI,7964
 cognite/neat/rules/models/information/_rules.py,sha256=YE7X8MsPQv-AVtl4vYtQW99moT45sYk2dI2DDS1YRO0,15546
-cognite/neat/rules/models/wrapped_entities.py,sha256=c5GkzOrYrE6SSRzIS2r8OAjhwxXpOoAO1WGc8kwiPPo,6154
+cognite/neat/rules/models/wrapped_entities.py,sha256=ThhjnNNrpgz0HeORIQ8Q894trxP73P7T_TuZj6qH2CU,7157
 cognite/neat/utils/__init__.py,sha256=l5Nyqhqo25bcQXCOb_lk01cr-UXsG8cczz_y_I0u6bg,68
 cognite/neat/utils/auxiliary.py,sha256=E2-YtddzScvN7l7j0kNYIMlfqIUT9NWMqLpcJYPK4rY,309
 cognite/neat/utils/cdf.py,sha256=dTg8wnm2916yhWT_2Jg9_PlauHCbmnuNgmpqrGU8eO0,711
+cognite/neat/utils/cdf_classes.py,sha256=NEmz5UprBlqfqZnqJkRk5xjSpzazwHbhcWsMH_GNxP8,5831
 cognite/neat/utils/cdf_loaders/__init__.py,sha256=s2aPR5XLo6WZ0ybstAJlcGFYkA7CyHW1XO-NYpL0V6o,483
 cognite/neat/utils/cdf_loaders/_base.py,sha256=j85HINIx4poGD-0dN3JPHTqjOS1XhCxv7G9s1gC1GBo,2057
 cognite/neat/utils/cdf_loaders/_data_modeling.py,sha256=RoIj2cL_j3vP6e4BlCExZU8d96p3dLitU9nsIIyesLc,11336
@@ -255,7 +256,7 @@ cognite/neat/workflows/steps/lib/current/graph_loader.py,sha256=HfGg1HRZhbV58TFu
 cognite/neat/workflows/steps/lib/current/graph_store.py,sha256=r7VTxdaz8jJQU7FJbnRDMxvEYbSAZFNMABhPyfNwiFk,6295
 cognite/neat/workflows/steps/lib/current/rules_exporter.py,sha256=wUQAZXWBCqWXe0241QSREtnNTii_tSmOkeiSPwNQRjk,22898
 cognite/neat/workflows/steps/lib/current/rules_importer.py,sha256=yDq06cvxLvEpSnTXTjwhxDie_MzHa3wO1A4cbKnrH6c,10338
-cognite/neat/workflows/steps/lib/current/rules_validator.py,sha256=fDRQiRHN9Cuph38-WruK0T1UG5H448S_GsbzdOpi0h4,4729
+cognite/neat/workflows/steps/lib/current/rules_validator.py,sha256=LwF9lXlnuPOxDSsOMMTHBi2BHc5rk08IF5zahS9yQuw,4844
 cognite/neat/workflows/steps/lib/io/__init__.py,sha256=k7IPbIq3ey19oRc5sA_15F99-O6dxzqbm1LihGRRo5A,32
 cognite/neat/workflows/steps/lib/io/io_steps.py,sha256=QAGypoi1vP32BRiIgBZ0B4qsbFMcwhzpRiVUUnWysLA,16874
 cognite/neat/workflows/steps/lib/legacy/__init__.py,sha256=725aFzVqhE0tbVOAW70zWXTGKFiYImVupRZ4C5_IkUo,274
@@ -271,8 +272,8 @@ cognite/neat/workflows/steps_registry.py,sha256=fkTX14ZA7_gkUYfWIlx7A1XbCidvqR23
 cognite/neat/workflows/tasks.py,sha256=dqlJwKAb0jlkl7abbY8RRz3m7MT4SK8-7cntMWkOYjw,788
 cognite/neat/workflows/triggers.py,sha256=_BLNplzoz0iic367u1mhHMHiUrCwP-SLK6_CZzfODX0,7071
 cognite/neat/workflows/utils.py,sha256=gKdy3RLG7ctRhbCRwaDIWpL9Mi98zm56-d4jfHDqP1E,453
-cognite_neat-0.76.3.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.76.3.dist-info/METADATA,sha256=N-fbQdrmuZ820x4fcdayOruzEbkDoCD1TU3scIJhWxo,9316
-cognite_neat-0.76.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-cognite_neat-0.76.3.dist-info/entry_points.txt,sha256=61FPqiWb25vbqB0KI7znG8nsg_ibLHBvTjYnkPvNFso,50
-cognite_neat-0.76.3.dist-info/RECORD,,
+cognite_neat-0.77.1.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.77.1.dist-info/METADATA,sha256=CXlHgF0btEegP5yLRqUsR40q8fIh3zaMU9nAefHikpQ,9316
+cognite_neat-0.77.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+cognite_neat-0.77.1.dist-info/entry_points.txt,sha256=61FPqiWb25vbqB0KI7znG8nsg_ibLHBvTjYnkPvNFso,50
+cognite_neat-0.77.1.dist-info/RECORD,,