cognite-neat 0.83.0__tar.gz → 0.84.0__tar.gz

{cognite_neat-0.83.0 → cognite_neat-0.84.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.83.0
+Version: 0.84.0
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

cognite_neat-0.84.0/cognite/neat/_shared.py

@@ -0,0 +1,35 @@
+from abc import abstractmethod
+from collections.abc import Hashable, Sequence
+from dataclasses import dataclass
+from typing import Any, TypeVar
+
+import pandas as pd
+
+T_ID = TypeVar("T_ID", bound=Hashable)
+
+
+@dataclass
+class NeatObject:
+    """A neat object can be dumped to a dictionary."""
+
+    @abstractmethod
+    def dump(self, aggregate: bool = True) -> dict[str, Any]:
+        """Return a dictionary representation of the object."""
+        raise NotImplementedError()
+
+
+T_NeatObject = TypeVar("T_NeatObject", bound=NeatObject)
+
+
+class NeatList(list, Sequence[T_NeatObject]):
+    """A list of neat objects."""
+
+    def dump(self) -> list[dict[str, Any]]:
+        """Return a list of dictionary representations of the objects."""
+        return [obj.dump() for obj in self]
+
+    def to_pandas(self) -> pd.DataFrame:
+        return pd.DataFrame(self.dump())
+
+    def _repr_html_(self) -> str:
+        return self.to_pandas()._repr_html_()  # type: ignore[operator]

cognite_neat-0.84.0/cognite/neat/_version.py

@@ -0,0 +1 @@
+__version__ = "0.84.0"

{cognite_neat-0.83.0 → cognite_neat-0.84.0}/cognite/neat/rules/exporters/_base.py

@@ -7,7 +7,7 @@ from cognite.client import CogniteClient
 
 from cognite.neat.rules._shared import Rules
 from cognite.neat.rules.models import DMSRules, InformationRules, RoleTypes
-from cognite.neat.utils.upload import UploadDiffsCount
+from cognite.neat.utils.upload import UploadResult, UploadResultList
 
 T_Export = TypeVar("T_Export")
 
@@ -37,5 +37,10 @@ class BaseExporter(ABC, Generic[T_Export]):
 
 class CDFExporter(BaseExporter[T_Export]):
     @abstractmethod
-    def export_to_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> Iterable[UploadDiffsCount]:
+    def export_to_cdf_iterable(
+        self, rules: Rules, client: CogniteClient, dry_run: bool = False
+    ) -> Iterable[UploadResult]:
         raise NotImplementedError
+
+    def export_to_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> UploadResultList:
+        return UploadResultList(self.export_to_cdf_iterable(rules, client, dry_run))

{cognite_neat-0.83.0 → cognite_neat-0.84.0}/cognite/neat/rules/exporters/_rules2dms.py

@@ -1,5 +1,5 @@
 import warnings
-from collections.abc import Collection, Iterable
+from collections.abc import Collection, Hashable, Iterable, Sequence
 from pathlib import Path
 from typing import Literal, TypeAlias, cast
 
@@ -31,7 +31,7 @@ from cognite.neat.utils.cdf_loaders import (
     TransformationLoader,
     ViewLoader,
 )
-from cognite.neat.utils.upload import UploadDiffsCount
+from cognite.neat.utils.upload import UploadResult
 
 from ._base import CDFExporter
 
@@ -123,109 +123,84 @@ class DMSExporter(CDFExporter[DMSSchema]):
             raise ValueError(f"{type(rules).__name__} cannot be exported to DMS")
         return dms_rules.as_schema(include_pipeline=self.export_pipeline, instance_space=self.instance_space)
 
-    def delete_from_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> Iterable[UploadDiffsCount]:
-        schema, to_export = self._prepare_schema_and_exporters(rules, client)
+    def delete_from_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> Iterable[UploadResult]:
+        to_export = self._prepare_exporters(rules, client)
 
         # we need to reverse order in which we are picking up the items to delete
         # as they are sorted in the order of creation and we need to delete them in reverse order
-        for all_items, loader in reversed(to_export):
-            all_item_ids = loader.get_ids(all_items)
-            item_ids = [item_id for item_id in all_item_ids]
-            cdf_items = loader.retrieve(item_ids)
-            cdf_item_by_id = {loader.get_id(item): item for item in cdf_items}
-            items = [item for item in all_items if loader.get_id(item) in item_ids]
-            to_delete = []
-
-            for item in items:
+        for items, loader in reversed(to_export):
+            item_ids = loader.get_ids(items)
+            existing_items = loader.retrieve(item_ids)
+            existing_ids = loader.get_ids(existing_items)
+            to_delete: list[Hashable] = []
+            for item_id in item_ids:
                 if (
                     isinstance(loader, DataModelingLoader)
                     and self.include_space is not None
-                    and not loader.in_space(item, self.include_space)
+                    and not loader.in_space(item_id, self.include_space)
                 ):
                     continue
 
-                cdf_item = cdf_item_by_id.get(loader.get_id(item))
-                if cdf_item:
-                    to_delete.append(cdf_item)
-
-            deleted = len(to_delete)
-            failed_deleted = 0
+                if item_id in existing_ids:
+                    to_delete.append(item_id)
 
+            deleted: set[Hashable] = set()
+            failed_deleted: set[Hashable] = set()
             error_messages: list[str] = []
-            if not dry_run:
-                if to_delete:
-                    try:
-                        loader.delete(to_delete)
-                    except CogniteAPIError as e:
-                        failed_deleted = len(e.failed) + len(e.unknown)
-                        deleted -= failed_deleted
-                        error_messages.append(f"Failed delete: {e.message}")
+            if dry_run:
+                deleted.update(to_delete)
+            elif to_delete:
+                try:
+                    loader.delete(to_delete)
+                except CogniteAPIError as e:
+                    failed_deleted.update(loader.get_id(item) for item in e.failed + e.unknown)
+                    deleted.update(loader.get_id(item) for item in e.successful)
+                    error_messages.append(f"Failed delete: {e.message}")
+                else:
+                    deleted.update(to_delete)
 
-            yield UploadDiffsCount(
+            yield UploadResult(
                 name=loader.resource_name,
                 deleted=deleted,
-                skipped=0,
                 failed_deleted=failed_deleted,
                 error_messages=error_messages,
             )
 
-    def export_to_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> Iterable[UploadDiffsCount]:
-        schema, to_export = self._prepare_schema_and_exporters(rules, client)
+    def export_to_cdf_iterable(
+        self, rules: Rules, client: CogniteClient, dry_run: bool = False
+    ) -> Iterable[UploadResult]:
+        to_export = self._prepare_exporters(rules, client)
 
-        # The conversion from DMS to GraphQL does not seem to be triggered even if the views
-        # are changed. This is a workaround to force the conversion.
         redeploy_data_model = False
+        for items, loader in to_export:
+            # The conversion from DMS to GraphQL does not seem to be triggered even if the views
+            # are changed. This is a workaround to force the conversion.
+            is_redeploying = loader is DataModelingLoader and redeploy_data_model
 
-        for all_items, loader in to_export:
-            issue_list = IssueList()
-            all_item_ids = loader.get_ids(all_items)
-            item_ids = [item_id for item_id in all_item_ids]
-            cdf_items = loader.retrieve(item_ids)
-            cdf_item_by_id = {loader.get_id(item): item for item in cdf_items}
-            items = [item for item in all_items if loader.get_id(item) in item_ids]
-            to_create, to_update, unchanged, to_delete = [], [], [], []
-            is_redeploying = loader.resource_name == "data_models" and redeploy_data_model
-            for item in items:
-                if (
-                    isinstance(loader, DataModelingLoader)
-                    and self.include_space is not None
-                    and not loader.in_space(item, self.include_space)
-                ):
-                    continue
-
-                cdf_item = cdf_item_by_id.get(loader.get_id(item))
-                if cdf_item is None:
-                    to_create.append(item)
-                elif is_redeploying:
-                    to_update.append(item)
-                    to_delete.append(cdf_item)
-                elif loader.are_equal(item, cdf_item):
-                    unchanged.append(item)
-                else:
-                    to_update.append(item)
-
-            created = len(to_create)
-            failed_created = 0
-            skipped = 0
-
-            if self.existing_handling in ["update", "force"]:
-                changed = len(to_update)
-                failed_changed = 0
-            elif self.existing_handling == "skip":
-                changed = 0
-                failed_changed = 0
-                skipped += len(to_update)
-            elif self.existing_handling == "fail":
-                failed_changed = len(to_update)
-                changed = 0
-            else:
-                raise ValueError(f"Unsupported existing_handling {self.existing_handling}")
+            to_create, to_delete, to_update, unchanged = self._categorize_items_for_upload(
+                loader, items, is_redeploying
+            )
 
+            issue_list = IssueList()
             warning_list = self._validate(loader, items)
             issue_list.extend(warning_list)
 
+            created: set[Hashable] = set()
+            skipped: set[Hashable] = set()
+            changed: set[Hashable] = set()
+            failed_created: set[Hashable] = set()
+            failed_changed: set[Hashable] = set()
             error_messages: list[str] = []
-            if not dry_run:
+            if dry_run:
+                if self.existing_handling in ["update", "force"]:
+                    changed.update(loader.get_id(item) for item in to_update)
+                elif self.existing_handling == "skip":
+                    skipped.update(loader.get_id(item) for item in to_update)
+                elif self.existing_handling == "fail":
+                    failed_changed.update(loader.get_id(item) for item in to_update)
+                else:
+                    raise ValueError(f"Unsupported existing_handling {self.existing_handling}")
+            else:
                 if to_delete:
                     try:
                         loader.delete(to_delete)
@@ -238,23 +213,31 @@ class DMSExporter(CDFExporter[DMSSchema]):
                 try:
                     loader.create(to_create)
                 except CogniteAPIError as e:
-                    failed_created = len(e.failed) + len(e.unknown)
-                    created -= failed_created
+                    failed_created.update(loader.get_id(item) for item in e.failed + e.unknown)
+                    created.update(loader.get_id(item) for item in e.successful)
                     error_messages.append(e.message)
+                else:
+                    created.update(loader.get_id(item) for item in to_create)
 
                 if self.existing_handling in ["update", "force"]:
                     try:
                         loader.update(to_update)
                     except CogniteAPIError as e:
-                        failed_changed = len(e.failed) + len(e.unknown)
-                        changed -= failed_changed
+                        failed_changed.update(loader.get_id(item) for item in e.failed + e.unknown)
+                        changed.update(loader.get_id(item) for item in e.successful)
                         error_messages.append(e.message)
-
-            yield UploadDiffsCount(
+                    else:
+                        changed.update(loader.get_id(item) for item in to_update)
+                elif self.existing_handling == "skip":
+                    skipped.update(loader.get_id(item) for item in to_update)
+                elif self.existing_handling == "fail":
+                    failed_changed.update(loader.get_id(item) for item in to_update)
+
+            yield UploadResult(
                 name=loader.resource_name,
                 created=created,
                 changed=changed,
-                unchanged=len(unchanged),
+                unchanged={loader.get_id(item) for item in unchanged},
                 skipped=skipped,
                 failed_created=failed_created,
                 failed_changed=failed_changed,
@@ -262,12 +245,37 @@ class DMSExporter(CDFExporter[DMSSchema]):
                 issues=issue_list,
             )
 
-            if loader.resource_name == "views" and (created or changed) and not redeploy_data_model:
+            if loader is ViewLoader and (created or changed):
                 redeploy_data_model = True
 
-    def _prepare_schema_and_exporters(
-        self, rules, client
-    ) -> tuple[DMSSchema, list[tuple[CogniteResourceList, ResourceLoader]]]:
+    def _categorize_items_for_upload(
+        self, loader: ResourceLoader, items: Sequence[CogniteResource], is_redeploying
+    ) -> tuple[list[CogniteResource], list[CogniteResource], list[CogniteResource], list[CogniteResource]]:
+        item_ids = loader.get_ids(items)
+        cdf_items = loader.retrieve(item_ids)
+        cdf_item_by_id = {loader.get_id(item): item for item in cdf_items}
+        to_create, to_update, unchanged, to_delete = [], [], [], []
+        for item in items:
+            if (
+                isinstance(loader, DataModelingLoader)
+                and self.include_space is not None
+                and not loader.in_space(item, self.include_space)
+            ):
+                continue
+
+            cdf_item = cdf_item_by_id.get(loader.get_id(item))
+            if cdf_item is None:
+                to_create.append(item)
+            elif is_redeploying:
+                to_update.append(item)
+                to_delete.append(cdf_item)
+            elif loader.are_equal(item, cdf_item):
+                unchanged.append(item)
+            else:
+                to_update.append(item)
+        return to_create, to_delete, to_update, unchanged
+
+    def _prepare_exporters(self, rules, client) -> list[tuple[CogniteResourceList, ResourceLoader]]:
         schema = self.export(rules)
         to_export: list[tuple[CogniteResourceList, ResourceLoader]] = []
         if self.export_components.intersection({"all", "spaces"}):
@@ -282,9 +290,9 @@ class DMSExporter(CDFExporter[DMSSchema]):
             to_export.append((schema.databases, RawDatabaseLoader(client)))
             to_export.append((schema.raw_tables, RawTableLoader(client)))
             to_export.append((schema.transformations, TransformationLoader(client)))
-        return schema, to_export
+        return to_export
 
-    def _validate(self, loader: ResourceLoader, items: list[CogniteResource]) -> IssueList:
+    def _validate(self, loader: ResourceLoader, items: CogniteResourceList) -> IssueList:
         issue_list = IssueList()
         if isinstance(loader, DataModelLoader):
             models = cast(list[DataModelApply], items)

{cognite_neat-0.83.0 → cognite_neat-0.84.0}/cognite/neat/utils/cdf_loaders/_base.py

@@ -9,18 +9,10 @@ from cognite.client.data_classes._base import (
     T_WriteClass,
     WriteableCogniteResourceList,
 )
-from cognite.client.data_classes.data_modeling import (
-    DataModelingId,
-)
-from cognite.client.data_classes.data_modeling.ids import (
-    InstanceId,
-    VersionedDataModelingId,
-)
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from .data_classes import RawTableID
+from cognite.neat._shared import T_ID
 
-T_ID = TypeVar("T_ID", bound=str | int | DataModelingId | InstanceId | VersionedDataModelingId | RawTableID)
 T_WritableCogniteResourceList = TypeVar("T_WritableCogniteResourceList", bound=WriteableCogniteResourceList)
 
 

{cognite_neat-0.83.0 → cognite_neat-0.84.0}/cognite/neat/utils/cdf_loaders/_data_modeling.py

@@ -41,7 +41,8 @@ from ._base import T_ID, ResourceLoader, T_WritableCogniteResourceList
 class DataModelingLoader(
     ResourceLoader[T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList]
 ):
-    def in_space(self, item: T_WriteClass | T_WritableCogniteResource, space: set[str]) -> bool:
+    @classmethod
+    def in_space(cls, item: T_WriteClass | T_WritableCogniteResource | T_ID, space: set[str]) -> bool:
         if hasattr(item, "space"):
             return item.space in space
         raise ValueError(f"Item {item} does not have a space attribute")

cognite_neat-0.84.0/cognite/neat/utils/upload.py

@@ -0,0 +1,126 @@
+from abc import ABC
+from dataclasses import dataclass, field
+from functools import total_ordering
+from typing import Any, Generic
+
+from cognite.neat._shared import T_ID, NeatList, NeatObject
+from cognite.neat.issues import NeatIssueList
+
+
+@total_ordering
+@dataclass
+class UploadResultCore(NeatObject, ABC):
+    name: str
+    error_messages: list[str] = field(default_factory=list)
+    issues: NeatIssueList = field(default_factory=NeatIssueList)
+
+    def __lt__(self, other: object) -> bool:
+        if isinstance(other, UploadResultCore):
+            return self.name < other.name
+        else:
+            return NotImplemented
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, UploadResultCore):
+            return self.name == other.name
+        else:
+            return NotImplemented
+
+    def dump(self, aggregate: bool = True) -> dict[str, Any]:
+        return {"name": self.name}
+
+
+class UploadResultList(NeatList[UploadResultCore]): ...
+
+
+@dataclass
+class UploadResult(UploadResultCore, Generic[T_ID]):
+    created: set[T_ID] = field(default_factory=set)
+    deleted: set[T_ID] = field(default_factory=set)
+    changed: set[T_ID] = field(default_factory=set)
+    unchanged: set[T_ID] = field(default_factory=set)
+    skipped: set[T_ID] = field(default_factory=set)
+    failed_created: set[T_ID] = field(default_factory=set)
+    failed_changed: set[T_ID] = field(default_factory=set)
+    failed_deleted: set[T_ID] = field(default_factory=set)
+
+    @property
+    def failed(self) -> int:
+        return len(self.failed_created) + len(self.failed_changed) + len(self.failed_deleted)
+
+    @property
+    def total(self) -> int:
+        return len(self.created) + len(self.deleted) + len(self.changed) + len(self.unchanged) + len(self.skipped)
+
+    def dump(self, aggregate: bool = True) -> dict[str, Any]:
+        output = super().dump(aggregate)
+        if self.created:
+            output["created"] = len(self.created) if aggregate else list(self.created)
+        if self.deleted:
+            output["deleted"] = len(self.deleted) if aggregate else list(self.deleted)
+        if self.changed:
+            output["changed"] = len(self.changed) if aggregate else list(self.changed)
+        if self.unchanged:
+            output["unchanged"] = len(self.unchanged) if aggregate else list(self.unchanged)
+        if self.skipped:
+            output["skipped"] = len(self.skipped) if aggregate else list(self.skipped)
+        if self.failed_created:
+            output["failed_created"] = len(self.failed_created) if aggregate else list(self.failed_created)
+        if self.failed_changed:
+            output["failed_changed"] = len(self.failed_changed) if aggregate else list(self.failed_changed)
+        if self.failed_deleted:
+            output["failed_deleted"] = len(self.failed_deleted) if aggregate else list(self.failed_deleted)
+        if self.error_messages:
+            output["error_messages"] = len(self.error_messages) if aggregate else self.error_messages
+        if self.issues:
+            output["issues"] = len(self.issues) if aggregate else [issue.dump() for issue in self.issues]
+        return output
+
+    def __str__(self) -> str:
+        dumped = self.dump(aggregate=True)
+        lines: list[str] = []
+        for key, value in dumped.items():
+            if key in ["name", "error_messages", "issues"]:
+                continue
+            lines.append(f"{key}: {value}")
+        return f"{self.name.title()}: {', '.join(lines)}"
+
+
+@dataclass
+class UploadResultIDs(UploadResultCore):
+    success: list[str] = field(default_factory=list)
+    failed: list[str] = field(default_factory=list)
+
+    def dump(self, aggregate: bool = True) -> dict[str, Any]:
+        output = super().dump(aggregate)
+        if self.success:
+            output["success"] = len(self.success) if aggregate else self.success
+        if self.failed:
+            output["failed"] = len(self.failed) if aggregate else self.failed
+        return output
+
+
+@dataclass
+class UploadDiffsID(UploadResultCore):
+    created: list[str] = field(default_factory=list)
+    changed: list[str] = field(default_factory=list)
+    unchanged: list[str] = field(default_factory=list)
+    failed: list[str] = field(default_factory=list)
+
+    def as_upload_result_ids(self) -> UploadResultIDs:
+        result = UploadResultIDs(name=self.name, error_messages=self.error_messages, issues=self.issues)
+        result.success = self.created + self.changed + self.unchanged
+        result.failed = self.failed
+        return result
+
+    def dump(self, aggregate: bool = True) -> dict[str, Any]:
+        output = super().dump(aggregate)
+        if self.created:
+            output["created"] = len(self.created) if aggregate else self.created
+        if self.changed:
+            output["changed"] = len(self.changed) if aggregate else self.changed
+        if self.unchanged:
+            output["unchanged"] = len(self.unchanged) if aggregate else self.unchanged
+        if self.failed:
+            output["failed"] = len(self.failed) if aggregate else self.failed
+        return output

{cognite_neat-0.83.0 → cognite_neat-0.84.0}/cognite/neat/workflows/steps/lib/current/rules_exporter.py

@@ -95,7 +95,7 @@ class DeleteDataModelFromCDF(Step):
         report_lines = ["# Data Model Deletion from CDF\n\n"]
         errors = []
         for result in dms_exporter.delete_from_cdf(rules=input_rules, client=cdf_client, dry_run=dry_run):
-            report_lines.append(result.as_report_str())
+            report_lines.append(str(result))
             errors.extend(result.error_messages)
 
         report_lines.append("\n\n# ERRORS\n\n")
@@ -216,8 +216,8 @@ class RulesToDMS(Step):
 
         report_lines = ["# DMS Schema Export to CDF\n\n"]
         errors = []
-        for result in dms_exporter.export_to_cdf(rules=input_rules, client=cdf_client, dry_run=dry_run):
-            report_lines.append(result.as_report_str())
+        for result in dms_exporter.export_to_cdf_iterable(rules=input_rules, client=cdf_client, dry_run=dry_run):
+            report_lines.append(str(result))
             errors.extend(result.error_messages)
 
         report_lines.append("\n\n# ERRORS\n\n")
@@ -555,8 +555,8 @@ class RulesToCDFTransformations(Step):
 
         report_lines = ["# DMS Schema Export to CDF\n\n"]
         errors = []
-        for result in dms_exporter.export_to_cdf(rules=input_rules, client=cdf_client, dry_run=dry_run):
-            report_lines.append(result.as_report_str())
+        for result in dms_exporter.export_to_cdf_iterable(rules=input_rules, client=cdf_client, dry_run=dry_run):
+            report_lines.append(str(result))
             errors.extend(result.error_messages)
 
         report_lines.append("\n\n# ERRORS\n\n")

{cognite_neat-0.83.0 → cognite_neat-0.84.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cognite-neat"
-version = "0.83.0"
+version = "0.84.0"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

cognite_neat-0.83.0/cognite/neat/_version.py

@@ -1 +0,0 @@
-__version__ = "0.83.0"

cognite_neat-0.83.0/cognite/neat/utils/upload.py

@@ -1,86 +0,0 @@
-from abc import ABC
-from dataclasses import dataclass, field
-from functools import total_ordering
-
-from cognite.neat.issues import NeatIssueList
-
-
-@total_ordering
-@dataclass
-class UploadResultCore(ABC):
-    name: str
-    error_messages: list[str] = field(default_factory=list)
-    issues: NeatIssueList = field(default_factory=NeatIssueList)
-
-    def __lt__(self, other: object) -> bool:
-        if isinstance(other, UploadDiffsCount):
-            return self.name < other.name
-        else:
-            return NotImplemented
-
-    def __eq__(self, other: object) -> bool:
-        if isinstance(other, UploadDiffsCount):
-            return self.name == other.name
-        else:
-            return NotImplemented
-
-
-@dataclass
-class UploadDiffsCount(UploadResultCore):
-    created: int = 0
-    deleted: int = 0
-    changed: int = 0
-    unchanged: int = 0
-    skipped: int = 0
-    failed_created: int = 0
-    failed_changed: int = 0
-    failed_deleted: int = 0
-
-    @property
-    def total(self) -> int:
-        return self.created + self.deleted + self.changed + self.unchanged
-
-    @property
-    def failed(self) -> int:
-        return self.failed_created + self.failed_changed + self.failed_deleted
-
-    def as_report_str(self) -> str:
-        line = []
-        if self.created:
-            line.append(f"created {self.created}")
-        if self.changed:
-            line.append(f"updated {self.changed}")
-        if self.skipped:
-            line.append(f"skipped {self.skipped}")
-        if self.unchanged:
-            line.append(f"unchanged {self.unchanged}")
-        if self.deleted:
-            line.append(f"deleted {self.deleted}")
-        if self.failed_created:
-            line.append(f"failed to create {self.failed_created}")
-        if self.failed_changed:
-            line.append(f"failed to update {self.failed_changed}")
-        if self.failed_deleted:
-            line.append(f"failed to delete {self.failed_deleted}")
-
-        return f"{self.name.title()}: {', '.join(line)}"
-
-
-@dataclass
-class UploadResultIDs(UploadResultCore):
-    success: list[str] = field(default_factory=list)
-    failed: list[str] = field(default_factory=list)
-
-
-@dataclass
-class UploadDiffsID(UploadResultCore):
-    created: list[str] = field(default_factory=list)
-    changed: list[str] = field(default_factory=list)
-    unchanged: list[str] = field(default_factory=list)
-    failed: list[str] = field(default_factory=list)
-
-    def as_upload_result_ids(self) -> UploadResultIDs:
-        result = UploadResultIDs(name=self.name, error_messages=self.error_messages, issues=self.issues)
-        result.success = self.created + self.changed + self.unchanged
-        result.failed = self.failed
-        return result