cognite-neat 0.70.1__py3-none-any.whl → 0.127.19__py3-none-any.whl

cognite/neat/v0/core/_issues/errors/_properties.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass
+from typing import Generic
+
+from cognite.neat.v0.core._issues._base import ResourceType
+
+from ._resources import ResourceError, T_Identifier, T_ReferenceIdentifier
+
+
+@dataclass(unsafe_hash=True)
+class PropertyError(ResourceError[T_Identifier]):
+    """Base class for property errors {resource_type} with identifier {identifier}.{property_name}"""
+
+    property_name: str
+
+
+@dataclass(unsafe_hash=True)
+class PropertyNotFoundError(PropertyError, Generic[T_Identifier, T_ReferenceIdentifier]):
+    """The {resource_type} with identifier {identifier} does not have a property {property_name}"""
+
+    extra = "referred to by {referred_type} {referred_by} does not exist"
+    fix = "Ensure the {resource_type} {identifier} has a {property_name} property"
+
+    referred_by: T_ReferenceIdentifier | None = None
+    referred_type: ResourceType | None = None
+
+
+@dataclass(unsafe_hash=True)
+class PropertyTypeNotSupportedError(PropertyError[T_Identifier]):
+    """The {resource_type} with identifier {identifier} has a property {property_name}
+    of unsupported type {property_type}"""
+
+    property_type: str
+
+
+@dataclass(unsafe_hash=True)
+class ReversedConnectionNotFeasibleError(PropertyError[T_Identifier]):
+    """The {resource_type} {identifier}.{property_name} cannot be created: {reason}"""
+
+    reason: str
+
+
+# This is a generic error that should be used sparingly
+@dataclass(unsafe_hash=True)
+class PropertyDefinitionError(PropertyError[T_Identifier]):
+    """Invalid property definition for {resource_type} {identifier}.{property_name}: {reason}"""
+
+    reason: str
+
+
+@dataclass(unsafe_hash=True)
+class PropertyDefinitionDuplicatedError(PropertyError[T_Identifier]):
+    """The {resource_type} with identifier {identifier} has multiple definitions for the property {property_name}
+    with values {property_values}
+    """
+
+    extra = "in locations {locations} with name {location_name}"
+
+    property_values: frozenset[str | int | float | bool | None | tuple[str | int | float | bool | None, ...]]
+    locations: tuple[str | int, ...] | None = None
+    location_name: str | None = None
+
+
+@dataclass(unsafe_hash=True)
+class PropertyInvalidDefinitionError(PropertyError[T_Identifier]):
+    """The {resource_type} with identifier {identifier} has an invalid definition of {property_name}. {reason}"""
+
+    extra = "in locations {locations} with name {location_name}"
+
+    reason: str
+    locations: tuple[str | int, ...] | None = None
+    location_name: str | None = None
+
+
+@dataclass(unsafe_hash=True)
+class PropertyMappingDuplicatedError(PropertyError[T_Identifier], Generic[T_Identifier, T_ReferenceIdentifier]):
+    """The {resource_type} with identifier {identifier}.{property_name} is mapped to by: {mappings}. Ensure
+    that only one {mapping_type} maps to {resource_type} {identifier}.{property_name}"""
+
+    mappings: frozenset[T_ReferenceIdentifier]
+    mapping_type: ResourceType

cognite/neat/v0/core/_issues/errors/_resources.py

