cognite-neat 0.72.2__py3-none-any.whl → 0.73.0__py3-none-any.whl

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

@@ -10,7 +10,6 @@ from typing import TYPE_CHECKING, Any, ClassVar, Literal, cast
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import PropertyType as CognitePropertyType
 from cognite.client.data_classes.data_modeling.containers import BTreeIndex
-from cognite.client.data_classes.data_modeling.data_types import ListablePropertyType
 from cognite.client.data_classes.data_modeling.views import SingleReverseDirectRelationApply, ViewPropertyApply
 from pydantic import Field, field_validator, model_serializer, model_validator
 from pydantic_core.core_schema import SerializationInfo, ValidationInfo
@@ -19,7 +18,6 @@ from rdflib import Namespace
 import cognite.neat.rules.issues.spreadsheet
 from cognite.neat.rules import issues
 from cognite.neat.rules.models._rules.domain_rules import DomainRules
-from cognite.neat.utils.text import to_camel
 
 from ._types import (
     CdfValueType,
@@ -135,18 +133,21 @@ class DMSMetadata(BaseMetadata):
         )
 
     @classmethod
-    def from_data_model(cls, data_model: dm.DataModelApply) -> "DMSMetadata":
-        description = None
-        if data_model.description and (description_match := re.search(r"Creator: (.+)", data_model.description)):
+    def _get_description_and_creator(cls, description_raw: str | None) -> tuple[str | None, list[str]]:
+        if description_raw and (description_match := re.search(r"Creator: (.+)", description_raw)):
             creator = description_match.group(1).split(", ")
-            data_model.description.replace(f" Creator: {', '.join(creator)}", "")
-        elif data_model.description:
+            description = description_raw.replace(description_match.string, "").strip() or None
+        elif description_raw:
             creator = ["MISSING"]
-            description = data_model.description
+            description = description_raw
         else:
             creator = ["MISSING"]
-            description = "Missing description"
+            description = None
+        return description, creator
 
