cognite-neat 0.87.0__py3-none-any.whl → 0.87.3__py3-none-any.whl

cognite/neat/rules/issues/spreadsheet.py

@@ -295,6 +295,41 @@ class ClassNoPropertiesNoParentError(NeatValidationError):
         return f"Class {self.classes[0]} have no direct or inherited properties. This may be a mistake."
 
 
+@dataclass(frozen=True)
+class AssetRulesHaveCircularDependencyError(NeatValidationError):
+    description = "Asset rules have circular dependencies."
+    fix = "Linking between classes via property that maps to parent_external_id must yield hierarchy structure."
+
+    classes: list[str]
+
+    def dump(self) -> dict[str, list[tuple[str, str]]]:
+        output = super().dump()
+        output["classes"] = self.classes
+        return output
+
+    def message(self) -> str:
+        return f"Asset rules have circular dependencies between classes {', '.join(self.classes)}."
+
+
+@dataclass(frozen=True)
+class AssetParentPropertyPointsToDataValueTypeError(NeatValidationError):
+    description = "Parent property points to a data value type instead of a class."
+    fix = "Make sure that the parent property points to a class."
+
+    class_property_with_data_value_type: list[tuple[str, str]]
+
+    def dump(self) -> dict[str, list[tuple[str, str]]]:
+        output = super().dump()
+        output["class_property"] = self.class_property_with_data_value_type
+        return output
+
+    def message(self) -> str:
+        text = [
+            f"class {class_} property {property_}" for class_, property_ in self.class_property_with_data_value_type
+        ]
+        return f"Following  {', and'.join(text)} point to data value type instead to classes. This is a mistake."
+
+
 @dataclass(frozen=True)
 class ParentClassesNotDefinedError(NeatValidationError):
     description = "Parent classes are not defined."

cognite/neat/rules/models/_rdfpath.py

@@ -232,21 +232,12 @@ class SingleProperty(Traversal):
         return f"{self.class_}({self.property})"
 
 
-class AllReferences(Traversal):
+class SelfReferenceProperty(Traversal):
     @classmethod
     def from_string(cls, class_: str) -> Self:
         return cls(class_=Entity.from_string(class_))
 
 
-class AllProperties(Traversal):
-    @classmethod
-    def from_string(cls, class_: str) -> Self:
-        return cls(class_=Entity.from_string(class_))
-
-    def __str__(self) -> str:
-        return f"{self.class_}(*)"
-
-
 class Origin(BaseModel):
     class_: Entity
 
@@ -290,7 +281,7 @@ class Query(BaseModel):
 
 
 class RDFPath(Rule):
-    traversal: SingleProperty | AllProperties | AllReferences | Hop
+    traversal: SingleProperty | SelfReferenceProperty | Hop
 
     def __str__(self) -> str:
         return f"{self.traversal}"
@@ -311,14 +302,13 @@ class SPARQLQuery(RDFPath):
     traversal: Query
 
 
-def parse_traversal(raw: str) -> AllReferences | AllProperties | SingleProperty | Hop:
+def parse_traversal(raw: str) -> SelfReferenceProperty | SingleProperty | Hop:
     if result := CLASS_ID_REGEX_COMPILED.match(raw):
-        return AllReferences.from_string(class_=result.group(EntityTypes.class_))
-    elif result := ALL_PROPERTIES_REGEX_COMPILED.match(raw):
-        return AllProperties.from_string(class_=result.group(EntityTypes.class_))
+        return SelfReferenceProperty.from_string(class_=result.group(EntityTypes.class_))
     elif result := SINGLE_PROPERTY_REGEX_COMPILED.match(raw):
         return SingleProperty.from_string(
-            class_=result.group(EntityTypes.class_), property_=result.group(EntityTypes.property_)
+            class_=result.group(EntityTypes.class_),
+            property_=result.group(EntityTypes.property_),
         )
     elif result := HOP_REGEX_COMPILED.match(raw):
         return Hop.from_string(class_=result.group("origin"), traversal=result.group(_traversal))
