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

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/domain.py

@@ -5,7 +5,7 @@ from pydantic import Field, field_serializer, field_validator, model_serializer
 from pydantic_core.core_schema import SerializationInfo
 
 from cognite.neat.rules.models.data_types import DataType
-from cognite.neat.rules.models.entities import ClassEntity, ParentEntityList
+from cognite.neat.rules.models.entities import ClassEntity, ClassEntityList
 
 from ._base import (
     BaseMetadata,
@@ -24,6 +24,9 @@ class DomainMetadata(BaseMetadata):
     def as_identifier(self) -> str:
         return "DomainRules"
 
+    def get_prefix(self) -> str:
+        return "domain"
+
 
 class DomainProperty(SheetEntity):
     class_: ClassEntity = Field(alias="Class")
@@ -51,7 +54,7 @@ class DomainClass(SheetEntity):
     class_: ClassEntity = Field(alias="Class")
     name: str | None = Field(alias="Name", default=None)
     description: str | None = Field(None, alias="Description")
-    parent: ParentEntityList | None = Field(alias="Parent Class")
+    parent: ClassEntityList | None = Field(alias="Parent Class")
 
 
 class DomainRules(BaseRules):

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
@@ -252,13 +258,6 @@ class ClassEntity(Entity):
         return ContainerEntity(space=space, externalId=str(self.suffix))
 
 
-class ParentClassEntity(ClassEntity):
-    type_: ClassVar[EntityTypes] = EntityTypes.parent_class
-
-    def as_class_entity(self) -> ClassEntity:
-        return ClassEntity(prefix=self.prefix, suffix=self.suffix, version=self.version)
-
-
 class UnknownEntity(ClassEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.undefined
     prefix: _UndefinedType = Undefined
@@ -270,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"
 
@@ -338,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
                 ]
             }
 
@@ -454,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)
@@ -466,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,
         )
 
 
@@ -502,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_)
 
@@ -555,8 +566,8 @@ def _generate_cdf_resource_list(v: Any) -> list[AssetEntity | RelationshipEntity
     return results  # type: ignore
 
 
-ParentEntityList = Annotated[
-    list[ParentClassEntity],
+ClassEntityList = Annotated[
+    list[ClassEntity],
     BeforeValidator(_split_str),
     PlainSerializer(
         _join_str,

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

@@ -1,13 +1,13 @@
 import math
 import sys
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, ClassVar, Literal, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Literal
 
 from pydantic import Field, field_serializer, field_validator, model_validator
 from pydantic.main import IncEx
 from rdflib import Namespace
 
-from cognite.neat.constants import PREFIXES
+from cognite.neat.constants import get_default_prefixes
 from cognite.neat.issues import MultiValueError
 from cognite.neat.rules import exceptions, issues
 from cognite.neat.rules.models._base import (
@@ -38,10 +38,9 @@ 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,
+    ClassEntityList,
     EntityTypes,
     MultiValueTypeInfo,
-    ParentClassEntity,
-    ParentEntityList,
     ReferenceEntity,
     Undefined,
     UnknownEntity,
@@ -114,6 +113,9 @@ class InformationMetadata(BaseMetadata):
     def as_identifier(self) -> str:
         return f"{self.prefix}:{self.name}"
 
+    def get_prefix(self) -> str:
+        return self.prefix
+
 
 class InformationClass(SheetEntity):
     """
@@ -130,7 +132,7 @@ class InformationClass(SheetEntity):
     class_: ClassEntity = Field(alias="Class")
     name: str | None = Field(alias="Name", default=None)
     description: str | None = Field(alias="Description", default=None)
-    parent: ParentEntityList | None = Field(alias="Parent Class", default=None)
+    parent: ClassEntityList | None = Field(alias="Parent Class", default=None)
     reference: URLEntity | ReferenceEntity | None = Field(alias="Reference", default=None, union_mode="left_to_right")
     match_type: MatchType | None = Field(alias="Match Type", default=None)
     comment: str | None = Field(alias="Comment", default=None)
@@ -259,7 +261,7 @@ class InformationRules(BaseRules):
     metadata: InformationMetadata = Field(alias="Metadata")
     properties: SheetList[InformationProperty] = Field(alias="Properties")
     classes: SheetList[InformationClass] = Field(alias="Classes")
-    prefixes: dict[str, Namespace] = Field(default_factory=lambda: PREFIXES.copy(), alias="Prefixes")
+    prefixes: dict[str, Namespace] = Field(default_factory=get_default_prefixes, alias="Prefixes")
     last: "InformationRules | None" = Field(None, alias="Last")
     reference: "InformationRules | None" = Field(None, alias="Reference")
 
@@ -268,7 +270,7 @@ class InformationRules(BaseRules):
         if isinstance(values, dict):
             return {key: Namespace(value) if isinstance(value, str) else value for key, value in values.items()}
         elif values is None:
-            values = PREFIXES.copy()
+            values = get_default_prefixes()
         return values
 
     @model_validator(mode="after")
@@ -287,7 +289,7 @@ class InformationRules(BaseRules):
         # update parent classes
         for class_ in self.classes:
             if class_.parent:
-                for parent in cast(list[ParentClassEntity], class_.parent):
+                for parent in class_.parent:
                     if not isinstance(parent.prefix, str):
                         parent.prefix = self.metadata.prefix
             if class_.class_.prefix is Undefined:

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

@@ -15,7 +15,6 @@ from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import (
     ClassEntity,
     MultiValueTypeInfo,
-    ParentClassEntity,
     Unknown,
     UnknownEntity,
 )
@@ -227,7 +226,7 @@ class InformationClassInput:
             "Reference": self.reference,
             "Match Type": self.match_type,
             "Parent Class": (
-                [ParentClassEntity.load(parent, prefix=default_prefix) for parent in self.parent.split(",")]
+                [ClassEntity.load(parent, prefix=default_prefix) for parent in self.parent.split(",")]
                 if self.parent
                 else None
             ),

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
 
@@ -161,7 +161,7 @@ class InformationPostValidation:
             class_subclass_pairs[class_.class_] = []
             if class_.parent is None:
                 continue
-            class_subclass_pairs[class_.class_].extend([parent.as_class_entity() for parent in class_.parent])
+            class_subclass_pairs[class_.class_].extend(class_.parent)
 
         return class_subclass_pairs
 

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