+    @classmethod
+    def from_data_model(cls, data_model: dm.DataModelApply) -> "DMSMetadata":
+        description, creator = cls._get_description_and_creator(data_model.description)
         return cls(
             schema_=SchemaCompleteness.complete,
             space=data_model.space,
@@ -207,11 +208,11 @@ class DMSContainer(SheetEntity):
     reference: ReferenceType = Field(alias="Reference", default=None)
     constraint: ContainerListType | None = Field(None, alias="Constraint")
 
-    def as_container(self, default_space: str, standardize_casing: bool = True) -> dm.ContainerApply:
-        container_id = self.container.as_id(default_space, standardize_casing)
+    def as_container(self, default_space: str) -> dm.ContainerApply:
+        container_id = self.container.as_id(default_space)
         constraints: dict[str, dm.Constraint] = {}
         for constraint in self.constraint or []:
-            requires = dm.RequiresConstraint(constraint.as_id(default_space, standardize_casing))
+            requires = dm.RequiresConstraint(constraint.as_id(default_space))
             constraints[f"{constraint.space}_{constraint.external_id}"] = requires
 
         return dm.ContainerApply(
@@ -246,18 +247,15 @@ class DMSView(SheetEntity):
     filter_: Literal["hasData", "nodeType"] | None = Field(None, alias="Filter")
     in_model: bool = Field(True, alias="InModel")
 
-    def as_view(self, default_space: str, default_version: str, standardize_casing: bool = True) -> dm.ViewApply:
-        view_id = self.view.as_id(False, default_space, default_version, standardize_casing)
+    def as_view(self, default_space: str, default_version: str) -> dm.ViewApply:
+        view_id = self.view.as_id(False, default_space, default_version)
         return dm.ViewApply(
             space=view_id.space,
             external_id=view_id.external_id,
             version=view_id.version or default_version,
             name=self.name or None,
             description=self.description,
-            implements=[
-                parent.as_id(False, default_space, default_version, standardize_casing)
-                for parent in self.implements or []
-            ]
+            implements=[parent.as_id(False, default_space, default_version) for parent in self.implements or []]
             or None,
             properties={},
         )
@@ -494,12 +492,117 @@ class DMSRules(BaseRules):
             raise issues.MultiValueError(errors)
         return self
 
+    @model_validator(mode="after")
+    def validate_extension(self) -> "DMSRules":
+        if self.metadata.schema_ is not SchemaCompleteness.extended:
+            return self
+        if not self.reference:
+            raise ValueError("The schema is set to 'extended', but no reference rules are provided to validate against")
+        is_solution = self.metadata.space != self.reference.metadata.space
+        if is_solution:
+            return self
+        if self.metadata.extension is ExtensionCategory.rebuild:
+            # Everything is allowed
+            return self
+        # Is an extension of an existing model.
+        user_schema = self.as_schema()
+        ref_schema = self.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}
+
+        errors: list[issues.NeatValidationError] = []
+        for container_id, container in new_containers.items():
+            existing_container = existing_containers.get(container_id)
+            if not existing_container or existing_container == container:
+                # No problem
+                continue
+            new_dumped = container.dump()
+            existing_dumped = existing_container.dump()
+            changed_attributes, changed_properties = self._changed_attributes_and_properties(
+                new_dumped, existing_dumped
+            )
+            errors.append(
+                issues.dms.ChangingContainerError(
+                    container_id=container_id,
+                    changed_properties=changed_properties or None,
+                    changed_attributes=changed_attributes or None,
+                )
+            )
+
+        if self.metadata.extension is ExtensionCategory.reshape and errors:
+            raise issues.MultiValueError(errors)
+        elif self.metadata.extension is ExtensionCategory.reshape:
+            # Reshape allows changes to views
+            return self
+
+        new_views = {view.as_id(): view for view in user_schema.views}
+        existing_views = {view.as_id(): view for view in ref_schema.views}
+        for view_id, view in new_views.items():
+            existing_view = existing_views.get(view_id)
+            if not existing_view or existing_view == view:
+                # No problem
+                continue
+            changed_attributes, changed_properties = self._changed_attributes_and_properties(
+                view.dump(), existing_view.dump()
+            )
+            errors.append(
+                issues.dms.ChangingViewError(
+                    view_id=view_id,
+                    changed_properties=changed_properties or None,
+                    changed_attributes=changed_attributes or None,
+                )
+            )
+
+        if errors:
+            raise issues.MultiValueError(errors)
+        return self
+
+    @staticmethod
+    def _changed_attributes_and_properties(
+        new_dumped: dict[str, Any], existing_dumped: dict[str, Any]
+    ) -> tuple[list[str], list[str]]:
+        """Helper method to find the changed attributes and properties between two containers or views."""
+        new_attributes = {key: value for key, value in new_dumped.items() if key != "properties"}
+        existing_attributes = {key: value for key, value in existing_dumped.items() if key != "properties"}
+        changed_attributes = [key for key in new_attributes if new_attributes[key] != existing_attributes.get(key)]
+        new_properties = new_dumped.get("properties", {})
+        existing_properties = existing_dumped.get("properties", {})
+        changed_properties = [prop for prop in new_properties if new_properties[prop] != existing_properties.get(prop)]
+        return changed_attributes, changed_properties
+
     @model_validator(mode="after")
     def validate_schema(self) -> "DMSRules":
-        if self.metadata.schema_ is not SchemaCompleteness.complete:
+        if self.metadata.schema_ is SchemaCompleteness.partial:
             return self
+        elif self.metadata.schema_ is SchemaCompleteness.complete:
+            rules: DMSRules = self
+        elif self.metadata.schema_ is SchemaCompleteness.extended:
+            if not self.reference:
+                raise ValueError(
+                    "The schema is set to 'extended', but no reference rules are provided to validate against"
+                )
+            # This is an extension of the reference rules, we need to merge the two
+            rules = self.copy(deep=True)
+            rules.properties.extend(self.reference.properties.data)
+            existing_views = {view.view.as_id(False) for view in rules.views}
+            rules.views.extend([view for view in self.reference.views if view.view.as_id(False) not in existing_views])
+            if rules.containers and self.reference.containers:
+                existing_containers = {
+                    container.container.as_id(self.metadata.space) for container in rules.containers.data
+                }
+                rules.containers.extend(
+                    [
+                        container
+                        for container in self.reference.containers
+                        if container.container.as_id(self.reference.metadata.space) not in existing_containers
+                    ]
+                )
+            elif not rules.containers and self.reference.containers:
+                rules.containers = self.reference.containers
+        else:
+            raise ValueError("Unknown schema completeness")
 
-        schema = self.as_schema()
+        schema = rules.as_schema()
         errors = schema.validate()
         if errors:
             raise issues.MultiValueError(errors)
@@ -557,17 +660,19 @@ class DMSRules(BaseRules):
                     )
             containers.append(dumped)
 
