cognite-neat 0.88.1__py3-none-any.whl → 0.88.3__py3-none-any.whl

cognite/neat/graph/exceptions.py

@@ -1,90 +0,0 @@
-"""This module contains the definition of validation errors and warnings raised during graph methods"""
-
-from cognite.neat.constants import DEFAULT_DOCS_URL
-from cognite.neat.exceptions import NeatException
-
-DOCS_BASE_URL = f"{DEFAULT_DOCS_URL}api/exceptions.html#{__name__}"
-
-
-class UnsupportedPropertyType(NeatException):
-    """Unsupported property type when processing the graph capturing sheet
-
-    Args:
-        property_type: property type that is not supported
-        verbose: flag that indicates whether to provide enhanced exception message, by default False
-    """
-
-    type_: str = "UnsupportedPropertyType"
-    code: int = 1000
-    description: str = "Unsupported property type when processing the graph capturing sheet."
-    example: str = ""
-    fix: str = ""
-
-    def __init__(self, property_type: str, verbose: bool = False):
-        self.property_type = property_type
-
-        self.message = (
-            f"Property type {self.property_type} is not supported. "
-            " Only the following property types are supported: DatatypeProperty and ObjectProperty"
-            f"\nFor more information visit: {DOCS_BASE_URL}.{self.__class__.__name__}"
-        )
-
-        if verbose:
-            self.message += f"\nDescription: {self.description}"
-            self.message += f"\nExample: {self.example}"
-            self.message += f"\nFix: {self.fix}"
-        super().__init__(self.message)
-
-
-class NamespaceRequired(NeatException):
-    """The functionality requires namespace in the TransformationRules.
-
-    Args:
-        functionality: functionality that requires namespace
-        verbose: flag that indicates whether to provide enhanced exception message, by default False
-    """
-
-    type_ = "NamespaceRequired"
-    description: str = "The functionality requires namespace in the TransformationRules."
-    example: str = ""
-    fix: str = ""
-
-    def __init__(self, functionality: str, verbose: bool = False):
-        self.message = (
-            f"Namespace is required to be set in the Transformation rules"
-            f"to use {functionality}."
-            f"\nFor more information visit: {DOCS_BASE_URL}.{self.__class__.__name__}"
-        )
-
-        if verbose:
-            self.message += f"\nDescription: {self.description}"
-            self.message += f"\nExample: {self.example}"
-            self.message += f"\nFix: {self.fix}"
-        super().__init__(self.message)
-
-
-class DatasetIdRequired(NeatException):
-    """The functionality requires data_set_id in the TransformationRules.
-
-    Args:
-        functionality: functionality that requires namespace
-        verbose: flag that indicates whether to provide enhanced exception message, by default False
-    """
-
-    type_ = "DatasetIdRequired"
-    description: str = "The functionality requires data_set_id in the TransformationRules."
-    example: str = ""
-    fix: str = ""
-
-    def __init__(self, functionality: str, verbose: bool = False):
-        self.message = (
-            f"DataSetId is required to be set in the Transformation rules"
-            f"to use {functionality}."
-            f"\nFor more information visit: {DOCS_BASE_URL}.{self.__class__.__name__}"
-        )
-
-        if verbose:
-            self.message += f"\nDescription: {self.description}"
-            self.message += f"\nExample: {self.example}"
-            self.message += f"\nFix: {self.fix}"
-        super().__init__(self.message)

cognite/neat/graph/issues/loader.py

@@ -1,104 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-
-from cognite.neat.issues import NeatError, NeatWarning
-
-__all__ = [
-    "FailedAuthorizationError",
-    "MissingDataModelError",
-    "FailedConvertError",
-    "InvalidClassWarning",
-    "InvalidInstanceError",
-]
-
-
-@dataclass(frozen=True)
-class FailedAuthorizationError(NeatError):
-    description = "Missing authorization for {action}: {reason}"
-
-    action: str
-    reason: str
-
-    def message(self) -> str:
-        return self.description.format(action=self.action, reason=self.reason)
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["action"] = self.action
-        output["reason"] = self.reason
-        return output
-
-
-@dataclass(frozen=True)
-class MissingDataModelError(NeatError):
-    description = "The data model with identifier {identifier} is missing: {reason}"
-    fix = "Check the data model identifier and try again."
-
-    identifier: str
-    reason: str
-
-    def message(self) -> str:
-        return self.description.format(identifier=self.identifier, reason=self.reason)
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["identifier"] = self.identifier
-        output["reason"] = self.reason
-        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 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
-
-
-@dataclass(frozen=True)
-class InvalidInstanceError(NeatError):
-    description = "The {type_} with identifier {identifier} is invalid and will be skipped. {reason}"
-    fix = "Check the error message and correct the instance."
-
-    type_: str
-    identifier: str
-    reason: str
-
-    def message(self) -> str:
-        return self.description.format(type_=self.type_, identifier=self.identifier, reason=self.reason)
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["type"] = self.type_
-        output["identifier"] = self.identifier
-        output["reason"] = self.reason
-        return output

