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

cognite/neat/rules/issues/spreadsheet_file.py

@@ -1,151 +0,0 @@
-from abc import ABC
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, ClassVar
-
-from .base import NeatValidationError
-
-__all__ = [
-    "SpreadsheetFileError",
-    "SpreadsheetNotFoundError",
-    "MetadataSheetMissingOrFailedError",
-    "SheetMissingError",
-    "ReadSpreadsheetsError",
-    "InvalidRoleError",
-]
-
-
-@dataclass(frozen=True)
-class SpreadsheetFileError(NeatValidationError, ABC):
-    description = "Error when reading spreadsheet"
-    filepath: Path
-
-
-@dataclass(frozen=True)
-class SpreadsheetNotFoundError(SpreadsheetFileError):
-    description: ClassVar[str] = "Spreadsheet not found"
-    fix: ClassVar[str] = "Make sure to provide a valid spreadsheet"
-
-    def message(self) -> str:
-        return f"Spreadsheet {self.filepath.name} not found"
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["spreadsheet_name"] = str(self.filepath)
-        return output
-
-
-@dataclass(frozen=True)
-class MetadataSheetMissingOrFailedError(SpreadsheetFileError):
-    description: ClassVar[str] = "Metadata sheet is missing or it failed validation for one or more fields"
-    fix: ClassVar[str] = "Make sure to define compliant Metadata sheet before proceeding"
-    hint: str | None = None
-    sheet_name: str = "Metadata"
-
-    def message(self) -> str:
-        output = (
-            f" {self.sheet_name} sheet is missing or it failed"
-            + f" validation for one or more fields in {self.filepath.name}. "
-            + self.fix
-        )
-        if self.hint:
-            output += f" Hint: {self.hint}"
-        return output
-
-
-@dataclass(frozen=True)
-class RoleMissingOrUnsupportedError(SpreadsheetFileError):
-    description: ClassVar[str] = "Role field in Metadata sheet is missing or its value is unsupported"
-    fix: ClassVar[str] = "Make sure to define compliant role in Metadata sheet before proceeding"
-
-    hint: str | None = None
-
-    def message(self) -> str:
-        output = (
-            f"Role field in Metadata sheet is missing or its value is unsupported {self.filepath.name}. " + self.fix
-        )
-        if self.hint:
-            output += f" Hint: {self.hint}"
-        return output
-
-
-@dataclass(frozen=True)
-class RoleMismatchError(SpreadsheetFileError):
-    description: ClassVar[str] = "Roles between user and reference Metadata sheets do not match"
-    fix: ClassVar[str] = "Make sure that both user and reference Metadata sheets have the same role defined"
-
-    hint: str | None = None
-
-    def message(self) -> str:
-        output = f"Roles between user and reference Metadata sheets do not match {self.filepath.name}. " + self.fix
-        if self.hint:
-            output += f" Hint: {self.hint}"
-        return output
-
-
-@dataclass(frozen=True)
-class SchemaMissingOrUnsupportedError(SpreadsheetFileError):
-    description: ClassVar[str] = "Schema field in Metadata sheet is missing or its value unsupported"
-    fix: ClassVar[str] = "Make sure to define compliant schema in Metadata sheet before proceeding"
-
-    hint: str | None = None
-
-    def message(self) -> str:
-        output = (
-            f"Schema field in Metadata sheet is missing or its value unsupported in file {self.filepath.name}. "
-            + self.fix
-        )
-        if self.hint:
-            output += f" Hint: {self.hint}"
-        return output
-
-
-@dataclass(frozen=True)
-class SheetMissingError(SpreadsheetFileError):
-    description: ClassVar[str] = "Spreadsheet(s) is missing"
-    fix: ClassVar[str] = "Make sure to provide compliant spreadsheet(s) before proceeding"
-
-    missing_spreadsheets: list[str]
-
-    def message(self) -> str:
-        if len(self.missing_spreadsheets) == 1:
-            return f"Spreadsheet {self.missing_spreadsheets[0]} is missing"
-        else:
-            return f"Spreadsheets {', '.join(self.missing_spreadsheets)} are missing"
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["missing_spreadsheets"] = self.missing_spreadsheets
-        return output
-
-
-@dataclass(frozen=True)
-class ReadSpreadsheetsError(SpreadsheetFileError):
-    description: ClassVar[str] = "Error reading spreadsheet(s)"
-    fix: ClassVar[str] = "Is the excel document open in another program? Is the file corrupted?"
-
-    error_message: str
-
-    def message(self) -> str:
-        return f"Error reading spreadsheet {self.filepath.name}: {self.error_message}"
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["error_message"] = self.error_message
-        return output
-
-
-@dataclass(frozen=True)
-class InvalidRoleError(NeatValidationError):
-    description: ClassVar[str] = "Invalid role"
-    fix: ClassVar[str] = "Make sure to provide a valid role"
-
-    provided_role: str
-
-    def message(self) -> str:
-        return f"Invalid role: {self.provided_role}"
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["provided_role"] = self.provided_role
-        return output

cognite/neat/rules/issues/tables.py

