cognite-neat 0.92.2__tar.gz → 0.92.3__tar.gz

{cognite_neat-0.92.2 → cognite_neat-0.92.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.92.2
+Version: 0.92.3
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

cognite_neat-0.92.3/cognite/neat/_version.py

@@ -0,0 +1 @@
+__version__ = "0.92.3"

{cognite_neat-0.92.2 → cognite_neat-0.92.3}/cognite/neat/rules/exporters/_rules2excel.py

@@ -11,6 +11,7 @@ from openpyxl import Workbook
 from openpyxl.cell import MergedCell
 from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
 from openpyxl.worksheet.worksheet import Worksheet
+from rdflib import Namespace
 
 from cognite.neat.rules._shared import VerifiedRules
 from cognite.neat.rules.models import (
@@ -22,6 +23,7 @@ from cognite.neat.rules.models import (
 from cognite.neat.rules.models.dms import DMSMetadata
 from cognite.neat.rules.models.domain import DomainMetadata
 from cognite.neat.rules.models.information import InformationMetadata
+from cognite.neat.rules.models.information._rules import InformationRules
 
 from ._base import BaseExporter
 
@@ -133,6 +135,9 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
             self._write_sheets(workbook, dumped_reference_rules, rules, sheet_prefix="Ref")
             self._write_metadata_sheet(workbook, dumped_reference_rules["Metadata"], sheet_prefix="Ref")
 
+        if isinstance(rules, InformationRules) and rules.prefixes:
+            self._write_prefixes_sheet(workbook, rules.prefixes)
+
         if self._styling_level > 0:
             self._adjust_column_widths(workbook)
 
@@ -209,6 +214,16 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
             for cell in metadata_sheet["A"]:
                 cell.font = Font(bold=True, size=12)
 
+    def _write_prefixes_sheet(self, workbook: Workbook, prefixes: dict[str, Namespace]) -> None:
+        metadata_sheet = workbook.create_sheet("Prefixes")
+        metadata_sheet.append(["Prefix", "Namespace"])
+        for key, value in prefixes.items():
+            metadata_sheet.append([key, value])
+
+        if self._styling_level > 1:
+            for cell in metadata_sheet["A"]:
+                cell.font = Font(bold=True, size=12)
+
     @classmethod
     def _get_item_class(cls, annotation: GenericAlias) -> type[SheetRow]:
         if not isinstance(annotation, GenericAlias):

{cognite_neat-0.92.2 → cognite_neat-0.92.3}/cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -11,6 +11,7 @@ from typing import Literal, cast
 import pandas as pd
 from cognite.client.utils._importing import local_import
 from pandas import ExcelFile
+from rdflib import Namespace
 
 from cognite.neat.issues import IssueList
 from cognite.neat.issues.errors import (
@@ -19,6 +20,7 @@ from cognite.neat.issues.errors import (
     FileReadError,
     PropertyDefinitionDuplicatedError,
 )
+from cognite.neat.issues.warnings import FileMissingRequiredFieldWarning
 from cognite.neat.rules._shared import ReadRules, T_InputRules
 from cognite.neat.rules.models import (
     INPUT_RULES_BY_ROLE,
@@ -93,6 +95,7 @@ class ReadResult:
     sheets: dict[str, dict | list]
     read_info_by_sheet: dict[str, SpreadsheetRead]
     metadata: MetadataRaw
+    prefixes: dict[str, Namespace] | None = None
 
     @property
     def role(self) -> RoleTypes:
@@ -122,6 +125,10 @@ class SpreadsheetReader:
     def metadata_sheet_name(self) -> str:
         return f"{self._sheet_prefix}Metadata"
 
+    @property
+    def prefixes_sheet_name(self) -> str:
+        return "Prefixes"
+
     @property
     def seen_sheets(self) -> set[str]:
         if not self._seen_files:
@@ -149,6 +156,14 @@ class SpreadsheetReader:
             return None
         sheets["Metadata"] = dict(metadata)
 
+        # Special case for reading prefixes as they are suppose to be read only once
+        if (
+            self.prefixes_sheet_name in excel_file.sheet_names
+            and not self._sheet_prefix
+            and (prefixes := self._read_prefixes(excel_file, filepath))
+        ):
+            sheets["Prefixes"] = prefixes
+
         return ReadResult(sheets, read_info_by_sheet, metadata)
 
     def _read_metadata(self, excel_file: ExcelFile, filepath: Path) -> MetadataRaw | None:
@@ -163,6 +178,25 @@ class SpreadsheetReader:
             return None
         return metadata
 
+    def _read_prefixes(self, excel_file: ExcelFile, filepath: Path) -> dict[str, Namespace] | None:
+        if self.prefixes_sheet_name not in excel_file.sheet_names:
+            return None
+
+        else:
+            prefixes = {}
+
+            for row in read_individual_sheet(excel_file, "Prefixes", expected_headers=["Prefix", "Namespace"]):
+                if "Prefix" in row and "Namespace" in row:
+                    prefixes[row["Prefix"]] = row["Namespace"]
+                else:
+                    if "Prefix" not in row:
+                        self.issue_list.append(FileMissingRequiredFieldWarning(filepath, "prefixes", "prefix"))
+                    if "Namespace" not in row:
+                        self.issue_list.append(FileMissingRequiredFieldWarning(filepath, "prefixes", "namespace"))
+                    return None
+
+            return prefixes
+
     def _read_sheets(
         self, excel_file: ExcelFile, read_role: RoleTypes
     ) -> tuple[dict[str, dict | list] | None, dict[str, SpreadsheetRead]]:

{cognite_neat-0.92.2 → cognite_neat-0.92.3}/cognite/neat/rules/models/_base_input.py

@@ -66,11 +66,15 @@ class InputRules(Generic[T_BaseRules], ABC):
                 candidate = type_
             elif isinstance(type_, GenericAlias) and type_.__origin__ is list and is_dataclass(type_.__args__[0]):
                 candidate = type_.__args__[0]
+
+            # this handles prefixes
+            elif isinstance(type_, GenericAlias) and type_.__origin__ is dict:
+                candidate = type_
             else:
                 continue
 
-            if hasattr(candidate, "_load"):
-                output[field_.name] = candidate
+            output[field_.name] = candidate
+
         return output
 
     @classmethod
@@ -88,10 +92,16 @@ class InputRules(Generic[T_BaseRules], ABC):
             else:
                 continue
 
-            if isinstance(value, dict):
-                args[field_name] = field_type._load(value)  # type: ignore[attr-defined]
-            elif isinstance(value, list) and value and isinstance(value[0], dict):
-                args[field_name] = [field_type._load(item) for item in value]  # type: ignore[attr-defined]
+            # Handles the case where the field is a dataclass
+            if hasattr(field_type, "_load"):
+                if isinstance(value, dict):
+                    args[field_name] = field_type._load(value)  # type: ignore[attr-defined]
+                elif isinstance(value, list) and value and isinstance(value[0], dict):
+                    args[field_name] = [field_type._load(item) for item in value]  # type: ignore[attr-defined]
+            # Handles the case where the field holds non-dataclass values, e.g. a prefixes dict
+            else:
+                args[field_name] = value
+
         return cls(**args)
 
     def _dataclass_fields(self) -> list[Field]:

{cognite_neat-0.92.2 → cognite_neat-0.92.3}/cognite/neat/rules/models/_base_rules.py

@@ -108,6 +108,14 @@ class SchemaModel(BaseModel):
         """Returns a set of mandatory fields for the model."""
         return _get_required_fields(cls, use_alias)
 
+    @field_validator("*", mode="before")
+    def strip_string(cls, value: Any) -> Any:
+        if isinstance(value, str):
+            return value.strip()
+        elif isinstance(value, list):
+            return [entry.strip() if isinstance(entry, str) else entry for entry in value]
+        return value
+
 
 class BaseMetadata(SchemaModel):
     """
@@ -279,12 +287,6 @@ class BaseRules(SchemaModel, ABC):
 
 
 class SheetRow(SchemaModel):
-    @field_validator("*", mode="before")
-    def strip_string(cls, value: Any) -> Any:
-        if isinstance(value, str):
-            return value.strip()
-        return value
-
     @abstractmethod
     def _identifier(self) -> tuple[Hashable, ...]:
         raise NotImplementedError()

{cognite_neat-0.92.2 → cognite_neat-0.92.3}/cognite/neat/rules/models/dms/_rules.py

@@ -98,15 +98,15 @@ class DMSMetadata(BaseMetadata):
 
     @field_validator("schema_", mode="plain")
     def as_enum_schema(cls, value: str) -> SchemaCompleteness:
-        return SchemaCompleteness(value)
+        return SchemaCompleteness(value.strip())
 
     @field_validator("extension", mode="plain")
     def as_enum_extension(cls, value: str) -> ExtensionCategory:
-        return ExtensionCategory(value)
+        return ExtensionCategory(value.strip())
 
     @field_validator("data_model_type", mode="plain")
     def as_enum_model_type(cls, value: str) -> DataModelType:
-        return DataModelType(value)
+        return DataModelType(value.strip())
 
     @field_validator("description", mode="before")
     def nan_as_none(cls, value):

{cognite_neat-0.92.2 → cognite_neat-0.92.3}/cognite/neat/rules/models/entities/_single_value.py

@@ -17,6 +17,7 @@ from cognite.client.data_classes.data_modeling.ids import (
 from pydantic import (
     BaseModel,
     Field,
+    field_validator,
     model_serializer,
     model_validator,
 )
@@ -97,6 +98,14 @@ class Entity(BaseModel, extra="ignore"):
     def as_str(self) -> str:
         return str(self)
 
+    @field_validator("*", mode="before")
+    def strip_string(cls, value: Any) -> Any:
+        if isinstance(value, str):
+            return value.strip()
+        elif isinstance(value, list):
+            return [entry.strip() if isinstance(entry, str) else entry for entry in value]
+        return value
+
     @classmethod
     def _parse(cls, raw: str, defaults: dict) -> dict:
         if not (result := ENTITY_PATTERN.match(raw)):

{cognite_neat-0.92.2 → cognite_neat-0.92.3}/cognite/neat/rules/models/information/_rules.py

@@ -100,15 +100,15 @@ class InformationMetadata(BaseMetadata):
 
     @field_validator("schema_", mode="plain")
     def as_enum_schema(cls, value: str) -> SchemaCompleteness:
-        return SchemaCompleteness(value)
+        return SchemaCompleteness(value.strip())
 
     @field_validator("extension", mode="plain")
     def as_enum_extension(cls, value: str) -> ExtensionCategory:
-        return ExtensionCategory(value)
+        return ExtensionCategory(value.strip())
 
     @field_validator("data_model_type", mode="plain")
     def as_enum_model_type(cls, value: str) -> DataModelType:
-        return DataModelType(value)
+        return DataModelType(value.strip())
 
     def as_identifier(self) -> str:
         return f"{self.prefix}:{self.name}"

{cognite_neat-0.92.2 → cognite_neat-0.92.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cognite-neat"
-version = "0.92.2"
+version = "0.92.3"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

cognite_neat-0.92.2/cognite/neat/_version.py

@@ -1 +0,0 @@
-__version__ = "0.92.2"