@@ -0,0 +1,116 @@
+from dataclasses import dataclass
+from typing import Generic
+
+from cognite.neat.v0.core._issues._base import (
+    NeatError,
+    ResourceType,
+    T_Identifier,
+    T_ReferenceIdentifier,
+)
+from cognite.neat.v0.core._utils.text import humanize_collection
+
+
+@dataclass(unsafe_hash=True)
+class ResourceError(NeatError, Generic[T_Identifier], RuntimeError):
+    """Base class for resource errors {resource_type} with identifier {identifier}"""
+
+    identifier: T_Identifier
+    resource_type: ResourceType
+
+
+@dataclass(unsafe_hash=True)
+class ResourceDuplicatedError(ResourceError[T_Identifier]):
+    """The {resource_type} with identifier {identifier} is duplicated in {location}"""
+
+    fix = "Remove the duplicate {resource_type} {identifier}."
+    location: str
+
+
+@dataclass(unsafe_hash=True)
+class ResourceRetrievalError(ResourceError[T_Identifier]):
+    """Failed to retrieve {resource_type} with identifier {identifier}. The error was: {error}"""
+
+    error: str
+
+
+@dataclass(unsafe_hash=True)
+class ResourceNotFoundError(ResourceError, Generic[T_Identifier, T_ReferenceIdentifier]):
+    """The {resource_type} with identifier '{identifier}' does not exist"""
+
+    extra = " This is expected by {referred_type} {referred_by}."
+
+    fix = "Create the {resource_type} {identifier}"
+
+    referred_by: T_ReferenceIdentifier | None = None
+    referred_type: ResourceType | None = None
+    more: str | None = None
+
+    def as_message(self, include_type: bool = True) -> str:
+        msg = (self.__doc__ or "").format(resource_type=self.resource_type, identifier=self.identifier)
+        if self.referred_by and self.referred_type:
+            msg += self.extra.format(referred_type=self.referred_type, referred_by=self.referred_by)
+        if self.more:
+            msg += f" {self.more}"
+        msg += f" Fix {self.fix.format(resource_type=self.resource_type, identifier=self.identifier)}"
+        return msg
+
+
+@dataclass(unsafe_hash=True)
+class ResourceNotDefinedError(ResourceError[T_Identifier]):
+    """The {resource_type} {identifier} is not defined in the {location}"""
+
+    extra = "{column_name} {row_number} in {sheet_name}"
+    fix = "Define the {resource_type} {identifier} in {location}."
+
+    location: str
+    column_name: str | None = None
+    row_number: int | None = None
+    sheet_name: str | None = None
+
+
+@dataclass(unsafe_hash=True)
+class ResourceConversionError(ResourceError, ValueError):
+    """Failed to convert the {resource_type} {identifier} to {target_format}: {reason}"""
+
+    fix = "Check the error message and correct the data model."
+    target_format: str
+    reason: str
+
+
+@dataclass(unsafe_hash=True)
+class ResourceCreationError(ResourceError[T_Identifier], ValueError):
+    """Failed to create {resource_type} with identifier {identifier}. The error was: {error}"""
+
+    error: str
+
+
+@dataclass(unsafe_hash=True)
+class ResourceMissingIdentifierError(NeatError, ValueError):
+    """The {resource_type} with name {name} is missing an identifier."""
+
+    resource_type: ResourceType
+    name: str | None = None
+
+
+@dataclass(unsafe_hash=True)
+class ResourceChangedError(ResourceError[T_Identifier]):
+    """The {resource_type} with identifier {identifier} has changed{changed}"""
+
+    fix = (
+        "When extending model with extension set to addition or reshape, "
+        "the {resource_type} properties must remain the same"
+    )
+
+    changed_properties: frozenset[str]
+    changed_attributes: frozenset[str]
+
+    def as_message(self, include_type: bool = True) -> str:
+        if self.changed_properties:
+            changed = f" properties {humanize_collection(self.changed_properties)}."
+        elif self.changed_attributes:
+            changed = f" attributes {humanize_collection(self.changed_attributes)}."
+        else:
+            changed = "."
+        msg = (self.__doc__ or "").format(resource_type=self.resource_type, identifier=self.identifier, changed=changed)
+        msg += f"Fix {self.fix.format(resource_type=self.resource_type)}"
+        return msg

cognite/neat/v0/core/_issues/errors/_wrapper.py

