cognite-toolkit 0.6.39__py3-none-any.whl → 0.7.30__py3-none-any.whl

cognite_toolkit/_cdf_tk/utils/http_client/_data_classes2.py

@@ -0,0 +1,187 @@
+import gzip
+import sys
+from abc import ABC, abstractmethod
+from collections.abc import Hashable
+from typing import Any, Literal
+
+import httpx
+from cognite.client import global_config
+from pydantic import BaseModel, ConfigDict, Field, JsonValue, TypeAdapter, model_validator
+from pydantic.alias_generators import to_camel
+
+from cognite_toolkit._cdf_tk.utils.http_client._tracker import ItemsRequestTracker
+from cognite_toolkit._cdf_tk.utils.useful_types import PrimitiveType
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class HTTPResult2(BaseModel): ...
+
+
+class FailedRequest2(HTTPResult2):
+    error: str
+
+
+class SuccessResponse2(HTTPResult2):
+    status_code: int
+    body: str
+    content: bytes
+
+
+class ErrorDetails2(BaseModel):
+    """This is the expected structure of error details in the CDF API"""
+
+    code: int
+    message: str
+    missing: list[JsonValue] | None = None
+    duplicated: list[JsonValue] | None = None
+    is_auto_retryable: bool | None = None
+
+    @classmethod
+    def from_response(cls, response: httpx.Response) -> "ErrorDetails2":
+        """Populate the error details from a httpx response."""
+        try:
+            res = TypeAdapter(dict[Literal["error"], ErrorDetails2]).validate_json(response.text)
+        except ValueError:
+            return cls(code=response.status_code, message=response.text)
+        return res["error"]
+
+
+class FailedResponse2(HTTPResult2):
+    status_code: int
+    body: str
+    error: ErrorDetails2
+
+
+class BaseRequestMessage(BaseModel, ABC):
+    endpoint_url: str
+    method: Literal["GET", "POST", "PATCH", "DELETE", "PUT"]
+    connect_attempt: int = 0
+    read_attempt: int = 0
+    status_attempt: int = 0
+    api_version: str | None = None
+    content_type: str = "application/json"
+    accept: str = "application/json"
+
+    parameters: dict[str, PrimitiveType] | None = None
+
+    @property
+    def total_attempts(self) -> int:
+        return self.connect_attempt + self.read_attempt + self.status_attempt
+
+    @property
+    @abstractmethod
+    def content(self) -> str | bytes | None: ...
+
+
+class RequestMessage2(BaseRequestMessage):
+    data_content: bytes | None = None
+    body_content: dict[str, JsonValue] | None = None
+
+    @model_validator(mode="before")
+    def check_data_or_body(cls, values: dict[str, Any]) -> dict[str, Any]:
+        if values.get("data_content") is not None and values.get("body_content") is not None:
+            raise ValueError("Only one of data_content or body_content can be set.")
+        return values
+
+    @property
+    def content(self) -> str | bytes | None:
+        data: str | bytes | None = None
+        if self.data_content is not None:
+            data = self.data_content
+            if not global_config.disable_gzip:
+                data = gzip.compress(data)
+        elif self.body_content is not None:
+            # We serialize using pydantic instead of json.dumps. This is because pydantic is faster
+            # and handles more complex types such as datetime, float('nan'), etc.
+            data = _BODY_SERIALIZER.dump_json(self.body_content)
+            if not global_config.disable_gzip and isinstance(data, str):
+                data = gzip.compress(data.encode("utf-8"))
+        return data
+
+
+_BODY_SERIALIZER = TypeAdapter(dict[str, JsonValue])
+
+
+class ItemsResultMessage2(BaseModel):
+    ids: list[Hashable]
+
+
+class ItemsFailedRequest2(ItemsResultMessage2):
+    error_message: str
+
+
+class ItemsSuccessResponse2(ItemsResultMessage2):
+    status_code: int
+    body: str
+    content: bytes
+
+
+class ItemsFailedResponse2(ItemsResultMessage2):
+    status_code: int
+    error: ErrorDetails2
+    body: str
+
+
+class BaseModelObject(BaseModel):
+    """Base class for all object. This includes resources and nested objects."""
+
+    # We allow extra fields to support forward compatibility.
+    model_config = ConfigDict(alias_generator=to_camel, extra="allow")
+
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        """Dump the resource to a dictionary.
+
+        This is the default serialization method for request resources.
+        """
+        return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=True)
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any]) -> "Self":
+        """Load method to match CogniteResource signature."""
+        return cls.model_validate(resource)
+
+
+class RequestResource(BaseModelObject, ABC):
+    @abstractmethod
+    def as_id(self) -> Hashable: ...
+
+
+def _set_default_tracker(data: dict[str, Any]) -> ItemsRequestTracker:
+    if "tracker" not in data or data["tracker"] is None:
+        return ItemsRequestTracker(data.get("max_failures_before_abort", 50))
+    return data["tracker"]
+
+
+class ItemsRequest2(BaseRequestMessage):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    items: list[RequestResource]
+    extra_body_fields: dict[str, JsonValue] | None = None
+    max_failures_before_abort: int = 50
+    tracker: ItemsRequestTracker = Field(init=False, default_factory=_set_default_tracker, exclude=True)
+
+    @property
+    def content(self) -> str | bytes | None:
+        body: dict[str, JsonValue] = {"items": [item.dump() for item in self.items]}
+        if self.extra_body_fields:
+            body.update(self.extra_body_fields)
+        res = _BODY_SERIALIZER.dump_json(body)
+        if not global_config.disable_gzip and isinstance(res, str):
+            return gzip.compress(res.encode("utf-8"))
+        return res
+
+    def split(self, status_attempts: int) -> list["ItemsRequest2"]:
+        """Split the request into multiple requests with a single item each."""
+        mid = len(self.items) // 2
+        if mid == 0:
+            return [self]
+        self.tracker.register_failure()
+        messages: list[ItemsRequest2] = []
+        for part in (self.items[:mid], self.items[mid:]):
+            new_request = self.model_copy(update={"items": part, "status_attempt": status_attempts})
+            new_request.tracker = self.tracker
+            messages.append(new_request)
+        return messages