@@ -1,72 +0,0 @@
-from dataclasses import dataclass
-
-from .base import NeatValidationError
-
-
-@dataclass(frozen=True)
-class NotValidRDFPathError(NeatValidationError):
-    """Provided `rdfpath` is not valid, i.e. it cannot be converted to SPARQL query.
-
-    Args:
-        rdf_path: `rdfpath` that raised exception
-
-    Notes:
-        Get familiar with `rdfpath` to avoid this exception.
-    """
-
-    description = "Provided `rdfpath` is not valid, i.e. it cannot be converted to SPARQL query"
-    fix = "Get familiar with `rdfpath` and check if provided path is valid!"
-    rdf_path: str
-
-    def message(self) -> str:
-        message = f"{self.rdf_path} is not a valid rdfpath!"
-
-        message += f"\nDescription: {self.description}"
-        message += f"\nFix: {self.fix}"
-        return message
-
-
-@dataclass(frozen=True)
-class NotValidTableLookUpError(NeatValidationError):
-    """Provided `table lookup` is not valid, i.e. it cannot be converted to CDF lookup.
-
-    Args:
-        table_look_up: `table_look_up`, a part of `rawlookup`, that raised exception
-
-    Notes:
-        Get familiar with `rawlookup` and `rdfpath` to avoid this exception.
-    """
-
-    description = "Provided table lookup is not valid, i.e. it cannot be converted to CDF lookup"
-    fix = "Get familiar with RAW look up and RDF paths and check if provided rawlookup is valid"
-    table_look_up: str
-
-    def message(self) -> str:
-        message = f"{self.table_look_up} is not a valid table lookup"
-
-        message += f"\nDescription: {self.description}"
-        message += f"\nFix: {self.fix}"
-        return message
-
-
-@dataclass(frozen=True)
-class NotValidRAWLookUpError(NeatValidationError):
-    """Provided `rawlookup` is not valid, i.e. it cannot be converted to SPARQL query and CDF lookup
-
-    Args:
-        raw_look_up: `rawlookup` rule that raised exception
-
-    Notes:
-        Get familiar with `rawlookup` and `rdfpath` to avoid this exception.
-    """
-
-    description = "Provided rawlookup is not valid, i.e. it cannot be converted to SPARQL query and CDF lookup"
-    fix = "Get familiar with `rawlookup` and `rdfpath` to avoid this exception"
-    raw_look_up: str
-
-    def message(self):
-        message = f"Invalid rawlookup expected traversal | table lookup, got {self.raw_look_up}"
-
-        message += f"\nDescription: {self.description}"
-        message += f"\nFix: {self.fix}"
-        return message

cognite/neat/rules/models/_constants.py

@@ -1 +0,0 @@
-DMS_CONTAINER_SIZE_LIMIT = 100

cognite/neat/rules/models/_types/__init__.py

@@ -1,19 +0,0 @@
-from ._field import (
-    ExternalIdType,
-    NamespaceType,
-    PrefixType,
-    PropertyType,
-    StrListType,
-    StrOrListType,
-    VersionType,
-)
-
-__all__ = [
-    "StrOrListType",
-    "StrListType",
-    "NamespaceType",
-    "PrefixType",
-    "ExternalIdType",
-    "VersionType",
-    "PropertyType",
-]

cognite/neat/rules/models/asset/_converter.py

@@ -1,4 +0,0 @@
-from cognite.neat.rules.models.information._converter import _InformationRulesConverter
-
-
-class _AssetRulesConverter(_InformationRulesConverter): ...

cognite/neat/rules/models/dms/_converter.py