@@ -0,0 +1,93 @@
+from abc import ABC
+from dataclasses import dataclass
+from typing import ClassVar, cast
+
+from cognite.neat.v0.core._issues import NeatError
+from cognite.neat.v0.core._utils.spreadsheet import SpreadsheetRead
+
+
+@dataclass(unsafe_hash=True)
+class SpreadsheetError(NeatError, ValueError, ABC):
+    """In row {row}: {error}"""
+
+    _name: ClassVar[str] = ""
+    error: NeatError
+
+    @classmethod
+    def create(
+        cls, location: tuple[int | str, ...], error: NeatError, spreadsheet: SpreadsheetRead | None = None
+    ) -> "SpreadsheetError":
+        spreadsheet_name = cast(str, location[0])
+        if spreadsheet_name not in ERROR_CLS_BY_SPREADSHEET_NAME:
+            # This happens for the metadata sheet, which are individual fields
+            if spreadsheet_name == "Metadata" and len(location) >= 2 and isinstance(location[1], str):
+                field_name = cast(str, location[1])
+            else:
+                field_name = spreadsheet_name
+            return MetadataValueError(error, field_name=field_name)
+
+        error_cls = ERROR_CLS_BY_SPREADSHEET_NAME[spreadsheet_name]
+        row, column = cast(tuple[int, str], location[2:4])
+
+        if spreadsheet:
+            row = spreadsheet.adjusted_row_number(row)
+
+        return error_cls(
+            row=row,
+            error=error,
+            column=column,
+        )
+
+
+@dataclass(unsafe_hash=True)
+class SpreadsheetListError(SpreadsheetError, ABC):
+    """In row {row}, column '{column}': {error}"""
+
+    row: int
+    column: str
+
+
+@dataclass(unsafe_hash=True)
+class MetadataValueError(SpreadsheetError):
+    """In field {field_name}: {error}"""
+
+    _type: ClassVar[str] = "Metadata"
+    field_name: str
+
+
+@dataclass(unsafe_hash=True)
+class ViewValueError(SpreadsheetListError):
+    _name = "Views"
+
+
+@dataclass(unsafe_hash=True)
+class ContainerValueError(SpreadsheetListError):
+    _name = "Containers"
+
+
+@dataclass(unsafe_hash=True)
+class PropertyValueError(SpreadsheetListError):
+    _name = "Properties"
+
+
+@dataclass(unsafe_hash=True)
+class ConceptValueError(SpreadsheetListError):
+    _name = "Concepts"
+
+
+@dataclass(unsafe_hash=True)
+class EnumValueError(SpreadsheetListError):
+    _name = "Enum"
+
+
+@dataclass(unsafe_hash=True)
+class NodeValueError(SpreadsheetListError):
+    _name = "Nodes"
+
+
+ERROR_CLS_BY_SPREADSHEET_NAME = {cls_._name: cls_ for cls_ in SpreadsheetListError.__subclasses__()}
+
+# Efficient way to set docstring for all classes
+for _cls in ERROR_CLS_BY_SPREADSHEET_NAME.values():
+    _cls.__doc__ = SpreadsheetListError.__doc__
+del _cls

cognite/neat/{rules/issues → v0/core/_issues}/formatters.py

@@ -3,9 +3,9 @@ import xml.etree.ElementTree as ET
 from abc import ABC, abstractmethod
 from pathlib import Path
 
-from .base import IssueList, NeatValidationError, ValidationWarning
+from ._base import IssueList, NeatError, NeatWarning
 
-__all__ = ["Formatter", "BasicHTML", "FORMATTER_BY_NAME"]
+__all__ = ["FORMATTER_BY_NAME", "BasicHTML", "Formatter"]
 
 
 class Formatter(ABC):
@@ -37,13 +37,13 @@ class Formatter(ABC):
 class BasicHTML(Formatter):
     file_suffix = ".html"
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._doc = ET.Element("html")
         self._body = ET.SubElement(self._doc, "body")
 
     def create_report(self, issues: IssueList) -> str:
-        errors = [issue for issue in issues if isinstance(issue, NeatValidationError)]
-        warnings_ = [issue for issue in issues if isinstance(issue, ValidationWarning)]
+        errors = [issue for issue in issues if isinstance(issue, NeatError)]
+        warnings_ = [issue for issue in issues if isinstance(issue, NeatWarning)]
         self._doc.clear()
         self._body = ET.SubElement(self._doc, "body")
         h1 = ET.SubElement(self._body, "h1")
@@ -61,11 +61,11 @@ class BasicHTML(Formatter):
 
         return ET.tostring(self._doc, encoding="unicode")
 