cognite_toolkit/_cdf_tk/utils/http_client/_exception.py

@@ -0,0 +1,4 @@
+class ToolkitAPIError(Exception):
+    """Base class for all exceptions raised by the Cognite Toolkit API client."""
+
+    pass

cognite_toolkit/_cdf_tk/utils/interactive_select.py

@@ -14,10 +14,7 @@ from cognite.client.data_classes import (
     filters,
 )
 from cognite.client.data_classes.aggregations import Count
-from cognite.client.data_classes.capabilities import (
-    UserProfilesAcl,
-)
-from cognite.client.data_classes.data_modeling import NodeList, Space, SpaceList, View, ViewId
+from cognite.client.data_classes.data_modeling import ContainerId, NodeList, Space, SpaceList, View, ViewId, ViewList
 from cognite.client.data_classes.data_modeling.statistics import SpaceStatistics
 from cognite.client.utils import ms_to_datetime
 from questionary import Choice
@@ -26,8 +23,9 @@ from rich.console import Console
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.data_classes.canvas import Canvas
 from cognite_toolkit._cdf_tk.client.data_classes.charts import Chart, ChartList, Visibility
+from cognite_toolkit._cdf_tk.client.data_classes.migration import ResourceViewMapping
 from cognite_toolkit._cdf_tk.client.data_classes.raw import RawTable