cognite/neat/issues.py

@@ -1,158 +0,0 @@
-import sys
-import warnings
-from abc import ABC, abstractmethod
-from collections import UserList
-from collections.abc import Sequence
-from dataclasses import dataclass
-from functools import total_ordering
-from typing import Any, ClassVar, TypeVar
-from warnings import WarningMessage
-
-import pandas as pd
-from pydantic_core import PydanticCustomError
-
-if sys.version_info < (3, 11):
-    from exceptiongroup import ExceptionGroup
-    from typing_extensions import Self
-else:
-    from typing import Self
-
-
-@total_ordering
-@dataclass(frozen=True)
-class NeatIssue(ABC):
-    description: ClassVar[str]
-    fix: ClassVar[str]
-
-    def message(self) -> str:
-        """Return a human-readable message for the issue.
-
-        This is the default implementation, which returns the description.
-        It is recommended to override this method in subclasses with a more
-        specific message.
-        """
-        return self.description
-
-    @abstractmethod
-    def dump(self) -> dict[str, Any]:
-        """Return a dictionary representation of the issue."""
-        raise NotImplementedError()
-
-    def __lt__(self, other: "NeatIssue") -> bool:
-        if not isinstance(other, NeatIssue):
-            return NotImplemented
-        return (type(self).__name__, self.message()) < (type(other).__name__, other.message())
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, NeatIssue):
-            return NotImplemented
-        return (type(self).__name__, self.message()) == (type(other).__name__, other.message())
-
-
-@dataclass(frozen=True)
-class NeatError(NeatIssue, ABC):
-    def dump(self) -> dict[str, Any]:
-        return {"errorType": type(self).__name__}
-
-    def as_exception(self) -> ValueError:
-        return ValueError(self.message())
-
-    def as_pydantic_exception(self) -> PydanticCustomError:
-        return PydanticCustomError(
-            self.__class__.__name__,
-            self.message(),
-            dict(description=self.description, fix=self.fix),
-        )
-
-
-@dataclass(frozen=True)
-class NeatWarning(NeatIssue, ABC, UserWarning):
-    def dump(self) -> dict[str, Any]:
-        return {"warningType": type(self).__name__}
-
-    @classmethod
-    def from_warning(cls, warning: WarningMessage) -> "NeatWarning":
-        return DefaultWarning.from_warning_message(warning)
-
-
-@dataclass(frozen=True)
-class DefaultWarning(NeatWarning):
-    description = "A warning was raised during validation."
-    fix = "No fix is available."
-
-    warning: str | Warning
-    category: type[Warning]
-    source: str | None = None
-
-    def dump(self) -> dict[str, Any]:
-        output = super().dump()
-        output["msg"] = str(self.warning)
-        output["category"] = self.category.__name__
-        output["source"] = self.source
-        return output
-
-    @classmethod
-    def from_warning_message(cls, warning: WarningMessage) -> NeatWarning:
-        if isinstance(warning.message, NeatWarning):
-            return warning.message
-
-        return cls(
-            warning=warning.message,
-            category=warning.category,
-            source=warning.source,
-        )
-
-    def message(self) -> str:
-        return str(self.warning)
-
-
-T_NeatIssue = TypeVar("T_NeatIssue", bound=NeatIssue)
-
-
-class NeatIssueList(UserList[T_NeatIssue], ABC):
-    def __init__(self, issues: Sequence[T_NeatIssue] | None = None, title: str | None = None):
-        super().__init__(issues or [])
-        self.title = title
-
-    @property
-    def errors(self) -> Self:
-        return type(self)([issue for issue in self if isinstance(issue, NeatError)])  # type: ignore[misc]
-
-    @property
-    def has_errors(self) -> bool:
-        return any(isinstance(issue, NeatError) for issue in self)
-
-    @property
-    def warnings(self) -> Self:
-        return type(self)([issue for issue in self if isinstance(issue, NeatWarning)])  # type: ignore[misc]
-
-    def as_errors(self) -> ExceptionGroup:
-        return ExceptionGroup(
-            "Operation failed",
-            [ValueError(issue.message()) for issue in self if isinstance(issue, NeatError)],
-        )
-
-    def trigger_warnings(self) -> None:
-        for warning in [issue for issue in self if isinstance(issue, NeatWarning)]:
-            warnings.warn(warning, stacklevel=2)
-
-    def to_pandas(self) -> pd.DataFrame:
-        return pd.DataFrame([issue.dump() for issue in self])
-
-    def _repr_html_(self) -> str | None:
-        return self.to_pandas()._repr_html_()  # type: ignore[operator]
-
-    def as_exception(self) -> "MultiValueError":
-        return MultiValueError(self.errors)
-
-
-class MultiValueError(ValueError):
-    """This is a container for multiple errors.
-
-    It is used in the pydantic field_validator/model_validator to collect multiple errors, which
-    can then be caught in a try-except block and returned as an IssueList.
-
-    """
-
-    def __init__(self, errors: Sequence[T_NeatIssue]):
-        self.errors = list(errors)