-    def _write_errors_or_warnings(self, issues: list[NeatValidationError] | list[ValidationWarning]) -> None:
-        issue_name = "errors" if isinstance(issues[0], NeatValidationError) else "warnings"
+    def _write_errors_or_warnings(self, issues: list[NeatError] | list[NeatWarning]) -> None:
+        issue_name = "errors" if isinstance(issues[0], NeatError) else "warnings"
         main_categories = {base_ for issue in issues for base_ in type(issue).__bases__}
         for category in main_categories:
-            issues_in_category: list[NeatValidationError] | list[ValidationWarning] = [  # type: ignore[assignment]
+            issues_in_category: list[NeatError] | list[NeatWarning] = [  # type: ignore[assignment]
                 issue for issue in issues if isinstance(issue, category)
             ]
             h3 = ET.SubElement(self._body, "h3")
@@ -75,9 +75,11 @@ class BasicHTML(Formatter):
             ul = ET.SubElement(self._body, "ul")
             for issue in issues_in_category:
                 li = ET.SubElement(ul, "li")
-                li.text = issue.message()
+                li.text = issue.as_message()
 
 
 FORMATTER_BY_NAME: dict[str, type[Formatter]] = {
-    subclass.__name__: subclass for subclass in Formatter.__subclasses__() if ABC not in subclass.__bases__  # type: ignore[type-abstract]
+    subclass.__name__: subclass  # type: ignore[type-abstract]
+    for subclass in Formatter.__subclasses__()
+    if ABC not in subclass.__bases__  # type: ignore[type-abstract]
 }

cognite/neat/v0/core/_issues/warnings/__init__.py

@@ -0,0 +1,99 @@
+"""All warnings raised by the neat package are defined here. Note this module is called 'warnings' which
+conflicts with the built-in Python warnings module. However, it is expected to always be used in an absolute
+import, and should thus not cause a naming conflict."""
+
+from cognite.neat.v0.core._issues._base import NeatWarning, _get_subclasses
+
+from . import user_modeling
+from ._external import (
+    CDFAuthWarning,
+    CDFMaxIterationsWarning,
+    FileItemNotSupportedWarning,
+    FileMissingRequiredFieldWarning,
+    FileReadWarning,
+    FileTypeUnexpectedWarning,
+)
+from ._general import (
+    DeprecatedWarning,
+    MissingCogniteClientWarning,
+    NeatValueWarning,
+    NotSupportedWarning,
+    RegexViolationWarning,
+)
+from ._models import (
+    BreakingModelingPrincipleWarning,
+    CDFNotSupportedWarning,
+    ConversionToPhysicalModelImpossibleWarning,
+    NotSupportedHasDataFilterLimitWarning,
+    NotSupportedViewContainerLimitWarning,
+    PrincipleMatchingSpaceAndVersionWarning,
+    PrincipleOneModelOneSpaceWarning,
+    PrincipleSolutionBuildsOnEnterpriseWarning,
+    UndefinedViewWarning,
+    UserModelingWarning,
+)
+from ._properties import (
+    PropertyDataTypeConversionWarning,
+    PropertyDefinitionDuplicatedWarning,
+    PropertyDefinitionWarning,
+    PropertyDirectRelationLimitWarning,
+    PropertyMultipleValueWarning,
+    PropertyNotFoundWarning,
+    PropertyOverwritingWarning,
+    PropertyTypeNotSupportedWarning,
+    PropertyValueTypeUndefinedWarning,
+    ReversedConnectionNotFeasibleWarning,
+)
+from ._resources import (
+    ResourceNeatWarning,
+    ResourceNotFoundWarning,
+    ResourceRegexViolationWarning,
+    ResourceRetrievalWarning,
+    ResourcesDuplicatedWarning,
+    ResourceTypeNotSupportedWarning,
+    ResourceUnknownWarning,
+)
+
+__all__ = [
+    "BreakingModelingPrincipleWarning",
+    "CDFAuthWarning",
+    "CDFMaxIterationsWarning",
+    "CDFNotSupportedWarning",
+    "ConversionToPhysicalModelImpossibleWarning",
+    "DeprecatedWarning",
+    "FileItemNotSupportedWarning",
+    "FileMissingRequiredFieldWarning",
+    "FileReadWarning",
+    "FileTypeUnexpectedWarning",
+    "MissingCogniteClientWarning",
+    "NeatValueWarning",
+    "NotSupportedHasDataFilterLimitWarning",
+    "NotSupportedViewContainerLimitWarning",
+    "NotSupportedWarning",
+    "PrincipleMatchingSpaceAndVersionWarning",
+    "PrincipleOneModelOneSpaceWarning",
+    "PrincipleSolutionBuildsOnEnterpriseWarning",
+    "PropertyDataTypeConversionWarning",
+    "PropertyDefinitionDuplicatedWarning",
+    "PropertyDefinitionWarning",
+    "PropertyDirectRelationLimitWarning",
+    "PropertyMultipleValueWarning",
+    "PropertyNotFoundWarning",
+    "PropertyOverwritingWarning",
+    "PropertyTypeNotSupportedWarning",
+    "PropertyValueTypeUndefinedWarning",
+    "RegexViolationWarning",
+    "ResourceNeatWarning",
+    "ResourceNotFoundWarning",
+    "ResourceRegexViolationWarning",
+    "ResourceRetrievalWarning",
+    "ResourceTypeNotSupportedWarning",
+    "ResourceUnknownWarning",
+    "ResourcesDuplicatedWarning",
+    "ReversedConnectionNotFeasibleWarning",
+    "UndefinedViewWarning",
+    "UserModelingWarning",
+    "user_modeling",
+]
+
+_NEAT_WARNINGS_BY_NAME = {warning.__name__: warning for warning in _get_subclasses(NeatWarning, include_base=True)}

cognite/neat/v0/core/_issues/warnings/_external.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from cognite.neat.v0.core._issues import NeatWarning
+
+
+@dataclass(unsafe_hash=True)
+class FileReadWarning(NeatWarning):
+    """Error when reading file, {filepath}: {reason}"""
+
+    filepath: Path
+    reason: str
+
+
+@dataclass(unsafe_hash=True)
+class FileMissingRequiredFieldWarning(NeatWarning):
+    """Missing required {field_name} in {filepath}: {field}. The file will be skipped"""
+
+    filepath: Path
+    field_name: str
+    field: str
+
+
+@dataclass(unsafe_hash=True)
+class FileTypeUnexpectedWarning(NeatWarning):
+    """Unexpected file type: {filepath}. Expected format: {expected_format}"""
+
+    extra = "Error: {error_message}"
+
+    filepath: Path
+    expected_format: frozenset[str]
+    error_message: str | None = None
+
+
+@dataclass(unsafe_hash=True)
+class FileItemNotSupportedWarning(NeatWarning):
+    """The item {item} in {filepath} is not supported. The item will be skipped"""
+
+    item: str
+    filepath: Path
+
+
+@dataclass(unsafe_hash=True)
+class CDFAuthWarning(NeatWarning):
+    """Failed to {action}: {reason}"""
+
+    action: str
+    reason: str
+
+
+@dataclass(unsafe_hash=True)
+class CDFMaxIterationsWarning(NeatWarning):
+    """The maximum number of iterations ({max_iterations}) has been reached. {message}"""
+
+    message: str
+    max_iterations: int

cognite/neat/v0/core/_issues/warnings/_general.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass
+
+from cognite.neat.v0.core._issues import NeatWarning
+
+
+@dataclass(unsafe_hash=True)
+class NeatValueWarning(NeatWarning):
+    """{value}"""
+
+    value: str
+
+
+@dataclass(unsafe_hash=True)
+class NotSupportedWarning(NeatWarning):
+    """{feature} is not supported"""
+
+    feature: str
+
+
+@dataclass(unsafe_hash=True)
+class RegexViolationWarning(NeatWarning):
+    """The value '{value}' of {identifier} does not match the {pattern_name} pattern '{pattern}'"""
+
+    extra = "{motivation}"
+    value: str
+    pattern: str
+    identifier: str
+    pattern_name: str
+    motivation: str | None = None
+
+
+@dataclass(unsafe_hash=True)
+class MissingCogniteClientWarning(NeatWarning):
+    """Missing Cognite Client required for {functionality}"""
+
+    functionality: str
+
+
+@dataclass(unsafe_hash=True)
+class DeprecatedWarning(NeatWarning):
+    """{feature} is deprecated"""
+
+    extra = "{replacement}"
+
+    feature: str
+    replacement: str | None = None