cognite-neat 0.109.1__tar.gz → 0.109.3__tar.gz

{cognite_neat-0.109.1 → cognite_neat-0.109.3}/PKG-INFO

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

cognite_neat-0.109.3/cognite/neat/_alpha.py

@@ -0,0 +1,15 @@
+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")
+    standardize_naming = AlphaWarning("standardize_naming")

{cognite_neat-0.109.1 → cognite_neat-0.109.3}/cognite/neat/_client/testing.py

@@ -19,7 +19,7 @@ class NeatClientMock(CogniteClientMock):
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         if "parent" in kwargs:
             super().__init__(*args, **kwargs)
-            return None
+            return
         super().__init__(*args, **kwargs)
         self.schema = SchemaAPI(self)
         self.loaders = DataModelLoaderAPI(self)

{cognite_neat-0.109.1 → cognite_neat-0.109.3}/cognite/neat/_issues/_base.py

@@ -103,6 +103,8 @@ class NeatIssue:
                 variables[name] = var_.as_posix()
             elif isinstance(var_, Collection):
                 variables[name] = humanize_collection(var_)
+            elif isinstance(var_, NeatError):
+                variables[name] = var_.as_message(include_type=False)
             else:
                 variables[name] = repr(var_)
         return variables, has_all_optional
@@ -138,6 +140,8 @@ class NeatIssue:
             return value.dump(camel_case=True)
         elif isinstance(value, DataModelId):
             return value.dump(camel_case=True, include_type=False)
+        elif isinstance(value, NeatError):
+            return value.dump()
         raise ValueError(f"Unsupported type: {type(value)}")
 
     @classmethod
@@ -192,6 +196,8 @@ class NeatIssue:
             return ContainerId.load(value)
         elif inspect.isclass(type_) and issubclass(type_, Entity):
             return type_.load(value)
+        elif type_ is NeatError:
+            return cls.load(value)
         return value
 
     def __lt__(self, other: "NeatIssue") -> bool:
@@ -227,22 +233,19 @@ class NeatError(NeatIssue, Exception):
                 # Skip the error for SheetList, as it is not relevant for the user. This is an
                 # internal class used to have helper methods for a lists as .to_pandas()
                 continue
+
             neat_error: NeatError | None = None
             if isinstance(error, dict) and isinstance(ctx := error.get("ctx"), dict) and "error" in ctx:
                 neat_error = ctx["error"]
             elif isinstance(error, NeatError | MultiValueError):
                 neat_error = error
 
+            loc = error["loc"] if isinstance(error, dict) else tuple()
             if isinstance(neat_error, MultiValueError):
-                if read_info_by_sheet:
-                    for caught_error in neat_error.errors:
-                        cls._adjust_row_numbers(caught_error, read_info_by_sheet)  # type: ignore[arg-type]
-                all_errors.extend(neat_error.errors)  # type: ignore[arg-type]
+                all_errors.extend([cls._adjust_error(e, loc, read_info_by_sheet) for e in neat_error.errors])
             elif isinstance(neat_error, NeatError):
-                if read_info_by_sheet:
-                    cls._adjust_row_numbers(neat_error, read_info_by_sheet)
-                all_errors.append(neat_error)
-            elif isinstance(error, dict) and len(error["loc"]) >= 4 and read_info_by_sheet:
+                all_errors.append(cls._adjust_error(neat_error, loc, read_info_by_sheet))
+            elif isinstance(error, dict) and len(loc) >= 4 and read_info_by_sheet:
                 all_errors.append(RowError.from_pydantic_error(error, read_info_by_sheet))
             elif isinstance(error, dict):
                 all_errors.append(DefaultPydanticError.from_pydantic_error(error))
@@ -251,6 +254,18 @@ class NeatError(NeatIssue, Exception):
                 raise ValueError(f"Unsupported error type: {error}")
         return all_errors
 
+    @classmethod
+    def _adjust_error(
+        cls, error: "NeatError", loc: tuple[str | int, ...], read_info_by_sheet: dict[str, SpreadsheetRead] | None
+    ) -> "NeatError":
+        from .errors._wrapper import MetadataValueError
+
+        if read_info_by_sheet:
+            cls._adjust_row_numbers(error, read_info_by_sheet)
+        if len(loc) == 2 and isinstance(loc[0], str) and loc[0].casefold() == "metadata":
+            return MetadataValueError(field_name=str(loc[1]), error=error)
+        return error
+
     @staticmethod
     def _adjust_row_numbers(caught_error: "NeatError", read_info_by_sheet: dict[str, SpreadsheetRead]) -> None:
         from cognite.neat._issues.errors._properties import PropertyDefinitionDuplicatedError