@@ -329,7 +319,9 @@ def parse_traversal(raw: str) -> AllReferences | AllProperties | SingleProperty
 def parse_table_lookup(raw: str) -> TableLookup:
     if result := TABLE_REGEX_COMPILED.match(raw):
         return TableLookup(
-            name=result.group(Lookup.table), key=result.group(Lookup.key), value=result.group(Lookup.value)
+            name=result.group(Lookup.table),
+            key=result.group(Lookup.key),
+            value=result.group(Lookup.value),
         )
     raise exceptions.NotValidTableLookUp(raw).to_pydantic_custom_error()
 
@@ -344,7 +336,10 @@ def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPa
             if Counter(rule_raw).get("|") != 1:
                 raise exceptions.NotValidRAWLookUp(rule_raw).to_pydantic_custom_error()
             traversal, table_lookup = rule_raw.split("|")
-            return RawLookup(traversal=parse_traversal(traversal), table=parse_table_lookup(table_lookup))
+            return RawLookup(
+                traversal=parse_traversal(traversal),
+                table=parse_table_lookup(table_lookup),
+            )
         case TransformationRuleType.sparql:
             return SPARQLQuery(traversal=Query(query=rule_raw))
         case None:
@@ -352,9 +347,10 @@ def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPa
 
 
 def is_valid_rule(rule_type: TransformationRuleType, rule_raw: str) -> bool:
-    is_valid_rule = {TransformationRuleType.rdfpath: is_rdfpath, TransformationRuleType.rawlookup: is_rawlookup}[
-        rule_type
-    ]
+    is_valid_rule = {
+        TransformationRuleType.rdfpath: is_rdfpath,
+        TransformationRuleType.rawlookup: is_rawlookup,
+    }[rule_type]
     return is_valid_rule(rule_raw)
 
 

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

@@ -1,4 +1,41 @@
+from graphlib import CycleError
+from typing import cast
+
+from cognite.neat.rules import issues
+from cognite.neat.rules.issues.base import IssueList
+from cognite.neat.rules.models._base import SheetList
+from cognite.neat.rules.models.asset._rules import AssetProperty, AssetRules
+from cognite.neat.rules.models.entities import AssetEntity, AssetFields, ClassEntity
 from cognite.neat.rules.models.information._validation import InformationPostValidation
 
 
-class AssetPostValidation(InformationPostValidation): ...
+class AssetPostValidation(InformationPostValidation):
+    def validate(self) -> IssueList:
+        self.issue_list = super().validate()
+        self._parent_property_point_to_class()
+        self._circular_dependency()
+        return self.issue_list
+
+    def _parent_property_point_to_class(self) -> None:
+        class_property_with_data_value_type = []
+        for property_ in cast(SheetList[AssetProperty], self.properties):
+            for implementation in property_.implementation:
+                if (
+                    isinstance(implementation, AssetEntity)
+                    and implementation.property_ == AssetFields.parentExternalId
+                    and not isinstance(property_.value_type, ClassEntity)
+                ):
+                    class_property_with_data_value_type.append((property_.class_.suffix, property_.property_))
+
+        if class_property_with_data_value_type:
+            self.issue_list.append(
+                issues.spreadsheet.AssetParentPropertyPointsToDataValueTypeError(class_property_with_data_value_type)
+            )
+
+    def _circular_dependency(self) -> None:
+        from cognite.neat.rules.analysis import AssetAnalysis
+
+        try:
+            _ = AssetAnalysis(cast(AssetRules, self.rules)).class_topological_sort()
+        except CycleError as error:
+            self.issue_list.append(issues.spreadsheet.AssetRulesHaveCircularDependencyError(error.args[1]))

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

@@ -5,6 +5,7 @@ from typing import Any, cast
 
 from cognite.client.data_classes import data_modeling as dm
 from cognite.client.data_classes.data_modeling.containers import BTreeIndex
