cognite-neat 0.88.2__py3-none-any.whl → 0.89.0__py3-none-any.whl

cognite/neat/issues/errors/properties.py

@@ -1,75 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Generic
-
-from .resources import ResourceError, T_Identifier, T_ReferenceIdentifier
-
-
-@dataclass(frozen=True)
-class PropertyNotFoundError(ResourceError[T_Identifier]):
-    """The {resource_type} with identifier {identifier} does not have a property {property_name}"""
-
-    property_name: str
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            resource_type=self.resource_type, identifier=repr(self.identifier), property_name=self.property_name
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["property_name"] = self.property_name
-        return output
-
-
-@dataclass(frozen=True)
-class ReferredPropertyNotFoundError(ResourceError, Generic[T_Identifier, T_ReferenceIdentifier]):
-    """The {resource_type} with identifier {identifier} does not have a property {property_name} 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
-    referred_type: str
-    property_name: str
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            resource_type=self.resource_type,
-            identifier=repr(self.identifier),
-            referred_type=self.referred_type,
-            referred_by=repr(self.referred_by),
-            property_name=self.property_name,
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["resource_type"] = self.resource_type
-        output["identifier"] = self.identifier
-        output["referred_by"] = self.referred_by
-        output["referred_type"] = self.referred_type
-        output["property_name"] = self.property_name
-        return output
-
-
-@dataclass(frozen=True)
-class PropertyTypeNotSupportedError(ResourceError[T_Identifier]):
-    """The {resource_type} with identifier {identifier} has a property {property_name}
-    of unsupported type {property_type}"""
-
-    property_name: str
-    property_type: str
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            resource_type=self.resource_type,
-            identifier=repr(self.identifier),
-            property_name=self.property_name,
-            property_type=self.property_type,
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["property_name"] = self.property_name
-        output["property_type"] = self.property_type
-        return output

cognite/neat/issues/errors/resources.py

@@ -1,123 +0,0 @@
-from collections.abc import Hashable
-from dataclasses import dataclass
-from typing import Any, Generic, TypeVar
-
-from cognite.neat.issues import NeatError
-
-T_Identifier = TypeVar("T_Identifier", bound=Hashable)
-
-
-@dataclass(frozen=True)
-class ResourceError(NeatError, Generic[T_Identifier]):
-    """Base class for resource errors"""
-
-    identifier: T_Identifier
-    resource_type: str
-
-
-@dataclass(frozen=True)
-class ResourceNotFoundError(ResourceError[T_Identifier]):
-    """The {resource_type} with identifier {identifier} is missing: {reason}"""
-
-    fix = "Check the {resource_type} {identifier} and try again."
-    reason: str
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            resource_type=self.resource_type, identifier=repr(self.identifier), reason=self.reason
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["resource_type"] = self.resource_type
-        output["identifier"] = self.identifier
-        output["reason"] = self.reason
-        return output
-
-
-T_ReferenceIdentifier = TypeVar("T_ReferenceIdentifier", bound=Hashable)
-
-
-@dataclass(frozen=True)
-class ReferredResourceNotFoundError(ResourceError, Generic[T_Identifier, T_ReferenceIdentifier]):
-    """The {resource_type} with identifier {identifier} referred by {referred_type} {referred_by} does not exist"""
-
-    fix = "Create the {resource_type}"
-
-    referred_by: T_ReferenceIdentifier
-    referred_type: str
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            resource_type=self.resource_type,
-            identifier=repr(self.identifier),
-            referred_type=self.referred_type,
-            referred_by=repr(self.referred_by),
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["resource_type"] = self.resource_type
-        output["identifier"] = self.identifier
-        output["referred_by"] = self.referred_by
-        output["referred_type"] = self.referred_type
-        return output
-
-
-@dataclass(frozen=True)
-class FailedConvertError(NeatError):
-    description = "Failed to convert the {identifier} to {target_format}: {reason}"
-    fix = "Check the error message and correct the rules."
-    identifier: str
-    target_format: str
-    reason: str
-
-    def message(self) -> str:
-        return self.description.format(identifier=self.identifier, target_format=self.target_format, reason=self.reason)
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["identifier"] = self.identifier
-        output["targetFormat"] = self.target_format
-        output["reason"] = self.reason
-        return output
-
-
-@dataclass(frozen=True)
-class InvalidResourceError(NeatError):
-    """The {resource_type} with identifier {identifier} is invalid and will be skipped. {reason}"""
-
-    fix = "Check the error message and correct the instance."
-
-    resource_type: str
-    identifier: str
-    reason: str
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            resource_type=self.resource_type, identifier=self.identifier, reason=self.reason
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["type"] = self.resource_type
-        output["identifier"] = self.identifier
-        output["reason"] = self.reason
-        return output
-
-
-@dataclass(frozen=True)
-class MissingIdentifierError(NeatError):
-    """The {resource_type} with name {name} is missing an identifier."""
-
-    resource_type: str
-    name: str | None = None
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(resource_type=self.resource_type, name=self.name or "unknown")
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["type"] = self.resource_type
-        output["name"] = self.name
-        return output

cognite/neat/issues/neat_warnings/__init__.py

@@ -1,2 +0,0 @@
-"""All warnings raised by the neat package are defined here. Note this module is called 'neat_warnings' instead
-of 'warnings' to avoid conflicts with the built-in Python warnings module."""

cognite/neat/issues/neat_warnings/identifier.py

@@ -1,27 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-
-from cognite.neat.issues import NeatWarning
-
-
-@dataclass(frozen=True)
-class RegexViolationWarning(NeatWarning):
-    """The value '{value}' of {identifier} does not match the {pattern_name} pattern '{pattern}'"""
-
-    value: str
-    pattern: str
-    identifier: str
-    pattern_name: str
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            value=self.value, pattern=self.pattern, identifier=self.identifier, pattern_name=self.pattern_name
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["value"] = self.value
-        output["pattern"] = self.pattern
-        output["identifier"] = self.identifier
-        output["pattern_name"] = self.pattern_name
-        return output

cognite/neat/issues/neat_warnings/models.py

@@ -1,22 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-
-from cognite.neat.issues import NeatWarning
-
-
-@dataclass(frozen=True)
-class InvalidClassWarning(NeatWarning):
-    description = "The class {class_name} is invalid and will be skipped. {reason}"
-    fix = "Check the error message and correct the class."
-
-    class_name: str
-    reason: str
-
-    def message(self) -> str:
-        return self.description.format(class_name=self.class_name, reason=self.reason)
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["class_name"] = self.class_name
-        output["reason"] = self.reason
-        return output

cognite/neat/issues/neat_warnings/properties.py

@@ -1,77 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Generic
-
-from .resources import ResourceWarning, T_Identifier, T_ReferenceIdentifier
-
-
-@dataclass(frozen=True)
-class PropertyTypeNotSupportedWarning(ResourceWarning[T_Identifier]):
-    """The {resource_type} with identifier {identifier} has a property {property_name}
-    of unsupported type {property_type}. This will be ignored."""
-
-    property_name: str
-    property_type: str
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            resource_type=self.resource_type,
-            identifier=repr(self.identifier),
-            property_name=self.property_name,
-            property_type=self.property_type,
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["property_name"] = self.property_name
-        output["property_type"] = self.property_type
-        return output
-
-
-@dataclass(frozen=True)
-class ReferredPropertyNotFoundWarning(ResourceWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
-    """The {resource_type} with identifier {identifier} does not have a property {property_name} referred
-    to by {referred_type} {referred_by} does not exist. This will be ignored.
-    """
-
-    fix = "Ensure the {resource_type} {identifier} has a {property_name} property"
-
-    referred_by: T_ReferenceIdentifier
-    referred_type: str
-    property_name: str
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            resource_type=self.resource_type,
-            identifier=repr(self.identifier),
-            referred_type=self.referred_type,
-            referred_by=repr(self.referred_by),
-            property_name=self.property_name,
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["resource_type"] = self.resource_type
-        output["identifier"] = self.identifier
-        output["referred_by"] = self.referred_by
-        output["referred_type"] = self.referred_type
-        output["property_name"] = self.property_name
-        return output
-
-
-@dataclass(frozen=True)
-class PropertyRedefinedWarning(ResourceWarning[T_Identifier]):
-    """The {resource_type} with identifier {identifier} has a property {property_name} redefined."""
-
-    property_id: str
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            resource_type=self.resource_type, identifier=repr(self.identifier), property_name=self.property_id
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["property_id"] = self.property_id
-        output["resource_type"] = self.resource_type
-        output["identifier"] = self.identifier
-        return output

cognite/neat/issues/neat_warnings/resources.py

@@ -1,125 +0,0 @@
-from collections.abc import Hashable
-from dataclasses import dataclass
-from typing import Any, Generic, TypeVar
-
-from cognite.neat.issues import NeatWarning
-
-T_Identifier = TypeVar("T_Identifier", bound=Hashable)
-
-T_ReferenceIdentifier = TypeVar("T_ReferenceIdentifier", bound=Hashable)
-
-
-@dataclass(frozen=True)
-class ResourceWarning(NeatWarning, Generic[T_Identifier]):
-    """Base class for resource warnings"""
-
-    identifier: T_Identifier
-    resource_type: str
-
-
-@dataclass(frozen=True)
-class ResourceNotFoundWarning(ResourceWarning[T_Identifier]):
-    """The {resource_type} with identifier {identifier} is missing: {reason}. This will be ignored."""
-
-    fix = "Check the {resource_type} {identifier} and try again."
-    reason: str
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            resource_type=self.resource_type, identifier=repr(self.identifier), reason=self.reason
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["resource_type"] = self.resource_type
-        output["identifier"] = self.identifier
-        output["reason"] = self.reason
-        return output
-
-
-@dataclass(frozen=True)
-class ReferredResourceNotFoundWarning(ResourceWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
-    """The {resource_type} with identifier {identifier} referred by {referred_type} {referred_by} does not exist.
-    This will be ignored."""
-
-    fix = "Create the {resource_type}"
-
-    referred_by: T_ReferenceIdentifier
-    referred_type: str
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            resource_type=self.resource_type,
-            identifier=repr(self.identifier),
-            referred_type=self.referred_type,
-            referred_by=repr(self.referred_by),
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["resource_type"] = self.resource_type
-        output["identifier"] = self.identifier
-        output["referred_by"] = self.referred_by
-        output["referred_type"] = self.referred_type
-        return output
-
-
-@dataclass(frozen=True)
-class MultipleResourcesWarning(NeatWarning, Generic[T_Identifier]):
-    """Multiple resources of type {resource_type} with identifiers {resources} were found. This will be ignored."""
-
-    fix = "Remove the duplicate resources"
-
-    resources: frozenset[T_Identifier]
-    resource_type: str
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            resource_type=self.resource_type,
-            resources=self.resources,
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["resource_type"] = self.resource_type
-        output["resources"] = self.resources
-        return output
-
-
-@dataclass(frozen=True)
-class FailedLoadingResourcesWarning(NeatWarning, Generic[T_Identifier]):
-    """Failed to load resources of type {resource_type} with identifiers {resources}. Continuing without
-    these resources."""
-
-    extra = "The error was: {error}"
-
-    fix = "Check the error."
-
-    resources: frozenset[T_Identifier]
-    resource_type: str
-    error: str | None = None
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(
-            resource_type=self.resource_type,
-            resources=self.resources,
-        ) + (self.extra.format(error=self.error) if self.error else "")
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["resource_type"] = self.resource_type
-        output["resources"] = self.resources
-        return output
-
-
-class ResourceTypeNotSupportedWarning(ResourceWarning[T_Identifier]):
-    """The {resource_type} with identifier {identifier} is not supported. This will be ignored."""
-
-    def message(self) -> str:
-        return (self.__doc__ or "").format(resource_type=self.resource_type, identifier=repr(self.identifier))
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["resource_type"] = self.resource_type
-        output["identifier"] = self.identifier
-        return output

cognite/neat/rules/issues/__init__.py

@@ -1,22 +0,0 @@
-from cognite.neat.issues import MultiValueError
-
-from . import dms, fileread, spreadsheet, spreadsheet_file
-from .base import (
-    DefaultPydanticError,
-    NeatValidationError,
-    ValidationIssue,
-    ValidationWarning,
-)
-
-__all__ = [
-    "DefaultPydanticError",
-    "MultiValueError",
-    "NeatValidationError",
-    "ValidationIssue",
-    "ValidationIssue",
-    "ValidationWarning",
-    "dms",
-    "fileread",
-    "spreadsheet",
-    "spreadsheet_file",
-]

cognite/neat/rules/issues/base.py

@@ -1,63 +0,0 @@
-from abc import ABC
-from dataclasses import dataclass
-from typing import Any
-
-from pydantic_core import ErrorDetails
-
-from cognite.neat.issues import MultiValueError, NeatError, NeatIssue, NeatWarning
-
-__all__ = [
-    "ValidationIssue",
-    "NeatValidationError",
-    "DefaultPydanticError",
-    "ValidationWarning",
-    "MultiValueError",
-]
-
-
-@dataclass(frozen=True)
-class ValidationIssue(NeatIssue, ABC): ...
-
-
-@dataclass(frozen=True)
-class NeatValidationError(NeatError, ValidationIssue, ABC): ...
-
-
-@dataclass(frozen=True)
-class DefaultPydanticError(NeatValidationError):
-    type: str
-    loc: tuple[int | str, ...]
-    msg: str
-    input: Any
-    ctx: dict[str, Any] | None
-
-    @classmethod
-    def from_pydantic_error(cls, error: ErrorDetails) -> "NeatValidationError":
-        return cls(
-            type=error["type"],
-            loc=error["loc"],
-            msg=error["msg"],
-            input=error.get("input"),
-            ctx=error.get("ctx"),
-        )
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["type"] = self.type
-        output["loc"] = self.loc
-        output["msg"] = self.msg
-        output["input"] = self.input
-        output["ctx"] = self.ctx
-        return output
-
-    def message(self) -> str:
-        if self.loc and len(self.loc) == 1:
-            return f"{self.loc[0]} sheet: {self.msg}"
-        elif self.loc and len(self.loc) == 2:
-            return f"{self.loc[0]} sheet field/column <{self.loc[1]}>: {self.msg}"
-        else:
-            return self.msg
-
-
-@dataclass(frozen=True)
-class ValidationWarning(NeatWarning, ValidationIssue, ABC): ...