-        return {
+        output = {
             "Metadata" if info.by_alias else "metadata": self.metadata.model_dump(**kwargs),
             "Properties" if info.by_alias else "properties": properties,
             "Views" if info.by_alias else "views": views,
             "Containers" if info.by_alias else "containers": containers,
+            "is_reference": self.is_reference,
         }
+        if self.reference is not None:
+            output["Reference" if info.by_alias else "reference"] = self.reference.model_dump(**kwargs)
+        return output
 
-    def as_schema(
-        self, standardize_casing: bool = True, include_pipeline: bool = False, instance_space: str | None = None
-    ) -> DMSSchema:
-        return _DMSExporter(standardize_casing, include_pipeline, instance_space).to_schema(self)
+    def as_schema(self, include_pipeline: bool = False, instance_space: str | None = None) -> DMSSchema:
+        return _DMSExporter(include_pipeline, instance_space).to_schema(self)
 
     def as_information_architect_rules(self) -> "InformationRules":
         return _DMSRulesConverter(self).as_information_architect_rules()
@@ -599,17 +704,12 @@ class _DMSExporter:
     (This module cannot have a dependency on the exporter module, as it would create a circular dependency.)
 
     Args
-        standardize_casing (bool): If True, the casing of the identifiers will be standardized. This means external IDs
-            are PascalCase and property names are camelCase.
         include_pipeline (bool): If True, the pipeline will be included with the schema. Pipeline means the
             raw tables and transformations necessary to populate the data model.
         instance_space (str): The space to use for the instance. Defaults to None,`Rules.metadata.space` will be used
     """
 
-    def __init__(
-        self, standardize_casing: bool = True, include_pipeline: bool = False, instance_space: str | None = None
-    ):
-        self.standardize_casing = standardize_casing
+    def __init__(self, include_pipeline: bool = False, instance_space: str | None = None):
         self.include_pipeline = include_pipeline
         self.instance_space = instance_space
 
@@ -628,9 +728,7 @@ class _DMSExporter:
         )
 
         views_not_in_model = {
-            view.view.as_id(False, default_space, default_version, self.standardize_casing)
-            for view in rules.views
-            if not view.in_model
+            view.view.as_id(False, default_space, default_version) for view in rules.views if not view.in_model
         }
         data_model = rules.metadata.as_data_model()
         data_model.views = sorted(
@@ -675,12 +773,9 @@ class _DMSExporter:
         default_space: str,
         default_version: str,
     ) -> tuple[dm.ViewApplyList, dm.NodeApplyList]:
-        views = dm.ViewApplyList(
-            [dms_view.as_view(default_space, default_version, self.standardize_casing) for dms_view in dms_views]
-        )
+        views = dm.ViewApplyList([dms_view.as_view(default_space, default_version) for dms_view in dms_views])
         dms_view_by_id = {
-            dms_view.view.as_id(False, default_space, default_version, self.standardize_casing): dms_view
-            for dms_view in dms_views
+            dms_view.view.as_id(False, default_space, default_version): dms_view for dms_view in dms_views
         }
 
         for view in views:
@@ -694,7 +789,7 @@ class _DMSExporter:
                     # This is not yet supported in the CDF API, a warning has already been issued, here we convert it to
                     # a multi-edge connection.
                     if isinstance(prop.value_type, ViewEntity):
-                        source = prop.value_type.as_id(False, default_space, default_version, self.standardize_casing)
+                        source = prop.value_type.as_id(False, default_space, default_version)
                     else:
                         raise ValueError(
                             "Direct relation must have a view as value type. "
@@ -709,43 +804,48 @@ class _DMSExporter:
                         direction="outwards",
                     )
                 elif prop.container and prop.container_property and prop.view_property:
-                    container_prop_identifier = (
-                        to_camel(prop.container_property) if self.standardize_casing else prop.container_property
-                    )
+                    container_prop_identifier = prop.container_property
                     extra_args: dict[str, Any] = {}
                     if prop.relation == "direct" and isinstance(prop.value_type, ViewEntity):
-                        extra_args["source"] = prop.value_type.as_id(
-                            True, default_space, default_version, self.standardize_casing
-                        )
+                        extra_args["source"] = prop.value_type.as_id(True, default_space, default_version)
                     elif prop.relation == "direct" and not isinstance(prop.value_type, ViewEntity):
                         raise ValueError(
                             "Direct relation must have a view as value type. "
                             "This should have been validated in the rules"
                         )
                     view_property = dm.MappedPropertyApply(
-                        container=prop.container.as_id(default_space, self.standardize_casing),
+                        container=prop.container.as_id(default_space),
                         container_property_identifier=container_prop_identifier,
                         **extra_args,
                     )
                 elif prop.view and prop.view_property and prop.relation == "multiedge":
                     if isinstance(prop.value_type, ViewEntity):
-                        source = prop.value_type.as_id(False, default_space, default_version, self.standardize_casing)
+                        source = prop.value_type.as_id(False, default_space, default_version)
                     else:
                         raise ValueError(
                             "Multiedge relation must have a view as value type. "
                             "This should have been validated in the rules"
                         )
-                    view_property = dm.MultiEdgeConnectionApply(
-                        type=dm.DirectRelationReference(
+                    if isinstance(prop.reference, ReferenceEntity):
+                        ref_view_prop = prop.reference.as_prop_id(default_space, default_version)
+                        edge_type = dm.DirectRelationReference(
+                            space=ref_view_prop.source.space,
+                            external_id=f"{ref_view_prop.source.external_id}.{ref_view_prop.property}",
+                        )
+                    else:
+                        edge_type = dm.DirectRelationReference(
                             space=source.space,
                             external_id=f"{prop.view.external_id}.{prop.view_property}",
-                        ),
+                        )
+
+                    view_property = dm.MultiEdgeConnectionApply(
+                        type=edge_type,
                         source=source,
                         direction="outwards",
                     )
                 elif prop.view and prop.view_property and prop.relation == "reversedirect":
                     if isinstance(prop.value_type, ViewPropEntity):
-                        source = prop.value_type.as_id(False, default_space, default_version, self.standardize_casing)
+                        source = prop.value_type.as_id(False, default_space, default_version)
                     else:
                         raise ValueError(
                             "Reverse direct relation must have a view as value type. "
@@ -765,11 +865,19 @@ class _DMSExporter:
                         warnings.warn(
                             issues.dms.ReverseOfDirectRelationListWarning(view_id, prop.property_), stacklevel=2
                         )
-                        view_property = dm.MultiEdgeConnectionApply(
-                            type=dm.DirectRelationReference(
+                        if isinstance(reverse_prop.reference, ReferenceEntity):
+                            ref_view_prop = reverse_prop.reference.as_prop_id(default_space, default_version)
+                            edge_type = dm.DirectRelationReference(
+                                space=ref_view_prop.source.space,
+                                external_id=f"{ref_view_prop.source.external_id}.{ref_view_prop.property}",
+                            )
+                        else:
+                            edge_type = dm.DirectRelationReference(
                                 space=source.space,
                                 external_id=f"{reverse_prop.view.external_id}.{reverse_prop.view_property}",
-                            ),
+                            )
+                        view_property = dm.MultiEdgeConnectionApply(
+                            type=edge_type,
                             source=source,
                             direction="inwards",
                         )
@@ -797,16 +905,24 @@ class _DMSExporter:
                     continue
                 else:
                     continue
-                prop_name = to_camel(prop.view_property) if self.standardize_casing else prop.view_property
+                prop_name = prop.view_property
                 view.properties[prop_name] = view_property
 
         node_types = dm.NodeApplyList([])
         parent_views = {parent for view in views for parent in view.implements or []}
         for view in views:
             ref_containers = sorted(view.referenced_containers(), key=lambda c: c.as_tuple())
-            has_data = dm.filters.HasData(containers=list(ref_containers)) if ref_containers else None
-            node_type = dm.filters.Equals(["node", "type"], {"space": view.space, "externalId": view.external_id})
             dms_view = dms_view_by_id.get(view.as_id())
+            has_data = dm.filters.HasData(containers=list(ref_containers)) if ref_containers else None
+            if dms_view and isinstance(dms_view.reference, ReferenceEntity):
+                # If the view is a reference, we implement the reference view,
+                # and need the filter to match the reference
+                ref_view = dms_view.reference.as_id(False, default_space, default_version)
+                node_type = dm.filters.Equals(
+                    ["node", "type"], {"space": ref_view.space, "externalId": ref_view.external_id}
+                )
+            else:
+                node_type = dm.filters.Equals(["node", "type"], {"space": view.space, "externalId": view.external_id})
             if view.as_id() in parent_views:
                 if dms_view and dms_view.filter_ == "nodeType":
                     warnings.warn(issues.dms.NodeTypeFilterOnParentViewWarning(view.as_id()), stacklevel=2)
@@ -838,10 +954,7 @@ class _DMSExporter:
         default_space: str,
     ) -> dm.ContainerApplyList:
         containers = dm.ContainerApplyList(
-            [
-                dms_container.as_container(default_space, self.standardize_casing)
-                for dms_container in dms_container or []
-            ]
+            [dms_container.as_container(default_space) for dms_container in dms_container or []]
         )
         container_to_drop = set()
         for container in containers:
@@ -858,7 +971,7 @@ class _DMSExporter:
                 else:
                     type_cls = dm.DirectRelation
 
-                prop_name = to_camel(prop.container_property) if self.standardize_casing else prop.container_property
+                prop_name = prop.container_property
 
                 if type_cls is dm.DirectRelation:
                     container.properties[prop_name] = dm.ContainerProperty(
@@ -870,10 +983,7 @@ class _DMSExporter:
                     )
                 else:
                     type_: CognitePropertyType
-                    if issubclass(type_cls, ListablePropertyType):
-                        type_ = type_cls(is_list=prop.is_list or False)
-                    else:
-                        type_ = cast(CognitePropertyType, type_cls())
+                    type_ = type_cls(is_list=prop.is_list or False)
                     container.properties[prop_name] = dm.ContainerProperty(
                         type=type_,
                         nullable=prop.nullable if prop.nullable is not None else True,
@@ -919,21 +1029,21 @@ class _DMSExporter:
         container_properties_by_id: dict[dm.ContainerId, list[DMSProperty]] = defaultdict(list)
         view_properties_by_id: dict[dm.ViewId, list[DMSProperty]] = defaultdict(list)
         for prop in rules.properties:
-            view_id = prop.view.as_id(False, default_space, default_version, self.standardize_casing)
+            view_id = prop.view.as_id(False, default_space, default_version)
             view_properties_by_id[view_id].append(prop)
 
             if prop.container and prop.container_property:
                 if prop.relation == "direct" and prop.is_list:
                     warnings.warn(
                         issues.dms.DirectRelationListWarning(
-                            container_id=prop.container.as_id(default_space, self.standardize_casing),
-                            view_id=prop.view.as_id(False, default_space, default_version, self.standardize_casing),
+                            container_id=prop.container.as_id(default_space),
+                            view_id=prop.view.as_id(False, default_space, default_version),
                             property=prop.container_property,
                         ),
                         stacklevel=2,
                     )
                     continue
-                container_id = prop.container.as_id(default_space, self.standardize_casing)
+                container_id = prop.container.as_id(default_space)
                 container_properties_by_id[container_id].append(prop)
 
         return container_properties_by_id, view_properties_by_id

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

@@ -63,6 +63,10 @@ class DMSSchema:
         if len(data_models) == 0:
             raise ValueError(f"Data model {data_model_id} not found")
         data_model = data_models.latest_version()
+        return cls.from_data_model(client, data_model)
+
+    @classmethod
+    def from_data_model(cls, client: CogniteClient, data_model: dm.DataModel) -> "DMSSchema":
         views = dm.ViewList(data_model.views)
         container_ids = views.referenced_containers()
         containers = client.data_modeling.containers.retrieve(list(container_ids))
@@ -267,7 +271,7 @@ class DMSSchema:
         if isinstance(item, dm.ContainerApply | dm.ViewApply | dm.DataModelApply | dm.NodeApply | RawTableWrite):
             identifier = item.as_id().as_tuple()
             if len(identifier) == 3 and identifier[2] is None:
-                return identifier[:2]
+                return identifier[:2]  # type: ignore[misc]
             return cast(tuple[str, str] | tuple[str, str, str], identifier)
         elif isinstance(item, dm.SpaceApply):
             return item.space

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

@@ -1,6 +1,7 @@
+import math
 from typing import Any, ClassVar
 
-from pydantic import Field, model_serializer
+from pydantic import Field, field_serializer, field_validator, model_serializer
 from pydantic_core.core_schema import SerializationInfo
 
 from ._types import ParentClassType, PropertyType, SemanticValueType, StrOrListType
@@ -24,6 +25,18 @@ class DomainProperty(SheetEntity):
     min_count: int | None = Field(alias="Min Count", default=None)
     max_count: int | float | None = Field(alias="Max Count", default=None)
 
+    @field_serializer("max_count", when_used="json-unless-none")
+    def serialize_max_count(self, value: int | float | None) -> int | float | None | str:
+        if isinstance(value, float) and math.isinf(value):
+            return None
+        return value
+
+    @field_validator("max_count", mode="before")
+    def parse_max_count(cls, value: int | float | None) -> int | float | None:
+        if value is None:
+            return float("inf")
+        return value
+
 
 class DomainClass(SheetEntity):
     description: str | None = Field(None, alias="Description")

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

@@ -1,3 +1,4 @@
+import math
 import re
 import sys
 import warnings
@@ -5,7 +6,7 @@ from collections import defaultdict
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, cast
 
-from pydantic import Field, field_validator, model_serializer, model_validator
+from pydantic import Field, field_serializer, field_validator, model_serializer, model_validator
 from pydantic_core.core_schema import SerializationInfo
 from rdflib import Namespace
 
@@ -47,6 +48,7 @@ from ._types._base import Unknown
 from .base import (
     BaseMetadata,
     ExtensionCategory,
+    ExtensionCategoryType,
     MatchType,
     RoleTypes,
     RuleModel,
@@ -69,7 +71,7 @@ else:
 class InformationMetadata(BaseMetadata):
     role: ClassVar[RoleTypes] = RoleTypes.information_architect
     schema_: SchemaCompleteness = Field(alias="schema")
-    extension: ExtensionCategory | None = ExtensionCategory.addition
+    extension: ExtensionCategoryType | None = ExtensionCategory.addition
     prefix: PrefixType
     namespace: NamespaceType
 
@@ -156,6 +158,18 @@ class InformationProperty(SheetEntity):
     )
     comment: str | None = Field(alias="Comment", default=None)
 
+    @field_serializer("max_count", when_used="json-unless-none")
+    def serialize_max_count(self, value: int | float | None) -> int | float | None | str:
+        if isinstance(value, float) and math.isinf(value):
+            return None
+        return value
+
+    @field_validator("max_count", mode="before")
+    def parse_max_count(cls, value: int | float | None) -> int | float | None:
+        if value is None:
+            return float("inf")
+        return value
+
     @model_validator(mode="after")
     def is_valid_rule(self):
         # TODO: Can we skip rule_type and simply try to parse the rule and if it fails, raise an error?

cognite/neat/utils/spreadsheet.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Literal, overload
+from typing import Literal, cast, overload
 
 import pandas as pd
 from openpyxl import load_workbook
@@ -58,7 +58,7 @@ def read_individual_sheet(
     expected_headers: list[str] | None = None,
 ) -> tuple[list[dict], SpreadsheetRead] | list[dict]:
     if expected_headers:
-        target_row = _get_row_number(load_workbook(excel_file)[sheet_name], expected_headers)
+        target_row = _get_row_number(cast(Worksheet, load_workbook(excel_file)[sheet_name]), expected_headers)
         skiprows = target_row - 1 if target_row is not None else 0
     else:
         skiprows = 0

cognite/neat/workflows/steps/lib/rules_exporter.py

@@ -102,7 +102,6 @@ class RulesToDMS(Step):
             if multi_space_components_create
             else {input_rules.metadata.space if isinstance(input_rules, DMSRules) else input_rules.metadata.prefix},
             existing_handling=existing_components_handling,
-            standardize_casing=False,
         )
 
         output_dir = self.data_store_path / Path("staging")

{cognite_neat-0.72.2.dist-info → cognite_neat-0.73.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.72.2
+Version: 0.73.0
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0
@@ -19,7 +19,7 @@ Provides-Extra: graphql
 Provides-Extra: oxi
 Requires-Dist: PyYAML
 Requires-Dist: backports.strenum (>=1.2,<2.0) ; python_version < "3.11"
-Requires-Dist: cognite-sdk (>=7.28.2,<8.0.0)
+Requires-Dist: cognite-sdk (>=7.37.0,<8.0.0)
 Requires-Dist: deepdiff
 Requires-Dist: exceptiongroup (>=1.1.3,<2.0.0) ; python_version < "3.11"
 Requires-Dist: fastapi (>=0.100,<0.101)