cognite-neat 1.0.28__py3-none-any.whl → 1.0.30__py3-none-any.whl

cognite/neat/_config.py

@@ -105,6 +105,9 @@ class AlphaFlagConfig(ConfigModel):
         default=False,
         description="If enabled, Neat will run experimental validators that are still in alpha stage.",
     )
+    enable_solution_model_creation: bool = Field(
+        default=False, description="If enabled, neat.physical_data_model.create() will be available"
+    )
     enable_cdf_analysis: bool = Field(default=False, description="If enabled, neat.cdf endpoint will be available.")
 
     def __setattr__(self, key: str, value: Any) -> None:

cognite/neat/_data_model/_analysis.py

@@ -1,10 +1,14 @@
+import math
 from collections import defaultdict
-from itertools import chain
+from dataclasses import dataclass
+from enum import Enum
+from itertools import chain, combinations
 from typing import Literal, TypeAlias, TypeVar
 
 import networkx as nx
 from pyparsing import cached_property
 
+from cognite.neat._data_model._constants import COGNITE_SPACES
 from cognite.neat._data_model._snapshot import SchemaSnapshot
 from cognite.neat._data_model.models.dms._constraints import RequiresConstraintDefinition
 from cognite.neat._data_model.models.dms._container import ContainerRequest
@@ -41,12 +45,34 @@ ResourceSource = Literal["auto", "merged", "cdf", "both"]
 _NodeT = TypeVar("_NodeT", ContainerReference, ViewReference)
 
 
+class RequiresChangeStatus(Enum):
+    """Status of requires constraint changes for a view."""
+
+    OPTIMAL = "optimal"  # Already optimized, no changes needed
+    CHANGES_AVAILABLE = "changes_available"  # Recommendations available
+    UNSOLVABLE = "unsolvable"  # Structural issue - can't create connected hierarchy
+    NO_MODIFIABLE_CONTAINERS = "no_modifiable_containers"  # All containers are immutable
+
+
+@dataclass
+class RequiresChangesForView:
+    """Result of computing requires constraint changes for a view."""
+
+    to_add: set[tuple[ContainerReference, ContainerReference]]
+    to_remove: set[tuple[ContainerReference, ContainerReference]]
+    status: RequiresChangeStatus
+
+
 class ValidationResources:
     def __init__(
-        self, modus_operandi: ModusOperandi, local: SchemaSnapshot, cdf: SchemaSnapshot, limits: SchemaLimits
+        self,
+        modus_operandi: ModusOperandi,
+        local: SchemaSnapshot,
+        cdf: SchemaSnapshot,
+        limits: SchemaLimits | None = None,
     ) -> None:
         self._modus_operandi = modus_operandi
-        self.limits = limits
+        self.limits = limits or SchemaLimits()
 
         self.local = local
         self.cdf = cdf
@@ -385,6 +411,18 @@ class ValidationResources:
 
         return connection_end_node_types
 
+    @staticmethod
+    def is_explicit_connection(property_: ViewRequestProperty) -> bool:
+        """Check if a property is an explicit connection property, meaning end node type is explicitly defined.
+
+        Args:
+            property_: The property to check.
+
+        Returns:
+            True if the property is a connection property, False otherwise.
+        """
+        return True if property_.source else False
+
     @cached_property
     def views_by_container(self) -> dict[ContainerReference, set[ViewReference]]:
         """Get a mapping from containers to the views that use them.
@@ -512,17 +550,84 @@ class ValidationResources:
             graph.add_node(container_ref)
 
         # Add edges for requires constraints from all known containers
-        for container_ref in graph.nodes():
+        for container_ref in list(graph.nodes()):
             container = self.select_container(container_ref)
             if not container or not container.constraints:
                 continue
-            for constraint in container.constraints.values():
+            for constraint_id, constraint in container.constraints.items():
                 if not isinstance(constraint, RequiresConstraintDefinition):
                     continue
-                graph.add_edge(container_ref, constraint.require)
+                is_auto = constraint_id.endswith("__auto")
+                graph.add_edge(container_ref, constraint.require, is_auto=is_auto)
 
         return graph
 
+    @cached_property
+    def modifiable_containers(self) -> set[ContainerReference]:
+        """Containers whose requires constraints can be modified in this session.
+
+        A container is modifiable if:
+        - It's NOT in a CDF built-in space (CDM, IDM, etc.)
+        - It's a user container brought in through the loaded data model scope or view implements chain
+        """
+        return {container_ref for container_ref in self.merged.containers if container_ref.space not in COGNITE_SPACES}
+
+    @cached_property
+    def immutable_requires_constraint_graph(self) -> nx.DiGraph:
+        """Subgraph of requires constraints from non-modifiable (CDM) containers.
+
+        Used to check reachability via existing immutable constraints.
+        """
+        return nx.subgraph_view(
+            self.requires_constraint_graph,
+            filter_edge=lambda src, _: src not in self.modifiable_containers,
+        )
+
+    @cached_property
+    def _fixed_constraint_graph(self) -> nx.DiGraph:
+        """Graph of all fixed constraints (immutable + user-intentional).
+
+        Both are "fixed" from the optimizer's perspective - existing paths that can't be changed.
+        """
+        G = nx.DiGraph()
+        G.add_edges_from(self.immutable_requires_constraint_graph.edges())
+        G.add_edges_from(self._user_intentional_constraints)
+        return G
+
+    @cached_property
+    def _fixed_descendants(self) -> defaultdict[ContainerReference, set[ContainerReference]]:
+        """Pre-compute descendants via fixed constraints. Missing keys return empty set."""
+        result: defaultdict[ContainerReference, set[ContainerReference]] = defaultdict(set)
+        for container in self._fixed_constraint_graph.nodes():
+            result[container] = nx.descendants(self._fixed_constraint_graph, container)
+        return result
+
+    @cached_property
+    def _existing_requires_edges(self) -> set[tuple[ContainerReference, ContainerReference]]:
+        """Cached set of existing requires constraint edges."""
+        return set(self.requires_constraint_graph.edges())
+
+    @cached_property
+    def _user_intentional_constraints(self) -> set[tuple[ContainerReference, ContainerReference]]:
+        """Constraints that appear to be user-intentional and should not be auto-removed
+
+        A constraint is user-intentional if:
+        1. The constraint identifier does NOT have '__auto' postfix
+        2. Neither src nor dst is part of a cycle (cyclic constraints are errors)
+
+        These constraints are preserved even if they're not in the optimal structure, because
+        they may be used for data integrity purposes.
+        We DON'T consider manual-created constraints as user-intended if they form part of a cycle,
+        because that indicates a problem with the data model where we likely can provide a better solution.
+        """
+        containers_in_cycles = {container for cycle in self.requires_constraint_cycles for container in cycle}
+
+        return {
+            (src, dst)
+            for src, dst, data in self.requires_constraint_graph.edges(data=True)
+            if not data.get("is_auto", False) and src not in containers_in_cycles and dst not in containers_in_cycles
+        }
+
     @staticmethod
     def forms_directed_path(nodes: set[_NodeT], graph: nx.DiGraph) -> bool:
         """Check if nodes form an uninterrupted directed path in the graph.
@@ -549,8 +654,14 @@ class ValidationResources:
         if len(nodes) <= 1:
             return True
 