+from cognite.client.data_classes.data_modeling.data_types import ListablePropertyType
 from cognite.client.data_classes.data_modeling.views import (
     SingleEdgeConnectionApply,
     SingleReverseDirectRelationApply,
@@ -23,7 +24,7 @@ from cognite.neat.rules.models.entities import (
     ViewPropertyEntity,
 )
 from cognite.neat.rules.models.wrapped_entities import DMSFilter, HasDataFilter, NodeTypeFilter
-from cognite.neat.utils.cdf_classes import ContainerApplyDict, NodeApplyDict, SpaceApplyDict, ViewApplyDict
+from cognite.neat.utils.cdf.data_classes import ContainerApplyDict, NodeApplyDict, SpaceApplyDict, ViewApplyDict
 
 from ._rules import DMSMetadata, DMSProperty, DMSRules, DMSView
 from ._schema import DMSSchema, PipelineSchema
@@ -282,8 +283,11 @@ class _DMSExporter:
                     type_cls = prop.value_type.dms
                 else:
                     type_cls = dm.DirectRelation
-
-                type_ = type_cls(is_list=prop.is_list or False)
+                type_: dm.PropertyType
+                if issubclass(type_cls, ListablePropertyType):
+                    type_ = type_cls(is_list=prop.is_list or False)
+                else:
+                    type_ = type_cls()
                 container.properties[prop.container_property] = dm.ContainerProperty(
                     type=type_,
                     nullable=prop.nullable if prop.nullable is not None else True,

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

@@ -42,17 +42,18 @@ from cognite.neat.rules.issues.dms import (
     MissingViewInModelWarning,
 )
 from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE
-from cognite.neat.utils.cdf_classes import (
+from cognite.neat.utils.cdf.data_classes import (
     CogniteResourceDict,
     ContainerApplyDict,
     NodeApplyDict,
+    RawTableWrite,
+    RawTableWriteList,
     SpaceApplyDict,
     ViewApplyDict,
 )
-from cognite.neat.utils.cdf_loaders import ViewLoader
-from cognite.neat.utils.cdf_loaders.data_classes import RawTableWrite, RawTableWriteList
+from cognite.neat.utils.cdf.loaders import ViewLoader
+from cognite.neat.utils.rdf_ import get_inheritance_path
 from cognite.neat.utils.text import to_camel
-from cognite.neat.utils.utils import get_inheritance_path
 
 if sys.version_info >= (3, 11):
     from typing import Self

cognite/neat/rules/models/entities.py

@@ -4,7 +4,13 @@ from abc import ABC, abstractmethod
 from functools import total_ordering
 from typing import Annotated, Any, ClassVar, Generic, TypeVar, cast
 
-from cognite.client.data_classes.data_modeling.ids import ContainerId, DataModelId, NodeId, PropertyId, ViewId
+from cognite.client.data_classes.data_modeling.ids import (
+    ContainerId,
+    DataModelId,
+    NodeId,
+    PropertyId,
+    ViewId,
+)
 from pydantic import (
     AnyHttpUrl,
     BaseModel,
@@ -16,7 +22,7 @@ from pydantic import (
 )
 
 from cognite.neat.rules.models.data_types import DataType
-from cognite.neat.utils.utils import replace_non_alphanumeric_with_underscore
+from cognite.neat.utils.text import replace_non_alphanumeric_with_underscore
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -263,9 +269,9 @@ class UnknownEntity(ClassEntity):
 
 
 class AssetFields(StrEnum):
-    external_id = "external_id"
+    externalId = "externalId"
     name = "name"
-    parent_external_id = "parent_external_id"
+    parentExternalId = "parentExternalId"
     description = "description"
     metadata = "metadata"
 
@@ -331,7 +337,8 @@ class MultiValueTypeInfo(BaseModel):
         else:
             return {
                 "types": [
-                    DataType.load(type_) if DataType.is_data_type(type_) else ClassEntity.load(type_) for type_ in types
+                    (DataType.load(type_) if DataType.is_data_type(type_) else ClassEntity.load(type_))
+                    for type_ in types
                 ]
             }
 
@@ -447,7 +454,10 @@ class ViewPropertyEntity(DMSVersionedEntity[PropertyId]):
     property_: str = Field(alias="property")
 
     def as_id(self) -> PropertyId:
-        return PropertyId(source=ViewId(self.space, self.external_id, self.version), property=self.property_)
+        return PropertyId(
+            source=ViewId(self.space, self.external_id, self.version),
+            property=self.property_,
+        )
 
     def as_view_id(self) -> ViewId:
         return ViewId(space=self.space, external_id=self.external_id, version=self.version)
@@ -459,7 +469,10 @@ class ViewPropertyEntity(DMSVersionedEntity[PropertyId]):
         if id.source.version is None:
             raise ValueError("Version must be specified")
         return cls(
-            space=id.source.space, externalId=id.source.external_id, version=id.source.version, property=id.property
+            space=id.source.space,
+            externalId=id.source.external_id,
+            version=id.source.version,
+            property=id.property,
         )
 
 
@@ -495,7 +508,12 @@ class ReferenceEntity(ClassEntity):
     @classmethod
     def from_entity(cls, entity: Entity, property_: str) -> "ReferenceEntity":
         if isinstance(entity, ClassEntity):
-            return cls(prefix=str(entity.prefix), suffix=entity.suffix, version=entity.version, property=property_)
+            return cls(
+                prefix=str(entity.prefix),
+                suffix=entity.suffix,
+                version=entity.version,
+                property=property_,
+            )
         else:
             return cls(prefix=str(entity.prefix), suffix=entity.suffix, property=property_)
 

cognite/neat/rules/models/information/_validation.py

@@ -6,7 +6,7 @@ from cognite.neat.rules import issues
 from cognite.neat.rules.issues import IssueList
 from cognite.neat.rules.models._base import DataModelType, SchemaCompleteness
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes, UnknownEntity
-from cognite.neat.utils.utils import get_inheritance_path
+from cognite.neat.utils.rdf_ import get_inheritance_path
 
 from ._rules import InformationRules
 

cognite/neat/utils/__init__.py

@@ -1,3 +0,0 @@
-from .utils import remove_namespace_from_uri
-
-__all__ = ["remove_namespace_from_uri"]

cognite/neat/utils/auth.py

@@ -5,13 +5,13 @@ from dataclasses import dataclass, fields
 from pathlib import Path
 from typing import Literal, TypeAlias, get_args
 
-from cognite.client import CogniteClient
+from cognite.client import ClientConfig, CogniteClient
 from cognite.client.credentials import CredentialProvider, OAuthClientCredentials, OAuthInteractive, Token
 
 from cognite.neat import _version
 from cognite.neat.utils.auxiliary import local_import
 
-__all__ = ["get_cognite_client"]
+__all__ = ["get_cognite_client", "EnvironmentVariables"]
 
 _LOGIN_FLOW: TypeAlias = Literal["infer", "client_credentials", "interactive", "token"]
 _VALID_LOGIN_FLOWS = get_args(_LOGIN_FLOW)
@@ -22,7 +22,7 @@ def get_cognite_client(env_file_name: str = ".env") -> CogniteClient:
     if not env_file_name.endswith(".env"):
         raise ValueError("env_file_name must end with '.env'")
     with suppress(KeyError):
-        variables = _EnvironmentVariables.create_from_environ()
+        variables = EnvironmentVariables.create_from_environ()
         return variables.get_client()
 
     repo_root = _repo_root()
@@ -51,7 +51,7 @@ def get_cognite_client(env_file_name: str = ".env") -> CogniteClient:
 
 
 @dataclass
-class _EnvironmentVariables:
+class EnvironmentVariables:
     CDF_CLUSTER: str
     CDF_PROJECT: str
     LOGIN_FLOW: _LOGIN_FLOW = "infer"
@@ -66,10 +66,17 @@ class _EnvironmentVariables:
     IDP_AUDIENCE: str | None = None
     IDP_SCOPES: str | None = None
     IDP_AUTHORITY_URL: str | None = None
+    CDF_MAX_WORKERS: int | None = None
+    CDF_TIMEOUT: int | None = None
+    CDF_REDIRECT_PORT: int = 53_000
 
     def __post_init__(self):
         if self.LOGIN_FLOW.lower() not in _VALID_LOGIN_FLOWS:
             raise ValueError(f"LOGIN_FLOW must be one of {_VALID_LOGIN_FLOWS}")
+        if self.IDP_TOKEN_URL and not self.IDP_TENANT_ID:
+            prefix, suffix = "https://login.microsoftonline.com/", "/oauth2/v2.0/token"
+            if self.IDP_TOKEN_URL.startswith(prefix) and self.IDP_TOKEN_URL.endswith(suffix):
+                self.IDP_TENANT_ID = self.IDP_TOKEN_URL.removeprefix(prefix).removesuffix(suffix)
 
     @property
     def cdf_url(self) -> str:
@@ -102,7 +109,7 @@ class _EnvironmentVariables:
         return f"https://login.microsoftonline.com/{self.IDP_TENANT_ID}"
 
     @classmethod
-    def create_from_environ(cls) -> "_EnvironmentVariables":
+    def create_from_environ(cls) -> "EnvironmentVariables":
         if "CDF_CLUSTER" not in os.environ or "CDF_PROJECT" not in os.environ:
             raise KeyError("CDF_CLUSTER and CDF_PROJECT must be set in the environment.", "CDF_CLUSTER", "CDF_PROJECT")
 
@@ -119,6 +126,25 @@ class _EnvironmentVariables:
             IDP_AUDIENCE=os.environ.get("IDP_AUDIENCE"),
             IDP_SCOPES=os.environ.get("IDP_SCOPES"),
             IDP_AUTHORITY_URL=os.environ.get("IDP_AUTHORITY_URL"),
+            CDF_MAX_WORKERS=int(os.environ["CDF_MAX_WORKERS"]) if "CDF_MAX_WORKERS" in os.environ else None,
+            CDF_TIMEOUT=int(os.environ["CDF_TIMEOUT"]) if "CDF_TIMEOUT" in os.environ else None,
+            CDF_REDIRECT_PORT=int(os.environ.get("CDF_REDIRECT_PORT", 53_000)),
+        )
+
+    @classmethod
+    def default(cls) -> "EnvironmentVariables":
+        # This method is for backwards compatibility with the old config
+        # It is not recommended to use this method.
+        return cls(
+            LOGIN_FLOW="client_credentials",
+            CDF_CLUSTER="api",
+            CDF_PROJECT="dev",
+            IDP_TENANT_ID="common",
+            IDP_CLIENT_ID="neat",
+            IDP_CLIENT_SECRET="secret",
+            IDP_SCOPES="project:read,project:write",
+            CDF_TIMEOUT=60,
+            CDF_MAX_WORKERS=3,
         )
 
     def get_credentials(self) -> CredentialProvider:
@@ -161,7 +187,7 @@ class _EnvironmentVariables:
         return OAuthInteractive(
             client_id=self.IDP_CLIENT_ID,
             authority_url=self.idp_authority_url,
-            redirect_port=53_000,
+            redirect_port=self.CDF_REDIRECT_PORT,
             scopes=self.idp_scopes,
         )
 
@@ -171,9 +197,15 @@ class _EnvironmentVariables:
         return Token(self.TOKEN)
 
     def get_client(self) -> CogniteClient:
-        return CogniteClient.default(
-            self.CDF_PROJECT, self.CDF_CLUSTER, credentials=self.get_credentials(), client_name=_CLIENT_NAME
+        config = ClientConfig(
+            client_name=_CLIENT_NAME,
+            project=self.CDF_PROJECT,
+            credentials=self.get_credentials(),
+            base_url=self.cdf_url,
+            max_workers=self.CDF_MAX_WORKERS,
+            timeout=self.CDF_TIMEOUT,
         )
+        return CogniteClient(config)
 
     def create_env_file(self) -> str:
         lines: list[str] = []
@@ -194,11 +226,11 @@ class _EnvironmentVariables:
         return "\n".join(lines)
 
 
-def _from_dotenv(evn_file: Path) -> _EnvironmentVariables:
+def _from_dotenv(evn_file: Path) -> EnvironmentVariables:
     if not evn_file.exists():
         raise FileNotFoundError(f"{evn_file} does not exist.")
     content = evn_file.read_text()
-    valid_variables = {f.name for f in fields(_EnvironmentVariables)}
+    valid_variables = {f.name for f in fields(EnvironmentVariables)}
     variables: dict[str, str] = {}
     for line in content.splitlines():
         if line.startswith("#") or "=" not in line:
@@ -206,15 +238,15 @@ def _from_dotenv(evn_file: Path) -> _EnvironmentVariables:
         key, value = line.split("=", 1)
         if key in valid_variables:
             variables[key] = value
-    return _EnvironmentVariables(**variables)  # type: ignore[arg-type]
+    return EnvironmentVariables(**variables)  # type: ignore[arg-type]
 
 
-def _prompt_user() -> _EnvironmentVariables:
+def _prompt_user() -> EnvironmentVariables:
     local_import("rich", "jupyter")
     from rich.prompt import Prompt
 
     try:
-        variables = _EnvironmentVariables.create_from_environ()
+        variables = EnvironmentVariables.create_from_environ()
         continue_ = Prompt.ask(
             f"Use environment variables for CDF Cluster '{variables.CDF_CLUSTER}' "
             f"and Project '{variables.CDF_PROJECT}'? [y/n]",
@@ -263,25 +295,12 @@ def _prompt_user() -> _EnvironmentVariables:
     return variables
 
 
-def _prompt_cluster_and_project() -> _EnvironmentVariables:
+def _prompt_cluster_and_project() -> EnvironmentVariables:
     from rich.prompt import Prompt
 
     cluster = Prompt.ask("Enter CDF Cluster (example 'greenfield', 'bluefield', 'westeurope-1)")
     project = Prompt.ask("Enter CDF Project")
-    return _EnvironmentVariables(cluster, project)
-
-
-def _is_notebook() -> bool:
-    try:
-        shell = get_ipython().__class__.__name__  # type: ignore[name-defined]
-        if shell == "ZMQInteractiveShell":
-            return True  # Jupyter notebook or qtconsole
-        elif shell == "TerminalInteractiveShell":
-            return False  # Terminal running IPython
-        else:
-            return False  # Other type (?)
-    except NameError:
-        return False  # Probably standard Python interpreter
+    return EnvironmentVariables(cluster, project)
 
 
 def _repo_root() -> Path | None:

cognite/neat/utils/auxiliary.py

@@ -1,8 +1,16 @@
+import hashlib
 import importlib
 import inspect
-from collections.abc import Callable
+import logging
+import time
+from collections.abc import Callable, Iterable
+from datetime import datetime
+from functools import wraps
 from types import ModuleType
 
+from cognite.client.exceptions import CogniteDuplicatedError, CogniteReadTimeout
+from pydantic_core import ErrorDetails
+
 from cognite.neat.exceptions import NeatImportError
 
 
@@ -33,3 +41,135 @@ def class_html_doc(cls: type, include_factory_methods: bool = True) -> str:
                 f'<ul style="list-style-type:circle;">{factory_methods_str}</ul>'
             )
     return f"<h3>{cls.__name__}</h3><p>{docstring}</p>"
+
+
+def retry_decorator(max_retries=2, retry_delay=3, component_name=""):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            previous_exception = None
+            for attempt in range(max_retries + 1):
+                try:
+                    logging.debug(f"Attempt {attempt + 1} of {max_retries + 1} for {component_name}")
+                    return func(*args, **kwargs)
+                except CogniteReadTimeout as e:
+                    previous_exception = e
+                    if attempt < max_retries:
+                        logging.error(
+                            f"""CogniteReadTimeout retry attempt {attempt + 1} failed for {component_name} .
+                            Retrying in {retry_delay} second(s). Error:"""
+                        )
+                        logging.error(e)
+                        time.sleep(retry_delay)
+                    else:
+                        raise e
+                except CogniteDuplicatedError as e:
+                    if isinstance(previous_exception, CogniteReadTimeout):
+                        # if previous exception was CogniteReadTimeout,
+                        # we can't be sure if the items were created or not
+                        if len(e.successful) == 0 and len(e.failed) == 0 and len(e.duplicated) >= 0:
+                            logging.warning(
+                                f"Duplicate error for {component_name} . All items already exist in CDF. "
+                                "Suppressing error."
+                            )
+                            return
+                        else:
+                            # can happend because of eventual consistency. Retry with delay to allow for CDF to catch up
+                            if attempt < max_retries:
+                                logging.error(
+                                    f"""CogniteDuplicatedError retry attempt {attempt + 1} failed for {component_name} .
+                                      Retrying in {retry_delay} second(s). Error:"""
+                                )
+                                logging.error(e)
+                                # incerasing delay to allow for CDF to catch up
+                                time.sleep(retry_delay)
+                            else:
+                                raise e
+                    else:
+                        # no point in retrying duplicate error if previous exception was not a timeout
+                        raise e
+
+                except Exception as e:
+                    previous_exception = e
+                    if attempt < max_retries:
+                        logging.error(
+                            f"Retry attempt {attempt + 1} failed for {component_name}. "
+                            f"Retrying in {retry_delay} second(s)."
+                        )
+                        logging.error(e)
+                        time.sleep(retry_delay)
+                    else:
+                        raise e
+
+        return wrapper
+
+    return decorator
+
+
+def create_sha256_hash(string: str) -> str:
+    # Create a SHA-256 hash object
+    sha256_hash = hashlib.sha256()
+
+    # Convert the string to bytes and update the hash object
+    sha256_hash.update(string.encode("utf-8"))
+
+    # Get the hexadecimal representation of the hash
+    hash_value = sha256_hash.hexdigest()
+
+    return hash_value
+
+
+# Will likely be removed with legacy code
+def generate_exception_report(exceptions: list[dict] | list[ErrorDetails] | None, category: str = "") -> str:
+    exceptions_as_dict = _order_expectations_by_type(exceptions) if exceptions else {}
+    report = ""
+
+    for exception_type in exceptions_as_dict.keys():
+        title = f"# {category}: {exception_type}" if category else ""
+        warnings = "\n- " + "\n- ".join(exceptions_as_dict[exception_type])
+        report += title + warnings + "\n\n"
+
+    return report
+
+
+def _order_expectations_by_type(
+    exceptions: list[dict] | list[ErrorDetails],
+) -> dict[str, list[str]]:
+    exception_dict: dict[str, list[str]] = {}
+    for exception in exceptions:
+        if not isinstance(exception["loc"], str) and isinstance(exception["loc"], Iterable):
+            location = f"[{'/'.join(str(e) for e in exception['loc'])}]"
+        else:
+            location = ""
+
+        issue = f"{exception['msg']} {location}"
+
+        if exception_dict.get(exception["type"]) is None:
+            exception_dict[exception["type"]] = [issue]
+        else:
+            exception_dict[exception["type"]].append(issue)
+    return exception_dict
+
+
+def string_to_ideal_type(input_string: str) -> int | bool | float | datetime | str:
+    try:
+        # Try converting to int
+        return int(input_string)
+    except ValueError:
+        try:
+            # Try converting to float
+            return float(input_string)  # type: ignore
+        except ValueError:
+            if input_string.lower() == "true":
+                # Return True if input is 'true'
+                return True
+            elif input_string.lower() == "false":
+                # Return False if input is 'false'
+                return False
+            else:
+                try:
+                    # Try converting to datetime
+                    return datetime.fromisoformat(input_string)  # type: ignore
+                except ValueError:
+                    # Return the input string if no conversion is possible
+                    return input_string