@@ -1,145 +0,0 @@
-import warnings
-from typing import TYPE_CHECKING, cast
-
-from rdflib import Namespace
-
-from cognite.neat.rules import issues
-from cognite.neat.rules.models._base import SheetList
-from cognite.neat.rules.models.data_types import DataType
-from cognite.neat.rules.models.domain import DomainRules
-from cognite.neat.rules.models.entities import (
-    ClassEntity,
-    ContainerEntity,
-    DMSUnknownEntity,
-    ReferenceEntity,
-    UnknownEntity,
-    ViewEntity,
-    ViewPropertyEntity,
-)
-from cognite.neat.rules.models.information._rules import InformationRules
-
-from ._rules import DMSMetadata, DMSProperty, DMSRules, DMSView
-
-if TYPE_CHECKING:
-    from cognite.neat.rules.models.information._rules import InformationMetadata
-
-
-class _DMSRulesConverter:
-    def __init__(self, dms: DMSRules):
-        self.dms = dms
-
-    def as_domain_rules(self) -> "DomainRules":
-        raise NotImplementedError("DomainRules not implemented yet")
-
-    def as_information_rules(
-        self,
-    ) -> "InformationRules":
-        from cognite.neat.rules.models.information._rules import (
-            InformationClass,
-            InformationProperty,
-            InformationRules,
-        )
-
-        dms = self.dms.metadata
-
-        metadata = self._convert_metadata_to_info(dms)
-
-        classes = [
-            InformationClass(
-                # we do not want a version in class as we use URI for the class
-                class_=ClassEntity(prefix=view.class_.prefix, suffix=view.class_.suffix),
-                description=view.description,
-                parent=[
-                    # we do not want a version in class as we use URI for the class
-                    implemented_view.as_class(skip_version=True)
-                    # We only want parents in the same namespace, parent in a different namespace is a reference
-                    for implemented_view in view.implements or []
-                    if implemented_view.prefix == view.class_.prefix
-                ],
-                reference=self._get_class_reference(view),
-            )
-            for view in self.dms.views
-        ]
-
-        properties: list[InformationProperty] = []
-        value_type: DataType | ClassEntity | str
-        for property_ in self.dms.properties:
-            if isinstance(property_.value_type, DataType):
-                value_type = property_.value_type
-            elif isinstance(property_.value_type, ViewEntity | ViewPropertyEntity):
-                value_type = ClassEntity(
-                    prefix=property_.value_type.prefix,
-                    suffix=property_.value_type.suffix,
-                )
-            elif isinstance(property_.value_type, DMSUnknownEntity):
-                value_type = UnknownEntity()
-            else:
-                raise ValueError(f"Unsupported value type: {property_.value_type.type_}")
-
-            properties.append(
-                InformationProperty(
-                    # Removing version
-                    class_=ClassEntity(suffix=property_.class_.suffix, prefix=property_.class_.prefix),
-                    property_=property_.view_property,
-                    value_type=value_type,
-                    description=property_.description,
-                    min_count=0 if property_.nullable or property_.nullable is None else 1,
-                    max_count=float("inf") if property_.is_list or property_.nullable is None else 1,
-                    reference=self._get_property_reference(property_),
-                )
-            )
-
-        return InformationRules(
-            metadata=metadata,
-            properties=SheetList[InformationProperty](data=properties),
-            classes=SheetList[InformationClass](data=classes),
-            last=self.dms.last.as_information_rules() if self.dms.last else None,
-            reference=self.dms.reference.as_information_rules() if self.dms.reference else None,
-        )
-
-    @classmethod
-    def _convert_metadata_to_info(cls, metadata: DMSMetadata) -> "InformationMetadata":
-        from cognite.neat.rules.models.information._rules import InformationMetadata
-
-        prefix = metadata.space
-        return InformationMetadata(
-            schema_=metadata.schema_,
-            data_model_type=metadata.data_model_type,
-            extension=metadata.extension,
-            prefix=prefix,
-            namespace=Namespace(f"https://purl.orgl/neat/{prefix}/"),
-            version=metadata.version,
-            description=metadata.description,
-            name=metadata.name or metadata.external_id,
-            creator=metadata.creator,
-            created=metadata.created,
-            updated=metadata.updated,
-        )
-
-    @classmethod
-    def _get_class_reference(cls, view: DMSView) -> ReferenceEntity | None:
-        parents_other_namespace = [parent for parent in view.implements or [] if parent.prefix != view.class_.prefix]
-        if len(parents_other_namespace) == 0:
-            return None
-        if len(parents_other_namespace) > 1:
-            warnings.warn(
-                issues.dms.MultipleReferenceWarning(
-                    view_id=view.view.as_id(), implements=[v.as_id() for v in parents_other_namespace]
-                ),
-                stacklevel=2,
-            )
-        other_parent = parents_other_namespace[0]
-
-        return ReferenceEntity(prefix=other_parent.prefix, suffix=other_parent.suffix)
-
-    @classmethod
-    def _get_property_reference(cls, property_: DMSProperty) -> ReferenceEntity | None:
-        has_container_other_namespace = property_.container and property_.container.prefix != property_.class_.prefix
-        if not has_container_other_namespace:
-            return None
-        container = cast(ContainerEntity, property_.container)
-        return ReferenceEntity(
-            prefix=container.prefix,
-            suffix=container.suffix,
-            property=property_.container_property,
-        )

cognite/neat/workflows/_exceptions.py

@@ -1,41 +0,0 @@
-from cognite.neat.exceptions import NeatException
-
-
-class InvalidStepOutputException(NeatException):
-    type_ = "invalid_step_output"
-    code = 400
-    description = "The step output is invalid."
-    example = "The step output must be a dictionary."
-
-    def __init__(self, step_type: str):
-        self.message = f"Object type {step_type} is not supported as step output"
-        super().__init__(self.message)
-
-
-class ConfigurationNotSet(NeatException):
-    type_ = "configuration_not_set"
-    code = 400
-    description = "The configuration is not set."
-    example = "The configuration must be set before running the workflow."
-
-    def __init__(self, config_variable: str):
-        self.message = (
-            f"The configuration variable '{config_variable}' is not set. "
-            f"Please set the configuration before running the workflow."
-        )
-        super().__init__(self.message)
-
-    def __str__(self):
-        return self.message
-
-
-class StepNotInitialized(NeatException):
-    def __init__(self, step_name: str):
-        self.message = f"Step {step_name} has not been initialized."
-        super().__init__(self.message)
-
-
-class StepFlowContextNotInitialized(NeatException):
-    def __init__(self, step_name: str):
-        self.message = f"Step {step_name} requires flow context which is missing."
-        super().__init__(self.message)