-        for candidate in nodes:
-            others = nodes - {candidate}
+        # Filter to nodes that are actually in the graph
+        nodes_in_graph = {n for n in nodes if n in graph}
+        if len(nodes_in_graph) < len(nodes):
+            # Some nodes aren't in the graph, so we can't form a complete path
+            return False
+
+        for candidate in nodes_in_graph:
+            others = nodes_in_graph - {candidate}
             if others.issubset(nx.descendants(graph, candidate)):
                 return True
 
@@ -562,10 +673,331 @@ class ValidationResources:
         Returns:
             List of lists, where each list contains the ordered containers involved in forming the requires cycle.
         """
-
         return self.graph_cycles(self.requires_constraint_graph)
 
     @staticmethod
     def graph_cycles(graph: nx.DiGraph) -> list[list[T_Reference]]:
         """Returns cycles in the graph otherwise empty list"""
         return [candidate for candidate in nx.simple_cycles(graph) if len(candidate) > 1]
+
+    @cached_property
+    def optimized_requires_constraint_graph(self) -> nx.DiGraph:
+        """Target state of requires constraints after optimizing (MST + fixed constraints)."""
+        graph = nx.DiGraph()
+        graph.add_edges_from(self.oriented_mst_edges)
+        graph.add_edges_from(self._fixed_constraint_graph.edges())
+        return graph
+
+    @cached_property
+    def _requires_candidate_graph(self) -> nx.Graph:
+        """Build weighted candidate graph for requires constraints.
+
+        Contains all container pairs that appear together in any view, with:
+        - weight: minimum directional weight (for MST computation)
+        - preferred_direction: direction with lower weight (for tie-breaking)
+
+        This graph is used to compute per-view MSTs.
+        """
+        G = nx.Graph()
+
+        for view_ref in self.merged.views:
+            containers = self.containers_by_view.get(view_ref, set())
+            if len(containers) < 2:
+                continue  # Need at least 2 containers to form a requires constraint
+
+            # Sort for deterministic preferred_direction when weights are equal
+            for src, dst in combinations(sorted(containers, key=str), 2):
+                if G.has_edge(src, dst):
+                    continue  # Already added from another view
+
+                w1 = self._compute_requires_edge_weight(src, dst)
+                w2 = self._compute_requires_edge_weight(dst, src)
+                direction = (src, dst) if w1 <= w2 else (dst, src)
+                weight = min(w1, w2)
+
+                G.add_edge(src, dst, weight=weight, preferred_direction=direction)
+
+        return G
+
+    @cached_property
+    def _mst_by_view(self) -> dict[ViewReference, nx.Graph]:
+        """Compute per-view MST graphs.
+
+        Each view gets its own MST over just its containers. This ensures:
+        - No routing through containers not in the view
+        - Each view gets exactly the edges it needs
+        - Voting handles orientation conflicts between views
+
+        Skips inherently unsolvable views (no immutable anchor + all modifiables are roots).
+        """
+        if not self._requires_candidate_graph:
+            return {}
+
+        result: dict[ViewReference, nx.Graph] = {}
+
+        for view_ref in self.merged.views:
+            if view_ref in self._views_with_root_conflicts:
+                continue
+
+            containers = self.containers_by_view.get(view_ref, set())
+            if len(containers) < 2:  # Need at least 2 containers to have a constraint
+                continue
+            if not containers.intersection(self.modifiable_containers):
+                continue
+
+            subgraph = self._requires_candidate_graph.subgraph(containers)
+            if not nx.is_connected(subgraph):
+                continue
+
+            result[view_ref] = nx.minimum_spanning_tree(subgraph, weight="weight")
+
+        return result
+
+    @cached_property
+    def _root_by_view(self) -> dict[ViewReference, ContainerReference]:
+        """Map each view (with 2+ containers) to its most view-specific (root) container.
+
+        Only includes views with 2+ containers since single-container views
+        are trivially satisfied and don't need root direction.
+
+        Selection criteria (in priority order):
+        1. Fewest views: Containers appearing in fewer views are more "view-specific"
+        2. Has existing constraint: Prefer containers with existing outgoing constraints
+        3. Alphabetical: Deterministic tie-breaker
+        """
+        result: dict[ViewReference, ContainerReference] = {}
+
+        for view, containers in self.containers_by_view.items():
+            if len(containers) < 2:
+                continue
+
+            modifiable = containers.intersection(self.modifiable_containers)
+            if not modifiable:
+                continue
+
+            # Selection priority: fewest views, has existing constraint, alphabetical
+            result[view] = min(
+                modifiable,
+                key=lambda c: (
+                    len(self.views_by_container.get(c, set())),
+                    0 if any((c, other) in self._existing_requires_edges for other in containers) else 1,
+                    str(c),
+                ),
+            )
+
+        return result
+
+    @cached_property
+    def _views_with_root_conflicts(self) -> set[ViewReference]:
+        """Views where all modifiable containers are forced roots for other views.
+
+        A view has root conflicts if:
+        1. It has no immutable containers (no shared CDM anchor)
+        2. All its modifiable containers are already forced roots for other views
+
+        Such views would require edges between forced roots, causing conflicts.
+        """
+        forced_roots = set(self._root_by_view.values())
+        unsolvable: set[ViewReference] = set()
+
+        for view, containers in self.containers_by_view.items():
+            modifiable = containers & self.modifiable_containers
+            immutable = containers - self.modifiable_containers
+
+            # Need at least 2 modifiable containers to have a conflict
+            if len(modifiable) < 2:
+                continue
+
+            # No immutable anchor AND all modifiables are roots elsewhere
+            if not immutable and modifiable <= forced_roots:
+                unsolvable.add(view)
+
+        return unsolvable
+
+    @cached_property
+    def oriented_mst_edges(self) -> set[tuple[ContainerReference, ContainerReference]]:
+        """Orient per-view MST edges by voting across views.
+
+        Each view votes for edge orientations based on BFS from its root container.
+        Views with only 1 modifiable container use 'inf' vote weight to force
+        that container as root.
+
+        Tie-breaker: preferred_direction from weight function.
+
+        Returns set of directed (src, dst) tuples.
+        """
+        edge_votes: dict[tuple[ContainerReference, ContainerReference], float] = defaultdict(float)
+        all_edges: set[tuple[ContainerReference, ContainerReference]] = set()
+
+        # Sort for deterministic iteration (dict order can vary with hash randomization)
+        for view in sorted(self._mst_by_view.keys(), key=str):
+            mst = self._mst_by_view[view]
+            root = self._root_by_view[view]  # Always exists for views in _mst_by_view
+            containers = self.containers_by_view.get(view, set())
+            modifiable_count = len(containers & self.modifiable_containers)
+            # Views with only 1 modifiable container have no choice - that container MUST be root
+            vote_weight = float("inf") if modifiable_count == 1 else 1.0
+
+            # BFS from root orients edges away from root (parent → child)
+            for parent, child in nx.bfs_edges(mst, root):  # type: ignore[func-returns-value]
+                if parent in self.modifiable_containers:
+                    edge_votes[(parent, child)] += vote_weight
+
+            # Normalize edges to canonical form so votes for same undirected edge are counted together
+            for c1, c2 in mst.edges():
+                all_edges.add((c1, c2) if str(c1) < str(c2) else (c2, c1))
+
+        # Pick direction: most votes wins, preferred_direction breaks ties
+        oriented: set[tuple[ContainerReference, ContainerReference]] = set()
+
+        # Sort for deterministic iteration (hash randomization affects set order)
+        for c1, c2 in sorted(all_edges, key=lambda e: (str(e[0]), str(e[1]))):
+            c1_votes = edge_votes.get((c1, c2), 0)
+            c2_votes = edge_votes.get((c2, c1), 0)
+
+            if c1_votes > c2_votes:
+                oriented.add((c1, c2))
+            elif c2_votes > c1_votes:
+                oriented.add((c2, c1))
+            else:
+                # Tie-breaker: use preferred_direction from weight function
+                oriented.add(self._requires_candidate_graph[c1][c2].get("preferred_direction", (c1, c2)))
+
+        return oriented
+
+    @cached_property
+    def _transitively_reduced_edges(self) -> set[tuple[ContainerReference, ContainerReference]]:
+        """Reduce MST edges to minimal necessary set (remove edges with alternative paths via immutable)."""
+        if not self.oriented_mst_edges:
+            return set()
+
+        # Optimal graph = MST + immutable + user-intentional (these provide existing paths)
+        optimal = nx.DiGraph()
+        optimal.add_edges_from(self.immutable_requires_constraint_graph.edges())
+        optimal.add_edges_from(self._user_intentional_constraints)
+        optimal.add_edges_from(self.oriented_mst_edges)
+
+        reduced = nx.transitive_reduction(optimal)
+
+        # Return MST edges that survive reduction
+        return {e for e in reduced.edges() if e in self.oriented_mst_edges}
+
+    def get_requires_changes_for_view(self, view: ViewReference) -> RequiresChangesForView:
+        """Get requires constraint changes needed to optimize a view.
+
+        Returns a RequiresChangesForView with:
+        - to_add: New constraints needed where source is mapped in this view
+        - to_remove: Existing constraints that are redundant or wrongly oriented
+        - status: The optimization status for this view
+        """
+        modifiable_containers_in_view = self.containers_by_view.get(view, set()).intersection(
+            self.modifiable_containers
+        )
+        if not modifiable_containers_in_view:
+            return RequiresChangesForView(set(), set(), RequiresChangeStatus.NO_MODIFIABLE_CONTAINERS)
+
+        # Early exit for inherently unsolvable views (no CDM anchor + all modifiables are roots)
+        if view in self._views_with_root_conflicts:
+            return RequiresChangesForView(
+                set[tuple[ContainerReference, ContainerReference]](), set(), RequiresChangeStatus.UNSOLVABLE
+            )
+
+        # Filter edges to those where source is in this view's modifiable containers
+        existing_from_view = {
+            edge for edge in self._existing_requires_edges if edge[0] in modifiable_containers_in_view
+        }
+        optimal_for_view = {
+            edge for edge in self._transitively_reduced_edges if edge[0] in modifiable_containers_in_view
+        }
+
+        to_add = optimal_for_view - existing_from_view
+
+        # To remove: existing edges with wrong direction or not in MST (and not needed externally)
+        # But NEVER remove user-intentional constraints (manually defined, no __auto postfix)
+        to_remove: set[tuple[ContainerReference, ContainerReference]] = set()
+        for src, dst in existing_from_view:
+            # Skip user-intentional constraints - they were set by the user on purpose
+            if (src, dst) in self._user_intentional_constraints:
+                continue
+            if (dst, src) in self.oriented_mst_edges:
+                to_remove.add((src, dst))  # Always remove if opposite direction from optimal solution
+            elif (src, dst) not in self.oriented_mst_edges and not (
+                self.find_views_mapping_to_containers([src, dst]) - set(self.merged.views)
+            ):
+                to_remove.add((src, dst))  # Remove if not in optimal solution and not needed by external views
+
+        # Check solvability in optimized state
+        if not self.forms_directed_path(
+            self.containers_by_view.get(view, set()), self.optimized_requires_constraint_graph
+        ):
+            return RequiresChangesForView(set(), set(), RequiresChangeStatus.UNSOLVABLE)
+
+        if not to_add and not to_remove:
+            return RequiresChangesForView(set(), set(), RequiresChangeStatus.OPTIMAL)
+
+        return RequiresChangesForView(to_add, to_remove, RequiresChangeStatus.CHANGES_AVAILABLE)
+
+    # ========================================================================
+    # REQUIRES CONSTRAINT MST WEIGHT CONSTANTS
+    # ========================================================================
+    # Weight = TIER + sub_weight.
+    #
+    # WHY THIS ENCODING:
+    # MST algorithm only support scalar weights, but we need a strict priority
+    # hierarchy where USER→USER ALWAYS beats USER→EXTERNAL. By using a large
+    # gap (1000) between tiers, sub-weights (max ~50) can never cause a lower
+    # tier to beat a higher tier.
+    #
+    # Tiers (explicit priority order):
+    #   - Tier 1 (USER→USER):     Both containers modifiable - always preferred
+    #   - Tier 2 (USER→EXTERNAL): Target is CDF/CDM - only when needed
+    #   - Tier ∞ (FORBIDDEN):     Invalid edge, forms cycle or source is not modifiable
+    #
+    # Sub-weights refine ordering WITHIN a tier (shared views, direction, etc).
+    #   - These have been empirically tuned through trial and error.
+    # ========================================================================
+
+    # Tier base weights (gap of 1000 ensures tier always wins)
+    _TIER_USER_TO_USER = 1000
+    _TIER_USER_TO_EXTERNAL = 2000
+    _TIER_FORBIDDEN = math.inf
+
+    # Sub-weight adjustments (applied within tier, max ~100)
+    _BONUS_SHARED_VIEWS_PER = 5  # Per shared view (max 5 views → 25)
+    _BONUS_SHARED_VIEWS_MAX = 25
+    _BONUS_COVERAGE_PER = 5  # Per descendant via immutable edges (max 3 → 15)
+    _BONUS_COVERAGE_MAX = 15
+    _PENALTY_VIEW_COUNT = 10  # When src is in more views than dst
+
+    # Tie-breaker for deterministic ordering
+    _TIE_BREAKER_DIVISOR = 1e9
+
+    def _compute_requires_edge_weight(self, src: ContainerReference, dst: ContainerReference) -> float:
+        """Compute the weight/cost of adding edge src → dst.
+
+        Returns TIER + sub_weight where tier dominates (gap of 1000).
+        Sub-weights refine ordering within a tier based on shared views, direction, coverage.
+        """
+        # Opposite direction of fixed constraints is forbidden (would conflict with existing path)
+        if src in self._fixed_descendants[dst]:
+            return self._TIER_FORBIDDEN
+
+        if src not in self.modifiable_containers:
+            return self._TIER_FORBIDDEN
+
+        src_views = self.views_by_container.get(src, set())
+        dst_views = self.views_by_container.get(dst, set())
+
+        # Sub-weight adjustments
+        shared_bonus = min(len(src_views & dst_views) * self._BONUS_SHARED_VIEWS_PER, self._BONUS_SHARED_VIEWS_MAX)
+        coverage_bonus = min(len(self._fixed_descendants[dst]) * self._BONUS_COVERAGE_PER, self._BONUS_COVERAGE_MAX)
+        view_penalty = self._PENALTY_VIEW_COUNT if len(src_views) > len(dst_views) else 0
+
+        # Deterministic tie-breaker (very small, only matters when all else is equal)
+        edge_str = f"{src.space}:{src.external_id}->{dst.space}:{dst.external_id}"
+        tie_breaker = sum(ord(c) for c in edge_str) / self._TIE_BREAKER_DIVISOR
+
+        if dst in self.modifiable_containers:
+            return self._TIER_USER_TO_USER - shared_bonus - coverage_bonus + view_penalty + tie_breaker
+
+        return self._TIER_USER_TO_EXTERNAL - shared_bonus - coverage_bonus + tie_breaker

cognite/neat/_data_model/_constants.py

@@ -61,6 +61,7 @@ COGNITE_CONCEPTS: tuple[str, ...] = (
 
 COGNITE_SPACES = (
     CDF_CDM_SPACE,
+    "cdf_idm",
     "cdf_360_image_schema",
     "cdf_3d_schema",
     "cdf_apm",

cognite/neat/_data_model/importers/__init__.py

@@ -1,5 +1,5 @@
-from ._api_importer import DMSAPIImporter
+from ._api_importer import DMSAPICreator, DMSAPIImporter
 from ._base import DMSImporter
 from ._table_importer.importer import DMSTableImporter
 
-__all__ = ["DMSAPIImporter", "DMSImporter", "DMSTableImporter"]
+__all__ = ["DMSAPICreator", "DMSAPIImporter", "DMSImporter", "DMSTableImporter"]

cognite/neat/_data_model/importers/_api_importer.py

@@ -1,19 +1,30 @@
 import difflib
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 import yaml
 from pydantic import ValidationError
 
 from cognite.neat._client import NeatClient
+from cognite.neat._data_model._analysis import ValidationResources
+from cognite.neat._data_model._snapshot import SchemaSnapshot
 from cognite.neat._data_model.importers._base import DMSImporter
 from cognite.neat._data_model.models.dms import (
     DataModelReference,
     RequestSchema,
     SpaceReference,
 )
-from cognite.neat._exceptions import CDFAPIException, DataModelImportException, FileReadException
-from cognite.neat._issues import ModelSyntaxError
+from cognite.neat._data_model.models.dms._data_model import DataModelRequest
+from cognite.neat._data_model.models.dms._references import ViewReference
+from cognite.neat._data_model.models.dms._views import ViewRequest
+from cognite.neat._data_model.models.entities._parser import parse_entities
+from cognite.neat._exceptions import (
+    CDFAPIException,
+    DataModelCreateException,
+    DataModelImportException,
+    FileReadException,
+)
+from cognite.neat._issues import ConsistencyError, ModelSyntaxError
 from cognite.neat._utils.http_client import FailedRequestMessage
 from cognite.neat._utils.text import humanize_collection
 from cognite.neat._utils.validation import ValidationContext, humanize_validation_error
@@ -164,3 +175,157 @@ class DMSAPIImporter(DMSImporter):
             )
         schema_data["dataModel"] = data_model
         return schema_data
+
+
+class DMSAPICreator(DMSImporter):
+    """Creates data model from the existing schema components in CDF"""
+
+    def __init__(
+        self,
+        cdf_snapshot: SchemaSnapshot,
+        space: str,
+        external_id: str,
+        version: str,
+        views: list[str],
+        name: str | None = None,
+        description: str | None = None,
+        kind: Literal["solution"] = "solution",
+    ) -> None:
+        self._resources = ValidationResources("rebuild", local=cdf_snapshot, cdf=cdf_snapshot)
+        self._space = space
+        self._external_id = external_id
+        self._version = version
+        self._name = name
+        self._description = description
+        self._kind = kind
+        self._views = views
+
+    def to_data_model(self) -> RequestSchema:
+        if self._kind == "solution":
+            return self._to_solution_model()
+        else:
+            raise NotImplementedError(f"Data model kind '{self._kind}' is not supported yet.")
+
+    def _to_solution_model(self) -> RequestSchema:
+        """Creates solution data model from provided views"""
+
+        errors, view_refs = self._parse_view_references(self._views)
+
+        if not view_refs:
+            errors.append(ModelSyntaxError(message="No valid views provided to create the data model."))
+
+        # Check if all views exist in the cdf snapshot:
+        for view in view_refs:
+            if not self._resources.select_view(view):
+                errors.append(
+                    ConsistencyError(
+                        message=f"View '{view}' not found in the provided CDF snapshot. Cannot create data model."
+                    )
+                )
+
+        if errors:
+            raise DataModelCreateException(errors)
+
+        # now we iterate over the views, expand them and add them to the data model
+        expanded_views: list[ViewRequest] = []
+
+        for view in view_refs:
+            expanded_view = self._resources.expand_view_properties(view)
+            if not expanded_view:
+                raise RuntimeError(f"Failed to expand view '{view}' despite earlier checks. This is a bug.")
+
+            # make a deep copy to avoid modifying the cached view in resources
+            expanded_view = expanded_view.model_copy(deep=True)
+
+            # remove implements after expansion
+            expanded_view.implements = None
+
+            # set space and version to data model values
+            expanded_view.space = self._space
+            expanded_view.version = self._version
+
+            # Connections should be dropped if their source are not part of the expanded view
+            properties_to_remove = []
+            for id, property_ in expanded_view.properties.items():
+                # Currently only supporting explicit connections where source is defined
+                if self._resources.is_explicit_connection(property_):
+                    source = property_.source
+                    if source not in view_refs:
+                        properties_to_remove.append(id)
+
+                    # Update source to point to view of solution data model
+                    else:
+                        property_.source = ViewReference(
+                            space=self._space, external_id=source.external_id, version=self._version
+                        )
+
+            # Dropping connections which sources will not be part of the data model
+            for property_id in properties_to_remove:
+                expanded_view.properties.pop(property_id)
+
+            expanded_views.append(expanded_view)
+
+        data_model = DataModelRequest(
+            space=self._space,
+            externalId=self._external_id,
+            version=self._version,
+            name=self._name,
+            description=self._description,
+            views=[view.as_reference() for view in expanded_views],
+        )
+
+        return RequestSchema(dataModel=data_model, views=expanded_views)
+
+    @classmethod
+    def _parse_view_references(
+        cls, views: list[str]
+    ) -> tuple[list[ModelSyntaxError | ConsistencyError], list[ViewReference]]:
+        """Parses list of view strings in to list of view references
+
+        Args:
+            views : list of view references in a short string format
+
+        Returns:
+            Tuple of errors and view references
+        """
+        view_references: list[ViewReference] = []
+        errors: list[ModelSyntaxError | ConsistencyError] = []
+
+        for view in views:
+            try:
+                entity = parse_entities(view)
+                if not entity:
+                    errors.append(ModelSyntaxError(message=f"Invalid view reference '{view}': Could not parse entity."))
+                    continue
+
+                if len(entity) != 1:
+                    errors.append(
+                        ModelSyntaxError(message=f"Invalid view reference '{view}': Expected a single view definition.")
+                    )
+                    continue
+
+                if "version" not in entity[0].properties:
+                    errors.append(
+                        ModelSyntaxError(message=f"Invalid view reference '{view}': Missing 'version' property.")
+                    )
+                    continue
+
+                try:
+                    view_ref = ViewReference(
+                        space=entity[0].prefix,
+                        external_id=entity[0].suffix,
+                        version=str(entity[0].properties["version"]),
+                    )
+                    view_references.append(view_ref)
+                except ValidationError as e:
+                    humanized = [humanize_validation_error(error) for error in e.errors()]
+                    errors.append(
+                        ModelSyntaxError(
+                            message=f"Invalid view reference '{view}', cannot parse it: " + ", ".join(humanized)
+                        )
+                    )
+
+            except ValueError as e:
+                errors.append(ModelSyntaxError(message=f"Invalid view reference '{view}', cannot parse it: {e}"))
+
+        return errors, view_references

cognite/neat/_data_model/validation/dms/__init__.py

@@ -37,6 +37,11 @@ from ._limits import (
     ViewPropertyCountIsOutOfLimits,
 )
 from ._orchestrator import DmsDataModelValidation
+from ._performance import (
+    MissingRequiresConstraint,
+    SuboptimalRequiresConstraint,
+    UnresolvableQueryPerformance,
+)
 from ._views import ImplementedViewNotExisting, ViewToContainerMappingNotPossible
 
 __all__ = [
@@ -54,6 +59,7 @@ __all__ = [
     "ExternalContainerDoesNotExist",
     "ExternalContainerPropertyDoesNotExist",
     "ImplementedViewNotExisting",
+    "MissingRequiresConstraint",
     "RequiredContainerDoesNotExist",
     "RequiresConstraintCycle",
     "ReverseConnectionContainerMissing",
@@ -65,6 +71,8 @@ __all__ = [
     "ReverseConnectionSourceViewMissing",
     "ReverseConnectionTargetMismatch",
     "ReverseConnectionTargetMissing",
+    "SuboptimalRequiresConstraint",
+    "UnresolvableQueryPerformance",
     "ViewContainerCountIsOutOfLimits",
     "ViewImplementsCountIsOutOfLimits",
     "ViewMissingDescription",

cognite/neat/_data_model/validation/dms/_containers.py

@@ -223,12 +223,26 @@ class RequiresConstraintCycle(DataModelValidator):
 
     def run(self) -> list[ConsistencyError]:
         errors: list[ConsistencyError] = []
+        optimal_edges = self.validation_resources.oriented_mst_edges
 
         for cycle in self.validation_resources.requires_constraint_cycles:
             cycle_str = " -> ".join(str(c) for c in cycle) + f" -> {cycle[0]!s}"
+
+            # Find edges in cycle that are NOT in optimal structure (these should be removed)
+            edges_to_remove = []
+            for i, container in enumerate(cycle):
+                next_container = cycle[(i + 1) % len(cycle)]
+                edge = (container, next_container)
+                if edge not in optimal_edges:
+                    edges_to_remove.append(f"{container} -> {next_container}")
+
+            message = f"Requires constraints form a cycle: {cycle_str}"
+            if edges_to_remove:
+                message += f". Recommended removal: {', '.join(edges_to_remove)} (not in optimal structure)"
+
             errors.append(
                 ConsistencyError(
-                    message=f"Requires constraints form a cycle: {cycle_str}",
+                    message=message,
                     fix="Remove one of the requires constraints to break the cycle",
                     code=self.code,
                 )

cognite/neat/_data_model/validation/dms/_performance.py

@@ -0,0 +1,194 @@
+"""Validators for checking performance-related aspects of the data model."""
+
+from cognite.neat._data_model._analysis import RequiresChangeStatus
+from cognite.neat._data_model._constants import COGNITE_SPACES
+from cognite.neat._data_model.validation.dms._base import DataModelValidator
+from cognite.neat._issues import Recommendation
+
+BASE_CODE = "NEAT-DMS-PERFORMANCE"
+
+
+class MissingRequiresConstraint(DataModelValidator):
+    """
+    Recommends adding requires constraints to optimize query performance.
+
+    ## What it does
+    Identifies views that is mapping to containers where adding a requires constraint,
+    would improve query performance. The recommendation message indicates whether the
+    change is "safe" or requires attention to potential ingestion dependencies.
+
+    ## Why is this important?
+    Views without proper requires constraints may have poor query performance.
+    Adding requires constraints enables queries to perform under-the-hood optimizations.
+
+    ## Example
+    View `Valve` is mapping to both containers `Valve` and `CogniteEquipment`.
+    A `requires` constraint from `Valve` to `CogniteEquipment` is likely needed
+    to enable efficient query performance.
+    """
+
+    code = f"{BASE_CODE}-001"
+    issue_type = Recommendation
+    alpha = True
+
+    def run(self) -> list[Recommendation]:
+        recommendations: list[Recommendation] = []
+
+        for view_ref in self.validation_resources.merged.views:
+            changes = self.validation_resources.get_requires_changes_for_view(view_ref)
+
+            if changes.status != RequiresChangeStatus.CHANGES_AVAILABLE:
+                continue
+
+            for src, dst in changes.to_add:
+                src_views = self.validation_resources.views_by_container.get(src, set())
+                other_views_with_src = src_views - {view_ref}
+                views_impacted_by_change = self.validation_resources.find_views_mapping_to_containers([src, dst])
+
+                # Check if this is a "safe" recommendation (no cross-view dependencies)
+                is_safe = not other_views_with_src or view_ref in views_impacted_by_change
+
+                message = (
+                    f"View '{view_ref!s}' is not optimized for querying. "
+                    f"Add a 'requires' constraint from '{src!s}' to '{dst!s}'."
+                )
+                if not is_safe:
+                    # Find a superset view to suggest for ingestion
+                    merged_views = set(self.validation_resources.merged.views)
+                    superset_views = views_impacted_by_change & merged_views
+                    view_example = min(superset_views, key=str) if superset_views else None
+                    message += (
+                        " Note: this causes an ingestion dependency for this view, "
+                        " if you will be using this view to ingest instances, you will "
+                        f"need to populate these instances into '{dst!s}' first"
+                        + (f", for example through view '{view_example!s}'." if view_example else ".")
+                    )
+
+                recommendations.append(
+                    Recommendation(
+                        message=message,
+                        fix="Add requires constraint between the containers",
+                        code=self.code,
+                    )
+                )
+
+        return recommendations
+
+
+class SuboptimalRequiresConstraint(DataModelValidator):
+    """
+    Recommends removing requires constraints that are not optimal.
+
+    ## What it does
+    Identifies existing requires constraints that are not optimal for querying purposes,
+    as they are either redundant or create unnecessary ingestion dependencies when all
+    other optimal constraints are applied. These constraints can be safely removed
+    without affecting query performance.
+
+    ## Why is this important?
+    Unnecessary requires constraints can:
+    - Create unnecessary ingestion dependencies
+    - Cause invalid requires constraint cycles if optimal constraints are applied
+
+    ## Example
+    Container `Tag` has a `requires` constraint to `Pump`, but NEAT determined that
+    `Pump → Tag` is more optimal. The existing `Tag → Pump` constraint should then
+    be removed when applying all optimal constraints.
+    """
+
+    code = f"{BASE_CODE}-002"
+    issue_type = Recommendation
+    alpha = True
+
+    def run(self) -> list[Recommendation]:
+        recommendations: list[Recommendation] = []
+
+        for view_ref in self.validation_resources.merged.views:
+            changes = self.validation_resources.get_requires_changes_for_view(view_ref)
+
+            if changes.status != RequiresChangeStatus.CHANGES_AVAILABLE:
+                continue
+
+            for src, dst in changes.to_remove:
+                recommendations.append(
+                    Recommendation(
+                        message=(
+                            f"View '{view_ref!s}' has a requires constraint '{src!s}' -> '{dst!s}' "
+                            "that is not part of the optimal structure. Consider removing it."
+                        ),
+                        fix="Remove the unnecessary requires constraint",
+                        code=self.code,
+                    )
+                )
+
+        return recommendations
+
+
+class UnresolvableQueryPerformance(DataModelValidator):
+    """
+    Identifies views with query performance issues that cannot be resolved.
+    This is likely to be caused by unintended modeling choices.
+
+    ## What it does
+    Detects views where no valid requires constraint solution exists:
+
+    1. **View maps only to CDF built-in containers**:
+       Since CDF containers cannot be modified, no requires can be added.
+
+    2. **No valid solution**:
+       This view is causing issues when optimizing requires constraints
+       for other views, due to its structure (mapping non-overlapping containers)
+
+    ## Why is this important?
+    These views will have suboptimal query performance that CANNOT be fixed by
+    adding or removing requires constraints. The only solutions require restructuring:
+    - Add a view-specific container that requires all the other containers in the view
+    - Restructure the view to use different containers
+
+    ## Example
+    View `MultipleEquipments` maps only to containers `Valve` and `InstrumentEquipment`.
+    The optimal constraints are `Valve → CogniteEquipment` and `InstrumentEquipment → CogniteEquipment`
+    due to other views needing these constraints to optimize their query performance.
+    This means however, that neither Valve nor InstrumentEquipment can reach each other without
+    creating complex ingestion dependencies. The view needs a new container or restructuring.
+    """
+
+    code = f"{BASE_CODE}-003"
+    issue_type = Recommendation
+    alpha = True
+
+    def run(self) -> list[Recommendation]:
+        recommendations: list[Recommendation] = []
+
+        for view_ref in self.validation_resources.merged.views:
+            if view_ref.space in COGNITE_SPACES:
+                continue
+
+            changes = self.validation_resources.get_requires_changes_for_view(view_ref)
+
+            if changes.status == RequiresChangeStatus.NO_MODIFIABLE_CONTAINERS:
+                recommendations.append(
+                    Recommendation(
+                        message=(
+                            f"View '{view_ref!s}' has poor query performance. "
+                            "It maps only to CDF built-in containers which cannot have requires constraints. "
+                            "Consider adding a view-specific container that requires the others."
+                        ),
+                        fix="Add a container that requires the others, or restructure the view",
+                        code=self.code,
+                    )
+                )
+            elif changes.status == RequiresChangeStatus.UNSOLVABLE:
+                recommendations.append(
+                    Recommendation(
+                        message=(
+                            f"View '{view_ref!s}' has poor query performance. "
+                            "No valid requires constraint solution was found. "
+                            "Consider adding a view-specific container that requires the others."
+                        ),
+                        fix="Add a container that requires the others, or restructure the view",
+                        code=self.code,
+                    )
+                )
+
+        return recommendations

cognite/neat/_exceptions.py

@@ -1,6 +1,8 @@
 from abc import ABC
 from typing import TYPE_CHECKING
 
+from cognite.neat._issues import ConsistencyError
+
 if TYPE_CHECKING:
     from cognite.neat._issues import ModelSyntaxError
     from cognite.neat._utils.http_client import HTTPMessage
@@ -23,6 +25,17 @@ class DataModelImportException(NeatException):
         return f"Model import failed with {len(self.errors)} errors: " + "; ".join(map(str, self.errors))
 
 
+class DataModelCreateException(NeatException):
+    """Raised when there is an error creating a data model."""
+
+    def __init__(self, errors: "list[ModelSyntaxError | ConsistencyError]") -> None:
+        super().__init__(errors)
+        self.errors = errors
+
+    def __str__(self) -> str:
+        return f"Model creation failed with {len(self.errors)} errors: " + "; ".join(map(str, self.errors))
+
+
 class CDFAPIException(NeatException):
     """Raised when there is an error in an API call."""
 

cognite/neat/_session/_physical.py

@@ -1,3 +1,4 @@
+from types import MethodType
 from typing import Any, Literal
 
 from cognite.neat._client import NeatClient
@@ -13,7 +14,7 @@ from cognite.neat._data_model.exporters import (
     DMSTableYamlExporter,
 )
 from cognite.neat._data_model.exporters._table_exporter.workbook import WorkbookOptions
-from cognite.neat._data_model.importers import DMSAPIImporter, DMSImporter, DMSTableImporter
+from cognite.neat._data_model.importers import DMSAPICreator, DMSAPIImporter, DMSImporter, DMSTableImporter
 from cognite.neat._data_model.models.dms import DataModelReference
 from cognite.neat._data_model.validation.dms import DmsDataModelValidation
 from cognite.neat._exceptions import UserInputError
@@ -24,6 +25,7 @@ from cognite.neat._utils._reader import NeatReader
 from ._wrappers import session_wrapper
 
 
+@session_wrapper
 class PhysicalDataModel:
     """Read from a data source into NeatSession graph store."""
 
@@ -34,6 +36,10 @@ class PhysicalDataModel:
         self.read = ReadPhysicalDataModel(self._store, self._client, self._config)
         self.write = WritePhysicalDataModel(self._store, self._client, self._config)
 
+        # attach alpha methods
+        if self._config.alpha.enable_solution_model_creation:
+            self.create = MethodType(create, self)  # type: ignore[attr-defined]
+
     def _repr_html_(self) -> str:
         if not isinstance(self._store.state, PhysicalState):
             return "No physical data model. Get started by reading physical data model <em>.physica_data_mode.read</em>"
@@ -292,3 +298,51 @@ class WritePhysicalDataModel:
         )
         on_success = SchemaDeployer(self._client, options)
         return self._store.write_physical(writer, on_success)
+
+
+def create(
+    self: PhysicalDataModel,
+    space: str,
+    external_id: str,
+    version: str,
+    views: list[str],
+    name: str | None = None,
+    description: str | None = None,
+    kind: Literal["solution"] = "solution",
+) -> None:
+    """Create a solution data model in Neat from CDF views.
+
+    Args:
+        space (str): The schema space of the data model.
+        external_id (str): The external id of the data model.
+        version (str): The version of the data model.
+        views (list[str]): List of view external ids to include in the data model in the short string format
+            space:external_id(version=version)
+        name (str | None): The name of the data model. If None, the name will be fetched from CDF.
+        description (str | None): The description of the data model. If None, the description will be fetched from CDF.
+        kind (Literal["solution"]): The kind of the data model. Currently, only "solution" is supported.
+    """
+
+    if not self._store.cdf_snapshot.data_model:
+        raise ValueError("There are no data models in CDF. Cannot create solution model.")
+
+    creator = DMSAPICreator(
+        space=space,
+        external_id=external_id,
+        version=version,
+        views=views,
+        name=name,
+        description=description,
+        kind=kind,
+        cdf_snapshot=self._store.cdf_snapshot,
+    )
+
+    on_success = DmsDataModelValidation(
+        modus_operandi=self._config.modeling.mode,
+        cdf_snapshot=self._store.cdf_snapshot,
+        limits=self._store.cdf_limits,
+        can_run_validator=self._config.validation.can_run_validator,
+        enable_alpha_validators=self._config.alpha.enable_experimental_validators,
+    )
+
+    return self._store.read_physical(creator, on_success)

cognite/neat/_session/_wrappers.py

@@ -96,6 +96,24 @@ def session_wrapper(cls: type[T_Class]) -> type[T_Class]:
             if callable(attr):
                 # Replace the original method with wrapped version
                 setattr(cls, attr_name, _handle_method_call(attr))
-
-    # Return the modified class
+    # Intercept __init__ to wrap any methods added via setattr
+    original_init = cls.__init__
+
+    @wraps(original_init)
+    def pick_alpha_methods(self: HasStore, *args: Any, **kwargs: Any) -> Any:
+        """This method wraps any instance methods added during __init__. which is the case for alpha methods"""
+        original_init(self, *args, **kwargs)
+        # Wrap any instance methods added during init
+        for attr_name in dir(self):
+            if not attr_name.startswith("_"):
+                attr = getattr(self, attr_name, None)
+                # Check if it's an instance method (not from the class)
+                if callable(attr) and attr_name not in vars(self.__class__):
+                    # Wrap and set on the instance
+                    wrapped = (
+                        _handle_method_call(attr.__func__) if hasattr(attr, "__func__") else _handle_method_call(attr)
+                    )
+                    setattr(self, attr_name, wrapped.__get__(self, type(self)))
+
+    cls.__init__ = pick_alpha_methods  # type: ignore[assignment]
     return cls

cognite/neat/_store/_store.py

@@ -15,7 +15,7 @@ from cognite.neat._data_model.exporters._table_exporter.exporter import DMSTable
 from cognite.neat._data_model.importers import DMSImporter, DMSTableImporter
 from cognite.neat._data_model.models.dms import RequestSchema as PhysicalDataModel
 from cognite.neat._data_model.models.dms._limits import SchemaLimits
-from cognite.neat._exceptions import DataModelImportException
+from cognite.neat._exceptions import DataModelCreateException, DataModelImportException
 from cognite.neat._issues import IssueList
 from cognite.neat._state_machine._states import EmptyState, PhysicalState, State
 from cognite.neat._utils.text import NEWLINE
@@ -179,6 +179,9 @@ class NeatStore:
         except DataModelImportException as e:
             errors.extend(e.errors)
 
+        except DataModelCreateException as e:
+            errors.extend(e.errors)
+
         # these are all other errors, such as missing file, wrong format, etc.
         except Exception as e:
             raise e

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "1.0.28"
+__version__ = "1.0.30"
 __engine__ = "^2.0.4"

{cognite_neat-1.0.28.dist-info → cognite_neat-1.0.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 1.0.28
+Version: 1.0.30
 Summary: Knowledge graph transformation
 Author: Nikola Vasiljevic, Anders Albert
 Author-email: Nikola Vasiljevic <nikola.vasiljevic@cognite.com>, Anders Albert <anders.albert@cognite.com>

{cognite_neat-1.0.28.dist-info → cognite_neat-1.0.30.dist-info}/RECORD

@@ -15,10 +15,10 @@ cognite/neat/_client/init/main.py,sha256=D-9bsor07T84iFnTZLnhIFA1Xey9zsooHaDhXVe
 cognite/neat/_client/spaces_api.py,sha256=yb26ju3sKbVgiduMEbN4LDGan6vsC3z_JaW3p4FUdr0,2929
 cognite/neat/_client/statistics_api.py,sha256=5meeh0v5mxC2SMB7xGdOwMh4KkaX3DtpUjbGEPhNBJo,913
 cognite/neat/_client/views_api.py,sha256=YMaw7IaxU4gmixpd_t1u9JK9BHfNerf5DMNinGPCAa0,3692
-cognite/neat/_config.py,sha256=RVVV6qTkFlS88lJKShIcz9pcCV4OlCxFW8dUbSi50-4,10003
+cognite/neat/_config.py,sha256=IJS_R-86M4SLxdo644LZ0dE9h0jg2XBL1A4QKWJj0TQ,10160
 cognite/neat/_data_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite/neat/_data_model/_analysis.py,sha256=dN-udKm_5oD3217O4B_QIps2Hx4v50-Pu2fR0bQNQg0,23504
-cognite/neat/_data_model/_constants.py,sha256=E2axzdYjsIy7lTHsjW91wsv6r-pUwko8g6K8C_oRnxk,1707
+cognite/neat/_data_model/_analysis.py,sha256=Z5HQ1ExB58Y_2W79ovOXbhyHQiAuB0S86117ZYMMjpg,43285
+cognite/neat/_data_model/_constants.py,sha256=h6FaREqE2KG7hy2ZQVDq-3_yjVjlpSG6Usz2kadIUIs,1722
 cognite/neat/_data_model/_identifiers.py,sha256=lDLvMvYDgRNFgk5GmxWzOUunG7M3synAciNjzJI0m_o,1913
 cognite/neat/_data_model/_shared.py,sha256=H0gFqa8tKFNWuvdat5jL6OwySjCw3aQkLPY3wtb9Wrw,1302
 cognite/neat/_data_model/_snapshot.py,sha256=JBaKmL0Tmprz59SZ1JeB49BPMB8Hqa-OAOt0Bai8cw4,6305
@@ -37,8 +37,8 @@ cognite/neat/_data_model/exporters/_table_exporter/__init__.py,sha256=47DEQpj8HB
 cognite/neat/_data_model/exporters/_table_exporter/exporter.py,sha256=4BPu_Chtjh1EyOaKbThXYohsqllVOkCbSoNekNZuBXc,5159
 cognite/neat/_data_model/exporters/_table_exporter/workbook.py,sha256=1Afk1WqeNe9tiNeSAm0HrF8jTQ1kTbIv1D9hMztKwO8,18482
 cognite/neat/_data_model/exporters/_table_exporter/writer.py,sha256=k1gPrI8OdS75x3ncLn27Z-wnWgkOJ_eiCFnfp-rgdyY,21748
-cognite/neat/_data_model/importers/__init__.py,sha256=dHnKnC_AXk42z6wzEHK15dxIOh8xSEkuUf_AFRZls0E,193
-cognite/neat/_data_model/importers/_api_importer.py,sha256=H8Ow3Tt7utuAuBhC6s7yWvhGqunHAtE0r0XRsVAr6IE,7280
+cognite/neat/_data_model/importers/__init__.py,sha256=35MasidLXvQyi7aL7eyNbY0hRGZEGQOHjCSw3lHkBdg,225
+cognite/neat/_data_model/importers/_api_importer.py,sha256=jkSw74kwKCFC1RvEr0DOn34dhTlcqbiBTcWT5vBuXYk,13838
 cognite/neat/_data_model/importers/_base.py,sha256=NRB0FcEBj4GaethU68nRffBfTedBBA866A3zfJNfmiQ,433
 cognite/neat/_data_model/importers/_table_importer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_data_model/importers/_table_importer/data_classes.py,sha256=_Hfub4GZNxiq01JcxijjeNFaecJXQmmMNoFe7apo0iM,11466
@@ -76,16 +76,17 @@ cognite/neat/_data_model/models/entities/_data_types.py,sha256=DfdEWGek7gODro-_0
 cognite/neat/_data_model/models/entities/_identifiers.py,sha256=a7ojJKY1ErZgUANHscEwkctX4RJ7bWEEWOQt5g5Tsdk,1915
 cognite/neat/_data_model/models/entities/_parser.py,sha256=zef_pSDZYMZrJl4IKreFDR577KutfhtN1xpH3Ayjt2o,7669
 cognite/neat/_data_model/validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite/neat/_data_model/validation/dms/__init__.py,sha256=STb0mYmyD-E6CfhjaXNOgWM1LvYSm59m6-Khu9cEhNI,2702
+cognite/neat/_data_model/validation/dms/__init__.py,sha256=Z6P8TTXZR1KIJreDieRVTcJVvovdZXCLXRbzm86UojI,2936
 cognite/neat/_data_model/validation/dms/_ai_readiness.py,sha256=bffMQJ5pqumU5P3KaEdQP67OO5eMKqzN2BAWbUjG6KE,16143
 cognite/neat/_data_model/validation/dms/_base.py,sha256=G_gMPTgKwyBW62UcCkKIBVHWp9ufAZPJ2p7o69_dJI0,820
 cognite/neat/_data_model/validation/dms/_connections.py,sha256=-kUXf2_3V50ckxwXRwJoTHsKkS5zxiBKkkkHg8Dm4WI,30353
 cognite/neat/_data_model/validation/dms/_consistency.py,sha256=IKSUoRQfQQcsymviESW9VuTFX7jsZMXfsObeZHPdov4,2435
-cognite/neat/_data_model/validation/dms/_containers.py,sha256=8pVnmeX6G9tQaGzzwRB_40y7TYUm4guaNbRiFgoGILU,9895
+cognite/neat/_data_model/validation/dms/_containers.py,sha256=n2L8HiJLylHIkzGi1veGb2QLVEFZuLlOwws77mxm0Fw,10552
 cognite/neat/_data_model/validation/dms/_limits.py,sha256=rAIh54DJBPi3J7d7eD-jMdldZS8R2vlkQ5MD9RxNsrI,14830
 cognite/neat/_data_model/validation/dms/_orchestrator.py,sha256=qiuUSUmNhekFyBARUUO2yhG-X9AeU_LL49UrJ65JXFA,2964
+cognite/neat/_data_model/validation/dms/_performance.py,sha256=hq4neZfoa0EKdYjhiQpugP9jrhSpTsn8_VJRncTj5Bk,8500
 cognite/neat/_data_model/validation/dms/_views.py,sha256=pRdnj5ZBnHNnbLKleXGbipteGma8_l5AYsDIfqgAil4,6345
-cognite/neat/_exceptions.py,sha256=mO19TEecZYDNqSvzuc6JmCLFQ70eniT1-Gb0AEbgbzE,2090
+cognite/neat/_exceptions.py,sha256=hOjPL1vFNNAZzqAHFB9l9ek-XJEBKcqiaPk0onwLPns,2540
 cognite/neat/_issues.py,sha256=wH1mnkrpBsHUkQMGUHFLUIQWQlfJ_qMfdF7q0d9wNhY,1871
 cognite/neat/_session/__init__.py,sha256=owqW5Mml2DSZx1AvPvwNRTBngfhBNrQ6EH-7CKL7Jp0,61
 cognite/neat/_session/_cdf.py,sha256=Ps49pc2tKriImpDkcIABnCgrfoX-L3QGmnXK8ceJ1Lc,1365
@@ -104,7 +105,7 @@ cognite/neat/_session/_html/templates/deployment.html,sha256=aLDXMbF3pcSqnCpUYVG
 cognite/neat/_session/_html/templates/issues.html,sha256=zjhkJcPK0hMp_ZKJ9RCf88tuZxQyTYRPxzpqx33Nkt0,1661
 cognite/neat/_session/_html/templates/statistics.html,sha256=C-ghoT8xzBehAJLOonNzCB418LW-FA60MaZBHlW1D5c,968
 cognite/neat/_session/_issues.py,sha256=E8UQeSJURg2dm4MF1pfD9dp-heSRT7pgQZgKlD1-FGs,2723
-cognite/neat/_session/_physical.py,sha256=e3i9xuLa4bMOa-mJxbf4AyLZ2UnPOPh05P-E7E0lRHY,12449
+cognite/neat/_session/_physical.py,sha256=uzgyNfchv5axhDMjdGB6hnpbvT_QfXKmI6zhwbsFW-o,14448
 cognite/neat/_session/_result/__init__.py,sha256=8A0BKgsqnjxkiHUlCpHBNl3mrFWtyjaWYnh0jssE6QU,50
 cognite/neat/_session/_result/_deployment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_session/_result/_deployment/_physical/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -117,13 +118,13 @@ cognite/neat/_session/_usage_analytics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JC
 cognite/neat/_session/_usage_analytics/_collector.py,sha256=8yVfzt8KFfZ-ldkVjDWazuQbs45Q3r6vWKcZEwU8i18,4734
 cognite/neat/_session/_usage_analytics/_constants.py,sha256=-tVdYrCTMKfuMlbO7AlzC29Nug41ug6uuX9DFuihpJg,561
 cognite/neat/_session/_usage_analytics/_storage.py,sha256=w3mUvmPysww6vM3PZBjg6jzNEsDISl7FJ1j19LNs26E,7779
-cognite/neat/_session/_wrappers.py,sha256=28RjNsRs6317Ml-ZHFytBT7c8z_aMQ-adkQVtrzEC6U,4412
+cognite/neat/_session/_wrappers.py,sha256=3GADffOVyGryXknnN88hKhwTHvtZfeFBYpCROuXyGXY,5447
 cognite/neat/_state_machine/__init__.py,sha256=wrtQUHETiLzYM0pFo7JC6pJCiXetHADQbyMu8pU8rQU,195
 cognite/neat/_state_machine/_base.py,sha256=-ZpeAhM6l6N6W70dET25tAzOxaaK5aa474eabwZVzjA,1112
 cognite/neat/_state_machine/_states.py,sha256=nmj4SmunpDYcBsNx8A284xnXGS43wuUuWpMMORha2DE,1170
 cognite/neat/_store/__init__.py,sha256=TvM9CcFbtOSrxydPAuJi6Bv_iiGard1Mxfx42ZFoTl0,55
 cognite/neat/_store/_provenance.py,sha256=1zzRDWjR9twZu2jVyIG3UdYdIXtQKJ7uF8a0hV7LEuA,3368
-cognite/neat/_store/_store.py,sha256=jtJPBQ8PBG0UlgzSJJpzOIRkC2Np3fHNtV4omRC6H5A,9629
+cognite/neat/_store/_store.py,sha256=3mfw5zFL2nLad57gHbriDnwd5WMy4qoUKKinK5k3xwA,9738
 cognite/neat/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_utils/_reader.py,sha256=pBAwGK_UMd-mGnAP3cXXj3SrORocR3lFKxn-WaVjqsY,5367
 cognite/neat/_utils/auxiliary.py,sha256=YQMpqCxccex_slmLYrR5icVX9aeLbD793ou7IrbNTFs,1654
@@ -327,9 +328,9 @@ cognite/neat/_v0/session/_template.py,sha256=BNcvrW5y7LWzRM1XFxZkfR1Nc7e8UgjBClH
 cognite/neat/_v0/session/_to.py,sha256=AnsRSDDdfFyYwSgi0Z-904X7WdLtPfLlR0x1xsu_jAo,19447
 cognite/neat/_v0/session/_wizard.py,sha256=baPJgXAAF3d1bn4nbIzon1gWfJOeS5T43UXRDJEnD3c,1490
 cognite/neat/_v0/session/exceptions.py,sha256=jv52D-SjxGfgqaHR8vnpzo0SOJETIuwbyffSWAxSDJw,3495
-cognite/neat/_version.py,sha256=D8wnGH1r0wYJFo06cmkFVRH6v-0euoV5JeDvOyoYFfE,45
+cognite/neat/_version.py,sha256=6cfMmDsIfl6IMAFwlEU9DPRkWwKrndMYQPZ5zAZvnuk,45
 cognite/neat/legacy.py,sha256=DMFeLCSBLT2enk-nm1KfX1rKR2DQDpxY-w6ThY0y9c8,421
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite_neat-1.0.28.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
-cognite_neat-1.0.28.dist-info/METADATA,sha256=i_1J8DaOFH5SdieuKec3Rp521-bBB0bWdPnO2NSgVZg,6872
-cognite_neat-1.0.28.dist-info/RECORD,,
+cognite_neat-1.0.30.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+cognite_neat-1.0.30.dist-info/METADATA,sha256=ixyEZ8MjefyUNCq_1yz_hoqgVeARW7_jFhxCrF0OfW0,6872
+cognite_neat-1.0.30.dist-info/RECORD,,