Address review comment regarding the err messages

Signed-off-by: Jared O'Connell <[email protected]>

Author: jaredoconnell

src/guidellm/data/deserializers/deserializer.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import contextlib
 from collections.abc import Callable
 from typing import Any, Protocol, Union, runtime_checkable
 
@@ -47,30 +46,16 @@ def deserialize(
         remove_columns: list[str] | None = None,
         **data_kwargs: dict[str, Any],
     ) -> Dataset | IterableDataset:
-        dataset: Dataset | None = None
+        dataset: Dataset
 
         if type_ is None:
             dataset = cls._deserialize_with_registered_deserializers(
                 data, processor_factory, random_seed, **data_kwargs
             )
 
-        elif (deserializer_from_type := cls.get_registered_object(type_)) is not None:
-            if isinstance(deserializer_from_type, type):
-                deserializer_fn = deserializer_from_type()
-            else:
-                deserializer_fn = deserializer_from_type
-
-            dataset = deserializer_fn(
-                data=data,
-                processor_factory=processor_factory,
-                random_seed=random_seed,
-                **data_kwargs,
-            )
-
-        if dataset is None:
-            raise DataNotSupportedError(
-                f"No suitable deserializer found for data {data} "
-                f"with kwargs {data_kwargs} and deserializer type {type_}."
+        else:
+            dataset = cls._deserialize_with_specified_deserializer(
+                data, type_, processor_factory, random_seed, **data_kwargs
             )
 
         if resolve_split:
@@ -99,7 +84,7 @@ def _deserialize_with_registered_deserializers(
             raise RuntimeError("registry is None; cannot deserialize dataset")
         dataset: Dataset | None = None
 
-        errors = []
+        errors: dict[str, Exception] = {}
         # Note: There is no priority order for the deserializers, so all deserializers
         #  must be mutually exclusive to ensure deterministic behavior.
         for _name, deserializer in cls.registry.items():
@@ -108,22 +93,52 @@ def _deserialize_with_registered_deserializers(
             )
 
             try:
-                with contextlib.suppress(DataNotSupportedError):
-                    dataset = deserializer_fn(
-                        data=data,
-                        processor_factory=processor_factory,
-                        random_seed=random_seed,
-                        **data_kwargs,
-                    )
+                dataset = deserializer_fn(
+                    data=data,
+                    processor_factory=processor_factory,
+                    random_seed=random_seed,
+                    **data_kwargs,
+                )
             except Exception as e:  # noqa: BLE001 # The exceptions are saved.
-                errors.append(e)
+                errors[_name] = e
 
             if dataset is not None:
-                break  # Found one that works. Continuing could overwrite it.
-
-        if dataset is None and len(errors) > 0:
-            raise DataNotSupportedError(
-                f"data deserialization failed; {len(errors)} errors occurred while "
-                f"attempting to deserialize data {data}: {errors}"
+                return dataset  # Success
+
+        if len(errors) > 0:
+            err_msgs = ""
+            def sort_key(item):
+                return (isinstance(item[1], DataNotSupportedError), item[0])
+            for key, err in sorted(errors.items(), key=sort_key):
+                err_msgs += f"\n  - Deserializer '{key}': ({type(err).__name__}) {err}"
+            raise ValueError(
+                "Data deserialization failed, likely because the input doesn't "
+                f"match any of the input formats. See the {len(errors)} error(s) that "
+                f"occurred while attempting to deserialize the data {data}:{err_msgs}"
             )
         return dataset
+
+    @classmethod
+    def _deserialize_with_specified_deserializer(
+        cls,
+        data: Any,
+        type_: str,
+        processor_factory: Callable[[], PreTrainedTokenizerBase],
+        random_seed: int = 42,
+        **data_kwargs: dict[str, Any],
+    ) -> Dataset:
+        deserializer_from_type = cls.get_registered_object(type_)
+        if deserializer_from_type is None:
+            raise ValueError(f"Deserializer type '{type_}' is not registered.")
+        if isinstance(deserializer_from_type, type):
+            deserializer_fn = deserializer_from_type()
+        else:
+            deserializer_fn = deserializer_from_type
+
+        return deserializer_fn(
+            data=data,
+            processor_factory=processor_factory,
+            random_seed=random_seed,
+            **data_kwargs,
+        )
+