cognite-neat 0.109.0__tar.gz → 0.109.2__tar.gz

{cognite_neat-0.109.0 → cognite_neat-0.109.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cognite-neat
-Version: 0.109.0
+Version: 0.109.2
 Summary: Knowledge graph transformation
 License: Apache-2.0
 Author: Nikola Vasiljevic

cognite_neat-0.109.2/cognite/neat/_alpha.py

@@ -0,0 +1,14 @@
+import warnings
+
+
+class AlphaWarning(UserWarning):
+    def __init__(self, feature_name: str):
+        super().__init__(f"Alpha feature '{feature_name}' is subject to change without notice")
+
+    def warn(self) -> None:
+        warnings.warn(self, stacklevel=2)
+
+
+class AlphaFlags:
+    manual_rules_edit = AlphaWarning("enable_manual_edit")
+    same_space_properties_only_export = AlphaWarning("same-space-properties-only")

{cognite_neat-0.109.0 → cognite_neat-0.109.2}/cognite/neat/_rules/exporters/_rules2excel.py

@@ -22,6 +22,7 @@ from cognite.neat._rules.models import (
 from cognite.neat._rules.models.dms import DMSMetadata
 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
 
 from ._base import BaseExporter
 
@@ -63,12 +64,22 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
     style_options = get_args(Style)
     dump_options = get_args(DumpOptions)
 
+    _internal_columns: ClassVar[list[str]] = [
+        "physical",
+        "logical",
+        "conceptual",
+        "Neat ID",
+    ]
+
     def __init__(
         self,
         styling: Style = "default",
         new_model_id: tuple[str, str] | None = None,
         sheet_prefix: str | None = None,
         reference_rules_with_prefix: tuple[VerifiedRules, str] | None = None,
+        add_empty_rows: bool = False,
+        hide_internal_columns: bool = True,
+        include_properties: Literal["same-space", "all"] = "all",
     ):
         self.sheet_prefix = sheet_prefix or ""
         if styling not in self.style_options:
@@ -77,6 +88,9 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         self._styling_level = self.style_options.index(styling)
         self.new_model_id = new_model_id
         self.reference_rules_with_prefix = reference_rules_with_prefix
+        self.add_empty_rows = add_empty_rows
+        self.hide_internal_columns = hide_internal_columns
+        self.include_properties = include_properties
 
     @property
     def description(self) -> str:
@@ -112,6 +126,16 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         if self._styling_level > 0:
             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 self._internal_columns:
+                    column_letter = find_column_with_value(ws, col)
+                    if column_letter:
+                        ws.column_dimensions[column_letter].hidden = True
+
         return workbook
 
     def _write_sheets(
@@ -149,13 +173,19 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
                 is_properties = sheet_name == "Properties"
                 is_new_class = class_ != last_class and last_class is not None
                 if self._styling_level > 2 and is_new_class and is_properties:
-                    sheet.append([""] * len(headers))
+                    if self.add_empty_rows:
+                        sheet.append([""] * len(headers))
                     for cell in sheet[sheet.max_row]:
                         cell.fill = PatternFill(fgColor=fill_color, patternType="solid")
                         side = Side(style="thin", color="000000")
                         cell.border = Border(left=side, right=side, top=side, bottom=side)
                     fill_color = next(fill_colors)
 
+                if is_properties and self.include_properties == "same-space":
+                    space = class_.split(":")[0] if ":" in class_ else rules.metadata.space
+                    if space != rules.metadata.space:
+                        continue
+
                 sheet.append(row)
                 if self._styling_level > 2 and is_properties:
                     for cell in sheet[sheet.max_row]:

{cognite_neat-0.109.0 → cognite_neat-0.109.2}/cognite/neat/_rules/models/entities/_wrapped.py

@@ -201,3 +201,6 @@ class RawFilter(DMSFilter):
 
     def __repr__(self) -> str:
         return self.filter
+
+    def __str__(self):
+        return f"{self.name}({self.filter})"

{cognite_neat-0.109.0 → cognite_neat-0.109.2}/cognite/neat/_session/_collector.py

@@ -65,7 +65,10 @@ class Collector:
         if kwargs:
             for key, value in kwargs.items():
                 event_information[key] = self._serialize_value(value)[:500]
-        self._track(command, event_information)
+
+        with suppress(RuntimeError):
+            # In case any thread issues, the tracking should not crash the program
+            self._track(command, event_information)
 
     @staticmethod
     def _serialize_value(value: Any) -> str:

{cognite_neat-0.109.0 → cognite_neat-0.109.2}/cognite/neat/_session/_inspect.py

@@ -110,7 +110,7 @@ class InspectIssues:
         if issues is None and self._state.instances.store.provenance:
             last_change = self._state.instances.store.provenance[-1]
             issues = last_change.target_entity.issues
-        else:
+        elif issues is None:
             self._print("No issues found.")
             return pd.DataFrame() if return_dataframe else None
 

{cognite_neat-0.109.0 → cognite_neat-0.109.2}/cognite/neat/_session/_read.py

@@ -1,8 +1,10 @@
+import warnings
 from typing import Any, Literal, cast
 
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
 from cognite.client.utils.useful_types import SequenceNotStr
 
+from cognite.neat._alpha import AlphaFlags
 from cognite.neat._client import NeatClient
 from cognite.neat._constants import (
     CLASSIC_CDF_NAMESPACE,
@@ -286,16 +288,26 @@ class ExcelReadAPI(BaseReadAPI):
         super().__init__(state, verbose)
         self.examples = ExcelExampleAPI(state, verbose)
 
-    def __call__(self, io: Any) -> IssueList:
+    def __call__(self, io: Any, enable_manual_edit: bool = False) -> IssueList:
         """Reads a Neat Excel Rules sheet to the graph store. The rules sheet may stem from an Information architect,
         or a DMS Architect.
 
         Args:
             io: file path to the Excel sheet
+            enable_manual_edit: If True, the user will be able to re-import rules which where edit outside NeatSession
+
+        !!! note "Manual Edit Warning"
+            This is an alpha feature and is subject to change without notice.
+            It is expected to have some limitations and may not work as expected in all cases.
         """
         reader = NeatReader.create(io)
         path = reader.materialize_path()
-        return self._state.rule_import(importers.ExcelImporter(path))
+
+        if enable_manual_edit:
+            warnings.filterwarnings("default")
+            AlphaFlags.manual_rules_edit.warn()
+
+        return self._state.rule_import(importers.ExcelImporter(path), enable_manual_edit)
 
 
 @session_class_wrapper

{cognite_neat-0.109.0 → cognite_neat-0.109.2}/cognite/neat/_session/_state.py

@@ -40,8 +40,12 @@ class SessionState:
         self.instances.store.add_rules(last_entity.information)
         return issues
 
-    def rule_import(self, importer: BaseImporter) -> IssueList:
-        issues = self.rule_store.import_rules(importer, client=self.client)
+    def rule_import(self, importer: BaseImporter, enable_manual_edit: bool = False) -> IssueList:
+        issues = self.rule_store.import_rules(
+            importer,
+            client=self.client,
+            enable_manual_edit=enable_manual_edit,
+        )
         if self.rule_store.empty:
             result = "failed"
         else:

{cognite_neat-0.109.0 → cognite_neat-0.109.2}/cognite/neat/_session/_to.py

@@ -6,6 +6,7 @@ from typing import Any, Literal, overload
 
 from cognite.client import data_modeling as dm
 
+from cognite.neat._alpha import AlphaFlags
 from cognite.neat._constants import COGNITE_MODELS
 from cognite.neat._graph import loaders
 from cognite.neat._rules import exporters
@@ -35,6 +36,8 @@ class ToAPI:
         self,
         io: Any,
         include_reference: bool = True,
+        include_properties: Literal["same-space", "all"] = "all",
+        add_empty_rows: bool = False,
     ) -> None:
         """Export the verified data model to Excel.
 
@@ -42,7 +45,10 @@ class ToAPI:
             io: The file path or file-like object to write the Excel file to.
             include_reference: If True, the reference data model will be included. Defaults to True.
                 Note that this only applies if you have created the data model using the
-                .to_enterprise(), .to_solution(), or .to_data_product() methods.
+                create.enterprise_model(...), create.solution_model(), or create.data_product_model() methods.
+        include_properties: The properties to include in the Excel file. Defaults to "all".
+            - "same-space": Only properties that are in the same space as the data model will be included.
+        add_empty_rows: If True, empty rows will be added between each component. Defaults to False.
 
         Example:
             Export information model to excel rules sheet
@@ -58,17 +64,17 @@ class ToAPI:
             neat = NeatSession(client)
 
             neat.read.cdf(("cdf_cdm", "CogniteCore", "v1"))
-            neat.verify()
-            neat.prepare.data_model.to_enterprise(
+            neat.create.enterprise_model(
                 data_model_id=("sp_doctrino_space", "ExtensionCore", "v1"),
                 org_name="MyOrg",
-                move_connections=True
             )
             dms_rules_file_name = "dms_rules.xlsx"
             neat.to.excel(dms_rules_file_name, include_reference=True)
             ```
         """
         reference_rules_with_prefix: tuple[VerifiedRules, str] | None = None
+        include_properties = include_properties.strip().lower()
+
         if include_reference and self._state.last_reference:
             if (
                 isinstance(self._state.last_reference.metadata, DMSMetadata)
@@ -79,7 +85,16 @@ class ToAPI:
                 prefix = "Ref"
             reference_rules_with_prefix = self._state.last_reference, prefix
 
-        exporter = exporters.ExcelExporter(styling="maximal", reference_rules_with_prefix=reference_rules_with_prefix)
+        if include_properties == "same-space":
+            warnings.filterwarnings("default")
+            AlphaFlags.same_space_properties_only_export.warn()
+
+        exporter = exporters.ExcelExporter(
+            styling="maximal",
+            reference_rules_with_prefix=reference_rules_with_prefix,
+            add_empty_rows=add_empty_rows,
+            include_properties=include_properties,  # type: ignore
+        )
         return self._state.rule_store.export_to_file(exporter, Path(io))
 
     def session(self, io: Any) -> None:

{cognite_neat-0.109.0 → cognite_neat-0.109.2}/cognite/neat/_session/exceptions.py

@@ -1,7 +1,9 @@
 import functools
+import warnings
 from collections.abc import Callable
 from typing import Any
 
+from cognite.neat._alpha import AlphaWarning
 from cognite.neat._issues.errors import CDFMissingClientError, NeatImportError
 from cognite.neat._issues.errors._external import OxigraphStorageLockedError
 from cognite.neat._issues.errors._general import NeatValueError
@@ -12,9 +14,11 @@ try:
     from rich import print
     from rich.markup import escape
 
-    _PREFIX = "[bold red][ERROR][/bold red]"
+    _ERROR_PREFIX = "[bold red][ERROR][/bold red]"
+    _WARNING_PREFIX = "[bold bright_magenta][WARNING][/bold bright_magenta]"
 except ImportError:
-    _PREFIX = "[ERROR]"
+    _ERROR_PREFIX = "[ERROR]"
+    _WARNING_PREFIX = "[WARNING]"
 
     def escape(x: Any, *_: Any, **__: Any) -> Any:  # type: ignore[misc]
         return x
@@ -31,21 +35,27 @@ def _session_method_wrapper(func: Callable, cls_name: str):
     def wrapper(*args: Any, **kwargs: Any):
         _COLLECTOR.track_session_command(f"{cls_name}.{func.__name__}", *args, **kwargs)
         try:
-            return func(*args, **kwargs)
+            with warnings.catch_warnings(record=True) as w:
+                result = func(*args, **kwargs)
+                for warning in w:
+                    if isinstance(warning.message, AlphaWarning):
+                        print(f"{_WARNING_PREFIX} {warning.message}")
+
+            return result
         except NeatSessionError as e:
             action = _get_action()
-            print(f"{_PREFIX} Cannot {action}: {e}")
+            print(f"{_ERROR_PREFIX} Cannot {action}: {e}")
         except (
             CDFMissingClientError,
             NeatImportError,
             NeatValueError,
             OxigraphStorageLockedError,
         ) as e:
-            print(f"{_PREFIX} {escape(e.as_message())}")
+            print(f"{_ERROR_PREFIX} {escape(e.as_message())}")
         except ModuleNotFoundError as e:
             if e.name == "neatengine":
                 action = _get_action()
-                print(f"{_PREFIX} The functionality {action} requires the NeatEngine.")
+                print(f"{_ERROR_PREFIX} The functionality {action} requires the NeatEngine.")
             else:
                 raise e
 

{cognite_neat-0.109.0 → cognite_neat-0.109.2}/cognite/neat/_store/_provenance.py

@@ -44,6 +44,7 @@ class Agent:
 CDF_AGENT = Agent(acted_on_behalf_of="UNKNOWN", id_=CDF_NAMESPACE["agent"])
 NEAT_AGENT = Agent(acted_on_behalf_of="UNKNOWN", id_=DEFAULT_NAMESPACE["agent"])
 UNKNOWN_AGENT = Agent(acted_on_behalf_of="UNKNOWN", id_=DEFAULT_NAMESPACE["unknown-agent"])
+EXTERNAL_AGENT = Agent(acted_on_behalf_of="HUMAN", id_=DEFAULT_NAMESPACE["external-agent"])
 
 
 @dataclass(frozen=True)