-from cognite_toolkit._cdf_tk.exceptions import AuthorizationError, ToolkitMissingResourceError, ToolkitValueError
+from cognite_toolkit._cdf_tk.exceptions import ToolkitMissingResourceError, ToolkitValueError
 
 from . import humanize_collection
 from .aggregators import (
@@ -308,9 +306,14 @@ class InteractiveCanvasSelect:
     opening_choices: ClassVar[list[questionary.Choice]] = [
         questionary.Choice(title="All public Canvases", value=CanvasFilter(visibility="public", select_all=True)),
         questionary.Choice(title="Selected public Canvases", value=CanvasFilter(visibility="public", select_all=False)),
-        questionary.Choice(title="All by given user", value=CanvasFilter(created_by="user", select_all=True)),
-        questionary.Choice(title="Selected by given user", value=CanvasFilter(created_by="user", select_all=False)),
-        questionary.Choice(title="All Canvases", value=CanvasFilter(visibility=None, select_all=True)),
+        questionary.Choice(
+            title="All public Canvases by given user",
+            value=CanvasFilter(created_by="user", select_all=True, visibility="public"),
+        ),
+        questionary.Choice(
+            title="Selected public Canvases by given user",
+            value=CanvasFilter(created_by="user", select_all=False, visibility="public"),
+        ),
     ]
 
     def __init__(self, client: ToolkitClient) -> None:
@@ -405,13 +408,6 @@ class InteractiveChartSelect:
         return user_response
 
     def _select_external_ids(self, select_filter: ChartFilter) -> list[str]:
-        if not self.client.iam.verify_capabilities(
-            UserProfilesAcl([UserProfilesAcl.Action.Read], scope=UserProfilesAcl.Scope.All())
-        ):
-            raise AuthorizationError(
-                "The current user does not have permission to list user profiles, "
-                "which is required to select Charts owned by a specific user."
-            )
         available_charts = self.client.charts.list(visibility=(select_filter.visibility or "PUBLIC"))
         if select_filter.select_all and select_filter.owned_by is None:
             return [chart.external_id for chart in available_charts]
@@ -504,29 +500,97 @@ class DataModelingSelect:
         result = self.client.data_modeling.statistics.spaces.list()
         return {stat.space: stat for stat in result}
 
-    def select_view(self, include_global: bool = False) -> View:
-        selected_space = self.select_schema_space(
-            include_global, message=f"In which Spaces is the view you will use to select instances to {self.operation}?"
+    @overload
+    def select_view(
+        self,
+        multiselect: Literal[False] = False,
+        include_global: bool = False,
+        space: str | None = None,
+        message: str | None = None,
+        instance_type: Literal["node", "edge", "all"] | None = None,
+        mapped_container: ContainerId | None = None,
+    ) -> View: ...
+
+    @overload
+    def select_view(
+        self,
+        multiselect: Literal[True],
+        include_global: bool = False,
+        space: str | None = None,
+        message: str | None = None,
+        instance_type: Literal["node", "edge", "all"] | None = None,
+        mapped_container: ContainerId | None = None,
+    ) -> ViewList: ...
+
+    def select_view(
+        self,
+        multiselect: bool = False,
+        include_global: bool = False,
+        space: str | None = None,
+        message: str | None = None,
+        instance_type: Literal["node", "edge", "all"] | None = None,
+        mapped_container: ContainerId | None = None,
+    ) -> View | ViewList:
+        """Select one or more views interactively.
+
+        Args:
+            multiselect: Whether to allow selecting multiple views.
+            include_global: Whether to include global views in the selection.
+            space: The space to select views from. If None, the user will be prompted to
+                select a space.
+            message: The message to display when prompting for a view. If None, a default message
+                will be used.
+            instance_type: If 'node' or 'edge', only views of that type will be shown.
+            mapped_container: Only selects view(s) that are mapping the given container.
+
+        Returns:
+            The selected view(s).
+
+        Raises:
+            ToolkitValueError: If no view(s) are selected or if the selected view(s) are not valid.
+            ToolkitMissingResourceError: If no views are found in the selected space.
+
+        """
+        selected_space = (
+            space
+            or self.select_schema_space(
+                include_global,
+                message=f"In which Spaces is the view you will use to select instances to {self.operation}?",
+            ).space
         )
 
         views = self.client.data_modeling.views.list(
-            space=selected_space.space,
+            space=selected_space,
             include_inherited_properties=True,
             limit=-1,
             include_global=include_global,
         )
+        views = ViewList(
+            [
+                view
+                for view in views
+                if instance_type in (None, "all", view.used_for)
+                and (mapped_container is None or mapped_container in view.referenced_containers())
+            ]
+        )
         if not views:
-            raise ToolkitMissingResourceError(f"No views found in space {selected_space.space!r}.")
-
-        selected_view = questionary.select(
-            f"Which view do you want to use to select instances to {self.operation}?",
-            [Choice(title=f"{view.external_id} (version={view.version})", value=view) for view in views],
-        ).ask()
-        if selected_view is None:
-            raise ToolkitValueError("No view selected")
-        if not isinstance(selected_view, View):
-            raise ToolkitValueError(f"Selected view is not a valid View object: {selected_view!r}")
-        return selected_view
+            raise ToolkitMissingResourceError(f"No views found in space {selected_space!r}.")
+        question = message or f"Which view do you want to use to select instances to {self.operation}?"
+        choices = [Choice(title=f"{view.external_id} (version={view.version})", value=view) for view in views]
+        if multiselect:
+            selected_views = questionary.checkbox(question, choices=choices).ask()
+        else:
+            selected_views = questionary.select(question, choices=choices).ask()
+        if selected_views is None:
+            raise ToolkitValueError("No view(s) selected")
+        if multiselect:
+            if not isinstance(selected_views, list) or not all(isinstance(v, View) for v in selected_views):
+                raise ToolkitValueError(f"Selected views is not a valid list of View objects: {selected_views!r}")
+            return ViewList(selected_views)
+        else:
+            if not isinstance(selected_views, View):
+                raise ToolkitValueError(f"Selected view is not a valid View object: {selected_views!r}")
+            return selected_views
 
     def select_schema_space(self, include_global: bool, message: str | None = None) -> Space:
         message = message or f"Select the space to {self.operation}:"
@@ -549,8 +613,19 @@ class DataModelingSelect:
             raise ToolkitValueError(f"Selected space is not a valid Space object: {selected_space!r}")
         return selected_space
 
-    def select_instance_type(self, view_used_for: Literal["node", "edge", "all"]) -> Literal["node", "edge"]:
-        if view_used_for != "all":
+    def select_instance_type(
+        self, view_used_for: Literal["node", "edge", "all"] | None = None
+    ) -> Literal["node", "edge"]:
+        """Selects an instance type (node or edge) interactively.
+
+        Args:
+            view_used_for: If 'node' or 'edge', that type is returned directly.
+                           If 'all' or None, the user is prompted to select.
+
+        Returns:
+            The selected instance type, either 'node' or 'edge'.
+        """
+        if view_used_for is not None and view_used_for != "all":
             return view_used_for
         selected_instance_type = questionary.select(
             f"What type of instances do you want to {self.operation}?",
@@ -561,7 +636,7 @@ class DataModelingSelect:
         ).ask()
         if selected_instance_type is None:
             raise ToolkitValueError("No instance type selected")
-        if selected_instance_type not in ["node", "edge"]:
+        if selected_instance_type not in ("node", "edge"):
             raise ToolkitValueError(f"Selected instance type is not valid: {selected_instance_type!r}")
         return selected_instance_type
 
@@ -587,6 +662,7 @@ class DataModelingSelect:
         selected_view: ViewId | None = None,
         instance_type: Literal["node", "edge"] | None = None,
         message: str | None = None,
+        include_empty: bool = False,
     ) -> str: ...
 
     @overload
@@ -596,6 +672,7 @@ class DataModelingSelect:
         selected_view: ViewId | None = None,
         instance_type: Literal["node", "edge"] | None = None,
         message: str | None = None,
+        include_empty: bool = False,
     ) -> list[str]: ...
 
     def select_instance_space(
@@ -604,6 +681,7 @@ class DataModelingSelect:
         selected_view: ViewId | None = None,
         instance_type: Literal["node", "edge"] | None = None,
         message: str | None = None,
+        include_empty: bool = False,
     ) -> str | list[str]:
         if (selected_view is not None and instance_type is None) or (
             selected_view is None and instance_type is not None
@@ -617,6 +695,10 @@ class DataModelingSelect:
                 space: stats.nodes + stats.edges
                 for space, stats in self.stats_by_space.items()
                 if (stats.nodes + stats.edges) > 0
+                or (
+                    include_empty
+                    and (stats.nodes + stats.edges + stats.containers + stats.views + stats.data_models) == 0
+                )
             }
 
         if not count_by_space:
@@ -705,3 +787,39 @@ class DataModelingSelect:
         if include_global:
             return self._available_spaces
         return SpaceList([space for space in self._available_spaces if not space.is_global])
+
+
+class ResourceViewMappingInteractiveSelect:
+    def __init__(self, client: ToolkitClient, operation: str) -> None:
+        self.client = client
+        self.operation = operation
+
+    def select_resource_view_mapping(self, resource_type: str) -> ResourceViewMapping:
+        """Select a Resource View Mapping interactively.
+
+        Args:
+            resource_type: The resource type to filter Resource View Mappings by.
+        Returns:
+            The selected Resource View Mapping.
+        """
+        mappings = self.client.migration.resource_view_mapping.list(resource_type=resource_type, limit=-1)
+        if not mappings:
+            raise ToolkitMissingResourceError(f"No Resource View Mappings found for resource type {resource_type!r}.")
+        choices = [
+            Choice(
+                title=f"{mapping.external_id} ({mapping.view_id!r})",
+                value=mapping,
+            )
+            for mapping in mappings
+        ]
+        selected_mapping = questionary.select(
+            f"Which Resource View Mapping do you want to use to {self.operation}? [identifier] (ingestion view)",
+            choices=choices,
+        ).ask()
+        if selected_mapping is None:
+            raise ToolkitValueError("No Resource View Mapping selected.")
+        if not isinstance(selected_mapping, ResourceViewMapping):
+            raise ToolkitValueError(
+                f"Selected Resource View Mapping is not a valid ResourceViewMapping object: {selected_mapping!r}"
+            )
+        return selected_mapping

