cognite-neat 0.119.1__py3-none-any.whl → 0.119.3__py3-none-any.whl

cognite/neat/_rules/exporters/_rules2excel.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
 import itertools
-import json
-from datetime import datetime, timezone
+from datetime import datetime
 from pathlib import Path
 from types import GenericAlias
 from typing import Any, ClassVar, Literal, cast, get_args
@@ -13,17 +12,17 @@ from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
 from openpyxl.worksheet.worksheet import Worksheet
 from rdflib import Namespace
 
+from cognite.neat._constants import COGNITE_CONCEPTS
 from cognite.neat._rules._constants import get_internal_properties
 from cognite.neat._rules._shared import VerifiedRules
 from cognite.neat._rules.models import (
-    ExtensionCategory,
-    SchemaCompleteness,
     SheetRow,
 )
-from cognite.neat._rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE
-from cognite.neat._rules.models.dms import DMSMetadata
+from cognite.neat._rules.models._base_rules import BaseMetadata, RoleTypes
+from cognite.neat._rules.models.data_types import (
+    _DATA_TYPE_BY_DMS_TYPE,
+)
 from cognite.neat._rules.models.dms._rules import DMSRules
-from cognite.neat._rules.models.information import InformationMetadata
 from cognite.neat._rules.models.information._rules import InformationRules
 from cognite.neat._utils.spreadsheet import (
     find_column_with_value,
@@ -107,6 +106,51 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
             data.close()
         return None
 
+    def template(self, role: RoleTypes, filepath: Path | None = None) -> None | Workbook:
+        """This method will create an spreadsheet template for data modeling depending on the role.
+
+        Args:
+            role: The role for which the template is created. Can be either "dms" or "information".
+            filepath: The path to the file where the template will be saved.
+
+        """
+        workbook = Workbook()
+        # Remove default sheet named "Sheet"
+        workbook.remove(workbook["Sheet"])
+
+        rules_model = DMSRules if role == RoleTypes.dms else InformationRules
+
+        headers_by_sheet = rules_model.headers_by_sheet(by_alias=True)
+        headers_by_sheet.pop("Metadata")
+
+        self._write_metadata_sheet(
+            workbook,
+            cast(BaseMetadata, rules_model.model_fields["metadata"].annotation).default().model_dump(),
+        )
+
+        for sheet_name, headers in headers_by_sheet.items():
+            if sheet_name in ("Metadata", "Prefixes", "Reference", "Last"):
+                continue
+            sheet = self._create_sheet_with_header(workbook, headers, sheet_name)
+            self._style_sheet_header(sheet, headers)
+
+        self._adjust_column_widths(workbook)
+        self._hide_internal_columns(workbook)
+
+        if role == RoleTypes.dms:
+            self._add_dms_drop_downs(workbook)
+        else:
+            self._add_info_drop_downs(workbook)
+
+        if filepath:
+            try:
+                workbook.save(filepath)
+            finally:
+                workbook.close()
+            return None
+
+        return workbook
+
     def export(self, rules: VerifiedRules) -> Workbook:
         workbook = Workbook()
         # Remove default sheet named "Sheet"
@@ -129,23 +173,35 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
             self._adjust_column_widths(workbook)
 
         if self.hide_internal_columns:
-            for sheet in workbook.sheetnames:
-                if sheet.lower() == "metadata":
-                    continue
-                ws = workbook[sheet]
-                for col in get_internal_properties():
-                    column_letter = find_column_with_value(ws, col)
-                    if column_letter:
-                        ws.column_dimensions[column_letter].hidden = True
+            self._hide_internal_columns(workbook)
 
         # Only add drop downs if the rules are DMSRules
         if self.add_drop_downs and isinstance(rules, DMSRules):
-            self._add_drop_downs(workbook)
+            self._add_dms_drop_downs(workbook)
+        elif self.add_drop_downs and isinstance(rules, InformationRules):
+            self._add_info_drop_downs(workbook)
 
         return workbook
 
-    def _add_drop_downs(self, workbook: Workbook, no_rows: int = 100) -> None:
-        """Adds drop down menus to specific columns for fast and accurate data entry.
+    def _hide_internal_columns(self, workbook: Workbook) -> None:
+        """Hides internal columns in workbook sheets.
+
+        Args:
+            workbook: Workbook representation of the Excel file.
+
+        """
+        for sheet in workbook.sheetnames:
+            if sheet.lower() == "metadata":
+                continue
+            ws = workbook[sheet]
+            for col in get_internal_properties():
+                column_letter = find_column_with_value(ws, col)
+                if column_letter:
+                    ws.column_dimensions[column_letter].hidden = True
+
+    def _add_info_drop_downs(self, workbook: Workbook, no_rows: int = 100) -> None:
+        """Adds drop down menus to specific columns for fast and accurate data entry
+        in the Information rules.
 
         Args:
             workbook: Workbook representation of the Excel file.
@@ -160,14 +216,101 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
             as and Excel file. Probably, the validation is not copied to the new column,
             but instead reference to the data validation object is added.
         """
+        self._make_helper_info_sheet(workbook, no_rows)
 
-        self._make_helper_sheet(workbook)
+        # We need create individual data validation and cannot re-use the same one due
+        # the internals of openpyxl
+        dv_classes = generate_data_validation(self._helper_sheet_name, "A", no_header_rows=0, no_rows=no_rows)
+        dv_value_types = generate_data_validation(self._helper_sheet_name, "B", no_header_rows=0, no_rows=no_rows)
+        dv_implements = generate_data_validation(
+            self._helper_sheet_name,
+            "C",
+            no_header_rows=0,
+            no_rows=no_rows + len(COGNITE_CONCEPTS),
+        )
+
+        workbook["Properties"].add_data_validation(dv_classes)
+        workbook["Properties"].add_data_validation(dv_value_types)
+        workbook["Classes"].add_data_validation(dv_implements)
+
+        # we multiply no_rows with 100 since a view can have max 100 properties per view
+        if column := find_column_with_value(workbook["Properties"], "Class"):
+            dv_classes.add(f"{column}{3}:{column}{no_rows * 100}")
+
+        if column := find_column_with_value(workbook["Properties"], "Value Type"):
+            dv_value_types.add(f"{column}{3}:{column}{no_rows * 100}")
+
+        if column := find_column_with_value(workbook["Classes"], "Implements"):
+            dv_implements.add(f"{column}{3}:{column}{no_rows}")
+
+    def _make_helper_info_sheet(self, workbook: Workbook, no_rows: int) -> None:
+        """This helper Information sheet is used as source of data for drop down menus creation"""
+        workbook.create_sheet(title=self._helper_sheet_name)
+
+        for dtype_counter, dtype in enumerate(_DATA_TYPE_BY_DMS_TYPE.values()):
+            # skip types which require special handling or are surpassed by CDM
+            if dtype.xsd in ["enum", "timeseries", "sequence", "file", "json"]:
+                continue
+            workbook[self._helper_sheet_name].cell(row=dtype_counter + 1, column=2, value=dtype.xsd)
+
+        # Add Cognite Core Data Views:
+        for concept_counter, concept in enumerate(COGNITE_CONCEPTS):
+            workbook[self._helper_sheet_name].cell(
+                row=concept_counter + 1,
+                column=3,
+                value=f"cdf_cdm:{concept}(version=v1)",
+            )
+
+        for i in range(no_rows):
+            workbook[self._helper_sheet_name].cell(
+                row=i + 1,
+                column=1,
+                value=f'=IF(ISBLANK(Classes!A{i + 3}), "", Classes!A{i + 3})',
+            )
+            workbook[self._helper_sheet_name].cell(
+                row=dtype_counter + i + 2,
+                column=2,
+                value=f'=IF(ISBLANK(Classes!A{i + 3}), "", Classes!A{i + 3})',
+            )
+            workbook[self._helper_sheet_name].cell(
+                row=concept_counter + i + 2,
+                column=3,
+                value=f'=IF(ISBLANK(Classes!A{i + 3}), "", Classes!A{i + 3})',
+            )
+
+        workbook[self._helper_sheet_name].sheet_state = "hidden"
+
+    def _add_dms_drop_downs(self, workbook: Workbook, no_rows: int = 100) -> None:
+        """Adds drop down menus to specific columns for fast and accurate data entry
+        in the DMS rules.
+
+        Args:
+            workbook: Workbook representation of the Excel file.
+            no_rows: number of rows to add drop down menus. Defaults to 100*100.
+
+        !!! note "Why no_rows=100?"
+            Maximum number of views per data model is 100, thus this value is set accordingly
+
+        !!! note "Why defining individual data validation per desired column?
+            This is due to the internal working of openpyxl. Adding same validation to
+            different column leads to unexpected behavior when the openpyxl workbook is exported
+            as and Excel file. Probably, the validation is not copied to the new column,
+            but instead reference to the data validation object is added.
+        """
+
+        self._make_helper_dms_sheet(workbook, no_rows)
 
         # We need create individual data validation and cannot re-use the same one due
         # the internals of openpyxl
         dv_views = generate_data_validation(self._helper_sheet_name, "A", no_header_rows=0, no_rows=no_rows)
-        dv_containers = generate_data_validation(self._helper_sheet_name, "b", no_header_rows=0, no_rows=no_rows)
+        dv_containers = generate_data_validation(self._helper_sheet_name, "B", no_header_rows=0, no_rows=no_rows)
         dv_value_types = generate_data_validation(self._helper_sheet_name, "C", no_header_rows=0, no_rows=no_rows)
+        dv_implements = generate_data_validation(
+            self._helper_sheet_name,
+            "F",
+            no_header_rows=0,
+            no_rows=no_rows + len(COGNITE_CONCEPTS),
+        )
 
         dv_immutable = generate_data_validation(self._helper_sheet_name, "D", no_header_rows=0, no_rows=3)
         dv_in_model = generate_data_validation(self._helper_sheet_name, "D", no_header_rows=0, no_rows=3)
@@ -178,6 +321,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         workbook["Properties"].add_data_validation(dv_value_types)
         workbook["Properties"].add_data_validation(dv_immutable)
         workbook["Views"].add_data_validation(dv_in_model)
+        workbook["Views"].add_data_validation(dv_implements)
         workbook["Containers"].add_data_validation(dv_used_for)
 
         # we multiply no_rows with 100 since a view can have max 100 properties per view
@@ -196,22 +340,30 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         if column := find_column_with_value(workbook["Views"], "In Model"):
             dv_in_model.add(f"{column}{3}:{column}{no_rows}")
 
+        if column := find_column_with_value(workbook["Views"], "Implements"):
+            dv_implements.add(f"{column}{3}:{column}{no_rows}")
+
         if column := find_column_with_value(workbook["Containers"], "Used For"):
             dv_used_for.add(f"{column}{3}:{column}{no_rows}")
 
-    def _make_helper_sheet(self, workbook: Workbook) -> None:
-        """This helper sheet is used as source of data for drop down menus creation
-
-        !!! note "Why 100 rows?"
-            The number of rows is set to 100 since this is the maximum number of views
-            per data model.
-        """
+    def _make_helper_dms_sheet(self, workbook: Workbook, no_rows: int) -> None:
+        """This helper DMS sheet is used as source of data for drop down menus creation"""
         workbook.create_sheet(title=self._helper_sheet_name)
 
-        for counter, dtype in enumerate(_DATA_TYPE_BY_DMS_TYPE):
-            workbook[self._helper_sheet_name].cell(row=counter + 1, column=3, value=dtype)
+        for dtype_counter, dtype in enumerate(_DATA_TYPE_BY_DMS_TYPE):
+            if dtype in ["enum", "timeseries", "sequence", "file", "json"]:
+                continue
+            workbook[self._helper_sheet_name].cell(row=dtype_counter + 1, column=3, value=dtype)
 
-        for i in range(100):
+        # Add Cognite Core Data Views:
+        for concept_counter, concept in enumerate(COGNITE_CONCEPTS):
+            workbook[self._helper_sheet_name].cell(
+                row=concept_counter + 1,
+                column=6,
+                value=f"cdf_cdm:{concept}(version=v1)",
+            )
+
+        for i in range(no_rows):
             workbook[self._helper_sheet_name].cell(
                 row=i + 1,
                 column=1,
@@ -223,10 +375,15 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
                 value=f'=IF(ISBLANK(Containers!A{i + 3}), "", Containers!A{i + 3})',
             )
             workbook[self._helper_sheet_name].cell(
-                row=counter + i + 2,
+                row=dtype_counter + i + 2,
                 column=3,
                 value=f'=IF(ISBLANK(Views!A{i + 3}), "", Views!A{i + 3})',
             )
+            workbook[self._helper_sheet_name].cell(
+                row=concept_counter + i + 2,
+                column=6,
+                value=f'=IF(ISBLANK(Views!A{i + 3}), "", Views!A{i + 3})',
+            )
 
         for i, value in enumerate([True, False, ""]):
             workbook[self._helper_sheet_name].cell(row=i + 1, column=4, value=cast(bool | str, value))
@@ -236,6 +393,56 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
 
         workbook[self._helper_sheet_name].sheet_state = "hidden"
 
+    def _create_sheet_with_header(
+        self,
+        workbook: Workbook,
+        headers: list[str],
+        sheet_name: str,
+        sheet_prefix: str = "",
+    ) -> Worksheet:
+        """Creates an empty sheet with the given headers.
+
+        Args:
+            workbook: The workbook to add the sheet to.
+            headers: The headers to add to the sheet.
+            sheet_name: The name of the sheet.
+            sheet_prefix: The prefix to add to the sheet name, if any.
+        """
+
+        sheet = workbook.create_sheet(f"{sheet_prefix}{sheet_name}")
+        main_header = self._main_header_by_sheet_name[sheet_name]
+        sheet.append([main_header] + [""] * (len(headers) - 1))
+
+        if headers[0] == "Neat ID":
+            # Move the Neat ID to the end of the columns
+            headers = headers[1:] + ["Neat ID"]
+
+        # Append the headers to the sheet
+        sheet.append(headers)
+
+        return sheet
+
+    def _style_sheet_header(self, sheet: Worksheet, headers: list[str]) -> None:
+        """Styles the sheet with the given headers.
+
+        Args:
+            sheet: The sheet to style.
+            headers: The headers to style.
+        """
+        if self._styling_level > 0:
+            # This freezes all rows above the given row
+            sheet.freeze_panes = sheet["A3"]
+
+            sheet["A1"].alignment = Alignment(horizontal="left")
+
+        if self._styling_level > 1:
+            # Make the header row bold, larger, and colored
+            for cell, *_ in sheet.iter_cols(min_row=1, max_row=1, min_col=1, max_col=len(headers)):
+                cell.font = Font(bold=True, size=20)
+                cell.fill = PatternFill(fgColor="FFC000", patternType="solid")
+            for cell in sheet["2"]:
+                cell.font = Font(bold=True, size=14)
+
     def _write_sheets(
         self,
         workbook: Workbook,
@@ -246,16 +453,8 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         for sheet_name, headers in rules.headers_by_sheet(by_alias=True).items():
             if sheet_name in ("Metadata", "Prefixes", "Reference", "Last"):
                 continue
-            sheet = workbook.create_sheet(f"{sheet_prefix}{sheet_name}")
-
-            main_header = self._main_header_by_sheet_name[sheet_name]
-            sheet.append([main_header] + [""] * (len(headers) - 1))
 
-            if headers[0] == "Neat ID":
-                # Move the Neat ID to the end of the columns
-                headers = headers[1:] + ["Neat ID"]
-
-            sheet.append(headers)
+            sheet = self._create_sheet_with_header(workbook, headers, sheet_name, sheet_prefix)
 
             fill_colors = itertools.cycle(["CADCFC", "FFFFFF"])
             fill_color = next(fill_colors)
@@ -292,19 +491,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
                         cell.border = Border(left=side, right=side, top=side, bottom=side)
                 last_class = class_
 
-            if self._styling_level > 0:
-                # This freezes all rows above the given row
-                sheet.freeze_panes = sheet["A3"]
-
-                sheet["A1"].alignment = Alignment(horizontal="left")
-
-            if self._styling_level > 1:
-                # Make the header row bold, larger, and colored
-                for cell, *_ in sheet.iter_cols(min_row=1, max_row=1, min_col=1, max_col=len(headers)):
-                    cell.font = Font(bold=True, size=20)
-                    cell.fill = PatternFill(fgColor="FFC000", patternType="solid")
-                for cell in sheet["2"]:
-                    cell.font = Font(bold=True, size=14)
+            self._style_sheet_header(sheet, headers)
 
     def _write_metadata_sheet(self, workbook: Workbook, metadata: dict[str, Any], sheet_prefix: str = "") -> None:
         # Excel does not support timezone in datetime strings
@@ -362,57 +549,3 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
                     max(current, max_length + 0.5), MAX_COLUMN_WIDTH
                 )
         return None
-
-
-class _MetadataCreator:
-    creator_name = "<YOUR NAME>"
-
-    def __init__(
-        self,
-        action: Literal["create", "update"],
-        new_model_id: tuple[str, str] | None = None,
-    ):
-        self.action = action
-        self.new_model_id = new_model_id or ("YOUR_SPACE", "YOUR_EXTERNAL_ID")
-
-    def create(self, metadata: InformationMetadata | DMSMetadata) -> dict[str, Any]:
-        now = datetime.now(timezone.utc).replace(microsecond=0, tzinfo=None)
-        if self.action == "update":
-            output = json.loads(metadata.model_dump_json(by_alias=True))
-            # This is the same for Information and DMS
-            output["updated"] = now.isoformat()
-            output["schema"] = SchemaCompleteness.extended.value
-            output["extension"] = ExtensionCategory.addition.value
-            if value := output.get("creator"):
-                output["creator"] = f"{value}, {self.creator_name}"
-            else:
-                output["creator"] = self.creator_name
-            return output
-
-        new_metadata = self._create_new_info(now)
-        if isinstance(metadata, DMSMetadata):
-            from cognite.neat._rules.transformers._converters import _InformationRulesConverter
-
-            output_metadata: DMSMetadata | InformationMetadata = _InformationRulesConverter._convert_metadata_to_dms(
-                new_metadata
-            )
-        elif isinstance(metadata, InformationMetadata):
-            output_metadata = new_metadata
-        else:
-            raise ValueError(f"Bug in Neat: Unknown metadata type: {type(metadata)}")
-
-        created = json.loads(output_metadata.model_dump_json(by_alias=True))
-        created.pop("extension", None)
-        return created
-
-    def _create_new_info(self, now: datetime) -> InformationMetadata:
-        return InformationMetadata(
-            space=self.new_model_id[0],
-            external_id=self.new_model_id[1],
-            description=None,
-            version="1",
-            created=now,
-            updated=now,
-            creator=[self.creator_name],
-            name=self.new_model_id[1],
-        )

cognite/neat/_rules/importers/_yaml2rules.py

@@ -8,6 +8,7 @@ from cognite.neat._issues.errors import (
     FileMissingRequiredFieldError,
     FileNotAFileError,
     FileNotFoundNeatError,
+    FileReadError,
     FileTypeUnexpectedError,
 )
 from cognite.neat._issues.warnings import NeatValueWarning
@@ -55,7 +56,12 @@ class YAMLImporter(BaseImporter[T_InputRules]):
             return cls({}, [FileNotAFileError(filepath)])
         elif filepath.suffix not in [".yaml", ".yml"]:
             return cls({}, [FileTypeUnexpectedError(filepath, frozenset([".yaml", ".yml"]))])
-        return cls(yaml.safe_load(filepath.read_text()), filepaths=[filepath], source_name=source_name)
+        try:
+            data = yaml.safe_load(filepath.read_text())
+        except yaml.YAMLError as exc:
+            return cls({}, [FileReadError(filepath, f"Invalid YAML: {exc!s}")])
+
+        return cls(data, filepaths=[filepath], source_name=source_name)
 
     def to_rules(self) -> ReadRules[T_InputRules]:
         if self._read_issues.has_errors or not self.raw_data:

cognite/neat/_rules/models/_base_rules.py

@@ -233,6 +233,21 @@ class BaseMetadata(SchemaModel):
     def as_identifier(self) -> str:
         return repr(self.as_data_model_id())
 
+    @classmethod
+    def default(cls) -> "BaseMetadata":
+        """Returns a default instance of the metadata model."""
+        now = datetime.now()
+        return cls(
+            space="pleaseUpdateMe",
+            external_id="PleaseUpdateMe",
+            version="v1",
+            name="Please Update Me",
+            description="Please Update Me",
+            creator=["NEAT"],
+            created=now,
+            updated=now,
+        )
+
 
 class BaseRules(SchemaModel, ABC):
     """
@@ -263,7 +278,7 @@ class BaseRules(SchemaModel, ABC):
                 annotation = annotation.__args__[0]
 
             try:
-                if isinstance(annotation, types.GenericAlias) and get_origin(annotation) is SheetList:
+                if isinstance(annotation, types.GenericAlias) and get_origin(annotation).__name__ == SheetList.__name__:
                     # We know that this is a SheetList, so we can safely access the annotation
                     # which is the concrete type of the SheetEntity.
                     model_fields = get_args(annotation)[0].model_fields  # type: ignore[union-attr]

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

@@ -127,7 +127,7 @@ class DMSValidation:
             }
 
             if missing_views or missing_containers:
-                raise CDFMissingResourcesError(resources=f"{missing_views.union(missing_containers)}")
+                raise CDFMissingResourcesError(containers=tuple(missing_containers), views=tuple(missing_views))
 
         # Setup data structures for validation
         dms_schema = self._rules.as_schema()
@@ -577,7 +577,16 @@ class DMSValidation:
             if not (
                 isinstance(target_property, dm.MappedPropertyApply | dm.MappedProperty)
                 # The direct relation is pointing to the view_id or one of its parents
-                and (target_property.source == view_id or target_property.source in parents_by_view[view_id])
+                and (
+                    (target_property.source == view_id or target_property.source in parents_by_view[view_id])
+                    # This is a hack that users use to create a multi value direct relations. It works by setting
+                    # the source of a direct relation to None. Then, you can have multiple reverse direct relations
+                    # through this property. In Search this will give you a multi value direct relation.
+                    # Thus, we must allow it here. Note that the missing source in the direct relation will give the
+                    # user a DirectRelationMissingSourceWarning so they know they are doing a not
+                    # recommended modeling pattern.
+                    or target_property.source is None
+                )
             ):
                 issue_list.append(
                     ReversedConnectionNotFeasibleError(

cognite/neat/_rules/transformers/_converters.py

@@ -19,8 +19,7 @@ from rdflib import Namespace
 from cognite.neat._client import NeatClient
 from cognite.neat._client.data_classes.data_modeling import ContainerApplyDict, ViewApplyDict
 from cognite.neat._constants import (
-    COGNITE_CORE_CONCEPTS,
-    COGNITE_CORE_FEATURES,
+    COGNITE_CONCEPTS,
     COGNITE_MODELS,
     COGNITE_SPACES,
     DMS_CONTAINER_PROPERTY_SIZE_LIMIT,
@@ -2011,9 +2010,7 @@ class _SubsetEditableCDMRules(VerifiedRulesTransformer[DMSRules, DMSRules]):
     """
 
     def __init__(self, views: set[ViewEntity]):
-        if not_in_cognite_core := {view.external_id for view in views} - COGNITE_CORE_CONCEPTS.union(
-            COGNITE_CORE_FEATURES
-        ):
+        if not_in_cognite_core := {view.external_id for view in views} - set(COGNITE_CONCEPTS):
             raise NeatValueError(
                 f"Concept(s) {', '.join(not_in_cognite_core)} is/are not part of the Cognite Core Data Model. Aborting."
             )
@@ -2220,11 +2217,13 @@ class AddCogniteProperties(RulesTransformer[ReadRules[InformationInputRules], Re
 
     Args:
         client: The client is used to look up the properties of the parent classes.
+        dummy_property: A dummy property is added to the user defined concepts
 
     """
 
-    def __init__(self, client: NeatClient) -> None:
+    def __init__(self, client: NeatClient, dummy_property: str | None = None) -> None:
         self._client = client
+        self._dummy_property = dummy_property
 
     @property
     def description(self) -> str:
@@ -2268,6 +2267,17 @@ class AddCogniteProperties(RulesTransformer[ReadRules[InformationInputRules], Re
                         new_properties.append(new_prop)
                         properties_by_class[class_entity][prop.property_] = new_prop
 
+            if self._dummy_property:
+                new_properties.append(
+                    InformationInputProperty(
+                        class_=class_entity,
+                        property_=f"{to_camel_case(class_entity.suffix)}{self._dummy_property}",
+                        value_type=String(),
+                        min_count=0,
+                        max_count=1,
+                    )
+                )
+
         new_classes: list[InformationInputClass] = input_.classes.copy()
         existing_classes = {cls.class_ for cls in input_.classes}
         for class_entity, view in views_by_class_entity.items():

cognite/neat/_session/_drop.py

@@ -45,14 +45,14 @@ class DropAPI:
         # Temporary solution until we agree on the form of specifying named graphs
         # it will default to the default named graph
         named_graph = self._state.instances.store.default_named_graph
-        uri_type_type = dict((v, k) for k, v in self._state.instances.store.queries.types(named_graph).items())
+        uri_type_type = dict((v, k) for k, v in self._state.instances.store.queries.select.types(named_graph).items())
         selected_uri_by_type: dict[URIRef, str] = {}
         for type_item in type_list:
             if type_item not in uri_type_type:
                 print(f"Type {type_item} not found.")
             selected_uri_by_type[uri_type_type[type_item]] = type_item
 
-        result = self._state.instances.store.queries.drop_types(list(selected_uri_by_type.keys()))
+        result = self._state.instances.store.queries.update.drop_types(list(selected_uri_by_type.keys()))
 
         for type_uri, count in result.items():
             print(f"Dropped {count} instances of type {selected_uri_by_type[type_uri]}")

cognite/neat/_session/_explore.py

@@ -21,19 +21,19 @@ class ExploreAPI:
 
     def types(self) -> pd.DataFrame:
         """List all the types of instances in the session."""
-        return pd.DataFrame(self._state.instances.store.queries.types_with_instance_and_property_count())
+        return pd.DataFrame(self._state.instances.store.queries.select.types_with_instance_and_property_count())
 
     def properties(self) -> pd.DataFrame:
         """List all the properties of a type of instances in the session."""
-        return pd.DataFrame(self._state.instances.store.queries.properties_with_count())
+        return pd.DataFrame(self._state.instances.store.queries.select.properties_with_count())
 
     def instance_with_properties(self, type: str) -> dict[str, set[str]]:
         """List all the instances of a type with their properties."""
-        available_types = self._state.instances.store.queries.list_types(remove_namespace=False)
+        available_types = self._state.instances.store.queries.select.list_types(remove_namespace=False)
         uri_by_type = {remove_namespace_from_uri(t[0]): t[0] for t in available_types}
         if type not in uri_by_type:
             raise NeatSessionError(
                 f"Type {type} not found. Available types are: {humanize_collection(uri_by_type.keys())}"
             )
         type_uri = cast(URIRef, uri_by_type[type])
-        return self._state.instances.store.queries.instances_with_properties(type_uri, remove_namespace=True)
+        return self._state.instances.store.queries.select.instances_with_properties(type_uri, remove_namespace=True)

cognite/neat/_session/_prepare.py

@@ -117,8 +117,8 @@ class InstancePrepareAPI:
         self._state.instances.store.transform(transformer)
 
     def _get_type_and_property_uris(self, type_: str, property_: str) -> tuple[URIRef, URIRef]:
-        type_uri = self._state.instances.store.queries.type_uri(type_)
-        property_uri = self._state.instances.store.queries.property_uri(property_)
+        type_uri = self._state.instances.store.queries.select.type_uri(type_)
+        property_uri = self._state.instances.store.queries.select.property_uri(property_)
 
         if not type_uri:
             raise NeatValueError(f"Type {type_} does not exist in the graph.")
@@ -132,7 +132,7 @@ class InstancePrepareAPI:
                 f"{property_} has multiple ids found in the graph: {humanize_collection(property_uri)}."
             )
 
-        if not self._state.instances.store.queries.type_with_property(type_uri[0], property_uri[0]):
+        if not self._state.instances.store.queries.select.type_with_property(type_uri[0], property_uri[0]):
             raise NeatValueError(f"Property {property_} is not defined for type {type_}.")
         return type_uri[0], property_uri[0]
 
@@ -210,7 +210,7 @@ class InstancePrepareAPI:
             except NeatValueError as e:
                 raise NeatSessionError(f"Cannot convert to type: {e}") from None
         else:
-            subject_predicate = self._state.instances.store.queries.property_uri(source[1])[0]
+            subject_predicate = self._state.instances.store.queries.select.property_uri(source[1])[0]
 
         transformer = LiteralToEntity(subject_type, subject_predicate, type, new_property)
         self._state.instances.store.transform(transformer)
@@ -241,7 +241,7 @@ class InstancePrepareAPI:
             except NeatValueError as e:
                 raise NeatSessionError(f"Cannot convert to data type: {e}") from None
         else:
-            subject_predicate = self._state.instances.store.queries.property_uri(source[1])[0]
+            subject_predicate = self._state.instances.store.queries.select.property_uri(source[1])[0]
         transformer = ConnectionToLiteral(subject_type, subject_predicate)
         self._state.instances.store.transform(transformer)