cognite/neat/rules/importers/_owl2rules/_owl2classes.py

@@ -1,215 +0,0 @@
-from typing import cast
-
-import numpy as np
-import pandas as pd
-from rdflib import OWL, Graph
-
-from cognite.neat.rules.models._base import MatchType
-from cognite.neat.utils.rdf_ import remove_namespace_from_uri
-
-
-def parse_owl_classes(graph: Graph, language: str = "en") -> list[dict]:
-    """Parse owl classes from graph to pandas dataframe.
-
-    Args:
-        graph: Graph containing owl classes
-        language: Language to use for parsing, by default "en"
-
-    Returns:
-        Dataframe containing owl classes
-
-    !!! note "Compliant OWL classes"
-        This makes the method very opinionated, but results in a compliant classes.
-    """
-
-    query = """
-        SELECT ?class ?name ?description ?parentClass ?reference ?match ?comment
-        WHERE {
-        ?class a owl:Class .
-        OPTIONAL {?class rdfs:subClassOf ?parentClass }.
-        OPTIONAL {?class rdfs:label ?name }.
-        OPTIONAL {?class rdfs:comment ?description} .
-        FILTER (!isBlank(?class))
-        FILTER (!bound(?parentClass) || !isBlank(?parentClass))
-        FILTER (!bound(?name) || LANG(?name) = "" || LANGMATCHES(LANG(?name), "en"))
-        FILTER (!bound(?description) || LANG(?description) = "" || LANGMATCHES(LANG(?description), "en"))
-    }
-    """
-
-    # create raw dataframe
-
-    raw_df = _parse_raw_dataframe(cast(list[tuple], list(graph.query(query.replace("en", language)))))
-    if raw_df.empty:
-        return []
-
-    # group values and clean up
-    processed_df = _clean_up_classes(raw_df)
-
-    # make compliant
-    processed_df = make_classes_compliant(processed_df)
-
-    # Make Parent Class list elements into string joined with comma
-    processed_df["Parent Class"] = processed_df["Parent Class"].apply(
-        lambda x: ", ".join(x) if isinstance(x, list) and x else None
-    )
-
-    return processed_df.dropna(axis=0, how="all").replace(float("nan"), None).to_dict(orient="records")
-
-
-def _parse_raw_dataframe(query_results: list[tuple]) -> pd.DataFrame:
-    df = pd.DataFrame(
-        query_results,
-        columns=["Class", "Name", "Description", "Parent Class", "Reference", "Match", "Comment"],
-    )
-    if df.empty:
-        return df
-
-    # # remove NaNs
-    df.replace(np.nan, "", regex=True, inplace=True)
-
-    df.Reference = df.Class
-    df.Class = df.Class.apply(lambda x: remove_namespace_from_uri(x))
-    df["Match Type"] = len(df) * [MatchType.exact]
-    df["Comment"] = len(df) * [None]
-    df["Parent Class"] = df["Parent Class"].apply(lambda x: remove_namespace_from_uri(x))
-
-    return df
-
-
-def _clean_up_classes(df: pd.DataFrame) -> pd.DataFrame:
-    clean_list = [
-        {
-            "Class": class_,
-            "Name": group_df["Name"].unique()[0],
-            "Description": "\n".join(list(group_df.Description.unique())),
-            "Parent Class": ", ".join(list(group_df["Parent Class"].unique())),
-            "Reference": group_df["Reference"].unique()[0],
-            "Match Type": group_df["Match Type"].unique()[0],
-            "Comment": group_df["Comment"].unique()[0],
-        }
-        for class_, group_df in df.groupby("Class")
-    ]
-
-    df = pd.DataFrame(clean_list)
-
-    # bring NaNs back
-    df.replace("", None, inplace=True)
-
-    # split Parent Class column back into list
-    df["Parent Class"] = df["Parent Class"].apply(lambda x: x.split(", ") if isinstance(x, str) else None)
-
-    return df
-
-
-def make_classes_compliant(classes: pd.DataFrame) -> pd.DataFrame:
-    """Make classes compliant.
-
-    Returns:
-        Dataframe containing compliant classes
-
-    !!! note "About the compliant classes"
-        The compliant classes are based on the OWL base ontology, but adapted to NEAT and use in CDF.
-        One thing to note is that this method would not be able to fix issues with class ids which
-        are not compliant with the CDF naming convention. For example, if a class id contains a space,
-        starts with a number, etc. This will cause issues when trying to create the class in CDF.
-    """
-
-    # Replace empty or non-string values in "Match" column with "exact"
-    classes["Match Type"] = classes["Match Type"].fillna(MatchType.exact)
-    classes["Match Type"] = classes["Match Type"].apply(
-        lambda x: MatchType.exact if not isinstance(x, str) or len(x) == 0 else x
-    )
-
-    # Replace empty or non-string values in "Comment" column with a default value
-    classes["Comment"] = classes["Comment"].fillna("Imported from Ontology by NEAT")
-    classes["Comment"] = classes["Comment"].apply(
-        lambda x: "Imported from Ontology by NEAT" if not isinstance(x, str) or len(x) == 0 else x
-    )
-
-    # Add _object_property_class, _data_type_property_class, _thing_class to the dataframe
-    classes = pd.concat(
-        [classes, pd.DataFrame([_object_property_class(), _data_type_property_class(), _thing_class()])],
-        ignore_index=True,
-    )
-
-    # Reduce length of elements in the "Description" column to 1024 characters
-    classes["Description"] = classes["Description"].apply(lambda x: x[:1024] if isinstance(x, str) else None)
-
-    # Add missing parent classes to the dataframe
-    classes = pd.concat(
-        [classes, pd.DataFrame(_add_parent_class(classes))],
-        ignore_index=True,
-    )
-
-    return classes
-
-
-def _object_property_class() -> dict:
-    return {
-        "Class": "ObjectProperty",
-        "Name": None,
-        "Description": "The class of object properties.",
-        "Parent Class": None,
-        "Reference": OWL.ObjectProperty,
-        "Match Type": MatchType.exact,
-        "Comment": "Added by NEAT based on owl:ObjectProperty but adapted to NEAT and use in CDF.",
-    }
-
-
-def _data_type_property_class() -> dict:
-    return {
-        "Class": "DatatypeProperty",
-        "Name": None,
-        "Description": "The class of data properties.",
-        "Parent Class": None,
-        "Reference": OWL.DatatypeProperty,
-        "Match Type": MatchType.exact,
-        "Comment": "Added by NEAT based on owl:DatatypeProperty but adapted to NEAT and use in CDF.",
-    }
-
-
-def _thing_class() -> dict:
-    return {
-        "Class": "Thing",
-        "Name": None,
-        "Description": "The class of holding class individuals.",
-        "Parent Class": None,
-        "Reference": OWL.Thing,
-        "Match Type": MatchType.exact,
-        "Comment": (
-            "Added by NEAT. "
-            "Imported from OWL base ontology, it is meant for use as a default"
-            " value type for object properties which miss a declared range."
-        ),
-    }
-
-
-def _add_parent_class(df: pd.DataFrame) -> list[dict]:
-    parent_set = {
-        item
-        for sublist in df["Parent Class"].tolist()
-        if sublist
-        for item in sublist
-        if item != "" and item is not None
-    }
-    class_set = set(df["Class"].tolist())
-
-    rows = []
-    for missing_parent_class in parent_set.difference(class_set):
-        rows += [
-            {
-                "Class": missing_parent_class,
-                "Name": None,
-                "Description": None,
-                "Parent Class": None,
-                "Reference": None,
-                "Match Type": None,
-                "Comment": (
-                    "Added by NEAT. "
-                    "This is a parent class that is missing in the ontology. "
-                    "It is added by NEAT to make the ontology compliant with CDF."
-                ),
-            }
-        ]
-
-    return rows