cognite_toolkit/_cdf_tk/utils/modules.py

@@ -4,7 +4,6 @@ from pathlib import Path
 from typing import Literal, overload
 
 from cognite_toolkit._cdf_tk.constants import (
-    BUILTIN_MODULES,
     MODULE_PATH_SEP,
     ROOT_MODULES,
 )
@@ -23,9 +22,6 @@ def iterate_modules(root_dir: Path) -> Iterator[tuple[Path, list[Path]]]:
     if root_dir.name in ROOT_MODULES:
         yield from _iterate_modules(root_dir)
         return
-    elif root_dir.name == BUILTIN_MODULES:
-        yield from _iterate_modules(root_dir)
-        return
     for root_module in ROOT_MODULES:
         module_dir = root_dir / root_module
         if module_dir.exists():

cognite_toolkit/_cdf_tk/utils/producer_worker.py

@@ -2,11 +2,13 @@ import queue
 import sys
 import threading
 import time
+import traceback
 import typing
 from collections.abc import Callable, Iterable, Sized
 from typing import Any, Generic, TypeVar
 
 from rich.console import Console
+from rich.panel import Panel
 from rich.progress import (
     BarColumn,
     Progress,
@@ -89,6 +91,7 @@ class ProducerWorkerExecutor(Generic[T_Download, T_Processed]):
         process_description: str = "Processing",
         write_description: str = "Writing",
         console: Console | None = None,
+        verbose: bool = False,
     ) -> None:
         self._download_iterable = download_iterable
         self._process = process
@@ -106,6 +109,8 @@ class ProducerWorkerExecutor(Generic[T_Download, T_Processed]):
         self.write_queue: queue.Queue[T_Processed] = queue.Queue(maxsize=max_queue_size)
         self.total_items = 0
         self.error_message = ""
+        self.error_traceback = ""
+        self.verbose = verbose
 
     @property
     def error_occurred(self) -> bool:
@@ -187,10 +192,24 @@ class ProducerWorkerExecutor(Generic[T_Download, T_Processed]):
     def raise_on_error(self) -> None:
         """Raises an exception if an error occurred during execution."""
         if self._error_event.is_set():
+            if self.verbose and self.error_traceback:
+                self.print_traceback()
             raise ToolkitRuntimeError(f"An error occurred during execution: {self.error_message}")
         if self._stop_event.is_set():
             raise ToolkitRuntimeError("Execution was stopped by the user.")
 
+    def print_traceback(self) -> None:
+        """Prints the traceback if an error occurred during execution."""
+        if self.error_traceback:
+            self.console.print(
+                Panel(
+                    self.error_traceback,
+                    title="Traceback",
+                    expand=False,
+                    border_style="red",
+                )
+            )
+
     def _download_worker(self, progress: Progress, download_task: TaskID) -> None:
         """Worker thread for downloading data."""
         try:
@@ -216,7 +235,8 @@ class ProducerWorkerExecutor(Generic[T_Download, T_Processed]):
                 break
             except Exception as e:
                 self._error_event.set()