@@ -288,7 +303,16 @@ class DefaultPydanticError(NeatError, ValueError):
     msg: str
 
     @classmethod
-    def from_pydantic_error(cls, error: ErrorDetails) -> "DefaultPydanticError":
+    def from_pydantic_error(cls, error: ErrorDetails) -> "NeatError":
+        loc = error["loc"]
+        if len(loc) >= 2 and isinstance(loc[0], str) and loc[0].casefold() == "metadata":
+            from .errors._general import NeatValueError
+            from .errors._wrapper import MetadataValueError
+
+            return MetadataValueError(
+                field_name=str(loc[1]), error=NeatValueError(f"{error['msg']} got '{error['input']}'")
+            )
+
         return cls(
             type=error["type"],
             loc=error["loc"],

{cognite_neat-0.109.1 → cognite_neat-0.109.3}/cognite/neat/_issues/errors/__init__.py

@@ -31,12 +31,7 @@ from ._resources import (
     ResourceNotFoundError,
     ResourceRetrievalError,
 )
-from ._workflow import (
-    WorkflowConfigurationNotSetError,
-    WorkFlowMissingDataError,
-    WorkflowStepNotInitializedError,
-    WorkflowStepOutputError,
-)
+from ._wrapper import MetadataValueError
 
 __all__ = [
     "AuthorizationError",
@@ -47,6 +42,7 @@ __all__ = [
     "FileNotFoundNeatError",
     "FileReadError",
     "FileTypeUnexpectedError",
+    "MetadataValueError",
     "NeatError",
     "NeatImportError",
     "NeatTypeError",
@@ -70,10 +66,6 @@ __all__ = [
     "ResourceRetrievalError",
     "ReversedConnectionNotFeasibleError",
     "RowError",
-    "WorkFlowMissingDataError",
-    "WorkflowConfigurationNotSetError",
-    "WorkflowStepNotInitializedError",
-    "WorkflowStepOutputError",
 ]
 
 _NEAT_ERRORS_BY_NAME = {error.__name__: error for error in _get_subclasses(NeatError, include_base=True)}

{cognite_neat-0.109.1 → cognite_neat-0.109.3}/cognite/neat/_issues/errors/_general.py

@@ -19,7 +19,7 @@ class NeatTypeError(NeatError, TypeError):
 
 @dataclass(unsafe_hash=True)
 class RegexViolationError(NeatError, ValueError):
-    """Value, {value} in {location} failed regex, {regex}, validation.
+    """The value '{value}' failed regex, {regex}, validation in {location}.
     Make sure that the name follows the regex pattern."""
 
     value: str

cognite_neat-0.109.3/cognite/neat/_issues/errors/_wrapper.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+from cognite.neat._issues import NeatError
+
+
+@dataclass(unsafe_hash=True)
+class MetadataValueError(NeatError, ValueError):
+    """Field {field_name} - {error}"""
+
+    field_name: str
+    error: NeatError

{cognite_neat-0.109.1 → cognite_neat-0.109.3}/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.1 → cognite_neat-0.109.3}/cognite/neat/_rules/models/_rdfpath.py

@@ -2,6 +2,7 @@
 
 import re
 import sys
+import urllib.parse
 from collections import Counter
 from functools import total_ordering
 from typing import ClassVar, Literal
@@ -327,6 +328,7 @@ def parse_table_lookup(raw: str) -> TableLookup:
 
 
 def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPath:
+    rule_raw = urllib.parse.unquote(rule_raw)
     match rule_type:
         case TransformationRuleType.rdfpath:
             rule_raw = rule_raw.replace(" ", "")

{cognite_neat-0.109.1 → cognite_neat-0.109.3}/cognite/neat/_rules/models/_types.py

@@ -38,7 +38,9 @@ def _custom_error(exc_factory: Callable[[str | None, Exception], Any]) -> Any:
     def _validator(value: Any, next_: Any, ctx: ValidationInfo) -> Any:
         try:
             return next_(value, ctx)
-        except Exception:
+        except ValueError as e:
+            if value is None:
+                raise e
             raise exc_factory(ctx.field_name, value) from None
 
     return WrapValidator(_validator)
@@ -130,7 +132,7 @@ def _external_id_validation_factory(entity_type: EntityTypes, location: str):
 
 SpaceType = Annotated[
     str,
-    AfterValidator(_external_id_validation_factory(EntityTypes.space, "space entry in metadata")),
+    AfterValidator(_external_id_validation_factory(EntityTypes.space, "")),
 ]
 
 InformationPropertyType = Annotated[

{cognite_neat-0.109.1 → cognite_neat-0.109.3}/cognite/neat/_rules/models/dms/_rules.py

@@ -1,4 +1,3 @@
-import warnings
 from collections.abc import Hashable
 from typing import TYPE_CHECKING, Any, ClassVar, Literal
 
@@ -8,11 +7,7 @@ from pydantic import Field, field_serializer, field_validator, model_validator
 from pydantic_core.core_schema import SerializationInfo, ValidationInfo
 
 from cognite.neat._client.data_classes.schema import DMSSchema
-from cognite.neat._constants import COGNITE_SPACES
 from cognite.neat._issues.errors import NeatValueError
-from cognite.neat._issues.warnings import (
-    PrincipleMatchingSpaceAndVersionWarning,
-)
 from cognite.neat._rules.models._base_rules import (
     BaseMetadata,
     BaseRules,
@@ -407,37 +402,6 @@ class DMSRules(BaseRules):
         None, alias="Nodes", description="Contains the definition of the node types."
     )
 
-    @field_validator("views")
-    def matching_version_and_space(cls, value: SheetList[DMSView], info: ValidationInfo) -> SheetList[DMSView]:
-        if not (metadata := info.data.get("metadata")):
-            return value
-        model_version = metadata.version
-        if different_version := [
-            view.view.as_id()
-            for view in value
-            if view.view.version != model_version and view.view.space not in COGNITE_SPACES
-        ]:
-            for view_id in different_version:
-                warnings.warn(
-                    PrincipleMatchingSpaceAndVersionWarning(
-                        f"The view {view_id!r} has a different version than the data model version, {model_version}",
-                    ),
-                    stacklevel=2,
-                )
-        if different_space := [
-            view.view.as_id()
-            for view in value
-            if view.view.space != metadata.space and view.view.space not in COGNITE_SPACES
-        ]:
-            for view_id in different_space:
-                warnings.warn(
-                    PrincipleMatchingSpaceAndVersionWarning(
-                        f"The view {view_id!r} is in a different space than the data model space, {metadata.space}",
-                    ),
-                    stacklevel=2,
-                )
-        return value
-
     @model_validator(mode="after")
     def set_neat_id(self) -> "DMSRules":
         namespace = self.metadata.namespace

{cognite_neat-0.109.1 → cognite_neat-0.109.3}/cognite/neat/_rules/models/entities/_constants.py

@@ -8,6 +8,9 @@ class _UnknownType(BaseModel):
     def __str__(self) -> str:
         return "#N/A"
 
+    def __hash__(self):
+        return hash(str(self))
+
 
 # This is a trick to make Undefined and Unknown singletons
 Undefined = _UndefinedType()

{cognite_neat-0.109.1 → cognite_neat-0.109.3}/cognite/neat/_rules/models/entities/_single_value.py

@@ -134,7 +134,12 @@ class Entity(BaseModel, extra="ignore"):
         content = result.group("content")
         if content is None:
             return dict(prefix=prefix, suffix=suffix)
-        extra_args = dict(SPLIT_ON_EQUAL_PATTERN.split(pair.strip()) for pair in SPLIT_ON_COMMA_PATTERN.split(content))
+        try:
+            extra_args = dict(
+                SPLIT_ON_EQUAL_PATTERN.split(pair.strip()) for pair in SPLIT_ON_COMMA_PATTERN.split(content)
+            )
+        except ValueError:
+            raise NeatValueError(f"Invalid {cls.type_.value} entity: {raw!r}") from None
         expected_args = {
             field_.alias or field_name: field_.annotation for field_name, field_ in cls.model_fields.items()
         }

{cognite_neat-0.109.1 → cognite_neat-0.109.3}/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.1 → cognite_neat-0.109.3}/cognite/neat/_rules/transformers/__init__.py

@@ -13,10 +13,12 @@ from ._converters import (
     MergeInformationRules,
     PrefixEntities,
     SetIDDMSModel,
+    StandardizeNaming,
     ToCompliantEntities,
     ToDataProductModel,
     ToEnterpriseModel,
     ToExtensionModel,
+    ToInformationCompliantEntities,
     ToSolutionModel,
 )
 from ._mapping import AsParentPropertyId, MapOneToOne, RuleMapper
@@ -40,10 +42,12 @@ __all__ = [
     "RuleMapper",
     "RulesTransformer",
     "SetIDDMSModel",
+    "StandardizeNaming",
     "ToCompliantEntities",
     "ToDataProductModel",
     "ToEnterpriseModel",
     "ToExtensionModel",
+    "ToInformationCompliantEntities",
     "ToSolutionModel",
     "VerifiedRulesTransformer",
     "VerifyAnyRules",