cognite-neat 0.125.1__tar.gz → 0.126.0__tar.gz

{cognite_neat-0.125.1 → cognite_neat-0.126.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.125.1
+Version: 0.126.0
 Summary: Knowledge graph transformation
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
 Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/

cognite_neat-0.126.0/cognite/neat/_data_model/exporters/_base.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from cognite.neat._data_model.models.dms import RequestSchema
+
+T_Export = TypeVar("T_Export")
+
+
+class DMSExporter(ABC, Generic[T_Export]):
+    """This is the base class for all DMS exporters."""
+
+    NEW_LINE = "\n"
+    ENCODING = "utf-8"
+
+    @abstractmethod
+    def export(self, data_model: RequestSchema) -> T_Export:
+        raise NotImplementedError()

cognite_neat-0.126.0/cognite/neat/_data_model/exporters/_table_exporter.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+from cognite.neat._data_model.models.dms import RequestSchema
+from cognite.neat._utils.useful_types import DataModelTableType
+
+from ._base import DMSExporter
+
+
+class DMSTableExporter(DMSExporter[DataModelTableType]):
+    """Exports DMS to a table structure.
+
+    The tables are expected to be a dictionary where the keys are the table names and the values
+    are lists of dictionaries representing the rows in the table.
+    """
+
+    def export(self, data_model: RequestSchema) -> DataModelTableType:
+        raise NotImplementedError()
+
+    def as_excel(self, data_model: RequestSchema, file_path: Path) -> None:
+        """Exports the data model as an Excel file.
+
+        Args:
+            data_model (RequestSchema): The data model to export.
+            file_path (Path): The path to the Excel file to create.
+        """
+        raise NotImplementedError()
+
+    def as_yaml(self, data_model: RequestSchema, file_path: Path) -> None:
+        """Exports the data model as a YAML file.
+
+        Args:
+            data_model (RequestSchema): The data model to export.
+            file_path (Path): The path to the YAML file to create.
+        """
+        raise NotImplementedError()

{cognite_neat-0.125.1 → cognite_neat-0.126.0}/cognite/neat/_data_model/importers/_table_importer/importer.py

@@ -9,10 +9,13 @@ from cognite.neat._data_model.models.dms import (
 )
 from cognite.neat._exceptions import DataModelImportError
 from cognite.neat._issues import ModelSyntaxError
-from cognite.neat._utils.useful_types import CellValueType
+from cognite.neat._utils.text import humanize_collection
+from cognite.neat._utils.useful_types import DataModelTableType
 from cognite.neat._utils.validation import as_json_path, humanize_validation_error
 
-from .data_classes import TableDMS
+from .data_classes import MetadataValue, TableDMS
+from .reader import DMSTableReader
+from .source import TableSource
 
 
 class DMSTableImporter(DMSImporter):
@@ -30,11 +33,16 @@ class DMSTableImporter(DMSImporter):
         f"Missing required column: {sheet!r}": f"Missing required sheet: {sheet!r}" for sheet in REQUIRED_SHEETS
     }
 
-    def __init__(self, tables: dict[str, list[dict[str, CellValueType]]]) -> None:
+    def __init__(self, tables: DataModelTableType, source: TableSource | None = None) -> None:
         self._table = tables
+        self._source = source or TableSource("Unknown")
 
     def to_data_model(self) -> RequestSchema:
-        raise NotImplementedError()
+        tables = self._read_tables()
+
+        space, version = self._read_defaults(tables.metadata)
+        reader = DMSTableReader(space, version, self._source)
+        return reader.read_tables(tables)
 
     def _read_tables(self) -> TableDMS:
         try:
@@ -74,3 +82,22 @@ class DMSTableImporter(DMSImporter):
             return f"{loc[0]} sheet row {loc[1] + 1} column {loc[2]!r}"
         # This should be unreachable as the TableDMS model only has 2 levels.
         return as_json_path(loc)
+
+    @staticmethod
+    def _read_defaults(metadata: list[MetadataValue]) -> tuple[str, str]:
+        """Reads the space and version from the metadata table."""
+        default_space: str | None = None
+        default_version: str | None = None
+        missing = {"space", "version"}
+        for meta in metadata:
+            if meta.key == "space":
+                default_space = str(meta.value)
+                missing.remove("space")
+            elif meta.key == "version":
+                default_version = str(meta.value)
+                missing.remove("version")
+        if missing:
+            error = ModelSyntaxError(message=f"In Metadata missing required values: {humanize_collection(missing)}")
+            # If space or version is missing, we cannot continue parsing the model as these are used as defaults.
+            raise DataModelImportError([error]) from None
+        return str(default_space), str(default_version)