-                self.error_message = str(e)
+                self.error_message = f"{type(e).__name__} {e!s}"
+                self.error_traceback = traceback.format_exc()
                 self.console.print(f"[red]Error[/red] occurred while {self.download_description}: {self.error_message}")
                 break
         self._put_with_error_check(PROCESS_FINISH_SENTINEL, self.process_queue)  # type: ignore[misc]
@@ -255,7 +275,8 @@ class ProducerWorkerExecutor(Generic[T_Download, T_Processed]):
                 continue
             except Exception as e:
                 self._error_event.set()
-                self.error_message = str(e)
+                self.error_message = f"{type(e).__name__} {e!s}"
+                self.error_traceback = traceback.format_exc()
                 self.console.print(f"[red]Error[/red] occurred while {self.process_description}: {self.error_message}")
                 break
 
@@ -276,7 +297,8 @@ class ProducerWorkerExecutor(Generic[T_Download, T_Processed]):
                 continue
             except Exception as e:
                 self._error_event.set()
-                self.error_message = str(e)
+                self.error_message = f"{type(e).__name__} {e!s}"
+                self.error_traceback = traceback.format_exc()
                 self.console.print(f"[red]Error[/red] occurred while {self.write_description}: {self.error_message}")
                 break
 

cognite_toolkit/_cdf_tk/utils/sql_parser.py

@@ -1,12 +1,11 @@
 import importlib.util
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from cognite_toolkit._cdf_tk.exceptions import ToolkitMissingDependencyError
 
 if TYPE_CHECKING:
-    from sqlparse.sql import Identifier
-    from sqlparse.tokens import Token
-from dataclasses import dataclass
+    from sqlparse.sql import Identifier, Token
 
 
 @dataclass(frozen=True)

cognite_toolkit/_cdf_tk/utils/text.py

@@ -1,8 +1,10 @@
+import hashlib
 import re
 from collections.abc import Hashable
 
 from rich.console import Console
 
+from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
 from cognite_toolkit._cdf_tk.tk_warnings import LowSeverityWarning
 
 INVALID_TITLE_REGEX = re.compile(r"[\\*?:/\[\]]")
@@ -58,3 +60,56 @@ def sanitize_spreadsheet_title(title: str) -> str:
         return "Sheet"
     sanitized_title = INVALID_TITLE_REGEX.sub("", title)
     return sanitized_title if sanitized_title else "Sheet"
+
+
+def to_sentence_case(text: str) -> str:
+    """Converts a string to sentence case.
+
+    Args:
+        text: The original string to convert.
+
+    Returns:
+        str: The string converted to sentence case.
+
+    >>> to_sentence_case("hello world")
+    'hello world'
+    >>> to_sentence_case("PYTHON programming")
+    'python programming'
+    >>> to_sentence_case("")
+    ''
+    >>> to_sentence_case("snake_case_string")
+    'snake case string'
+    >>> to_sentence_case("MIXED_case STRING")
+    'mixed case string'
+    >>> to_sentence_case("camelCaseString")
+    'camel case string'
+    """
+    if not text:
+        return text
+    # Replace underscores with spaces
+    text = text.replace("_", " ")
+    # Insert spaces before uppercase letters that are preceded by lowercase letters
+    text = re.sub(r"(?<=[a-z])([A-Z])", r" \1", text)
+    # Convert to lowercase
+    return text.casefold()
+
+
+def sanitize_instance_external_id(external_id: str) -> str:
+    """Sanitize an instance external ID to be compatible with CDF requirements.
+
+    Args:
+        external_id: The external ID to sanitize.
+
+    Returns:
+        The sanitized external ID.
+    """
+    # CDF instance external IDs must be between 1 and 256 characters,
+    if not external_id or external_id == "\x00":
+        raise ToolkitValueError("External ID cannot be empty.")
+    elif len(external_id) <= 256:
+        return external_id
+    hasher = hashlib.sha256()
+    hasher.update(external_id.encode("utf-8"))
+    hash_digest = hasher.hexdigest()[:8]
+    sanitized_external_id = f"{external_id[:247]}_{hash_digest}"
+    return sanitized_external_id