cognite-neat 1.0.28__tar.gz → 1.0.29__tar.gz

{cognite_neat-1.0.28 → cognite_neat-1.0.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 1.0.28
+Version: 1.0.29
 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 → cognite_neat-1.0.29}/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-1.0.28 → cognite_neat-1.0.29}/cognite/neat/_data_model/_analysis.py

@@ -43,10 +43,14 @@ _NodeT = TypeVar("_NodeT", ContainerReference, ViewReference)
 
 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 +389,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.

cognite_neat-1.0.29/cognite/neat/_data_model/importers/__init__.py

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

{cognite_neat-1.0.28 → cognite_neat-1.0.29}/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-1.0.28 → cognite_neat-1.0.29}/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-1.0.28 → cognite_neat-1.0.29}/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-1.0.28 → cognite_neat-1.0.29}/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-1.0.28 → cognite_neat-1.0.29}/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-1.0.29/cognite/neat/_version.py

@@ -0,0 +1,2 @@
+__version__ = "1.0.29"
+__engine__ = "^2.0.4"

{cognite_neat-1.0.28 → cognite_neat-1.0.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cognite-neat"
-version = "1.0.28"
+version = "1.0.29"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

cognite_neat-1.0.28/cognite/neat/_data_model/importers/__init__.py

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

cognite_neat-1.0.28/cognite/neat/_version.py

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