added test for unhashable exceptions and touched up exception messages

pydra/engine/specs.py

@@ -1000,8 +1000,8 @@ def get_value(
                 "types across multiple processes (see bytes_repr() "
                 '"singledispatch "function in pydra/utils/hash.py).'
                 "You may need to implement a specific `bytes_repr()` "
-                '"singledispatch overload"s or `__bytes_repr__()` '
-                "dunder methods to handle one or more types in "
+                "implementations (see pydra.utils.hash.register_serializer) or a "
+                "`__bytes_repr__()` dunder methods to handle one or more types in "
                 "your interface inputs."
             )
         _, split_depth = TypeParser.strip_splits(self.type)

pydra/engine/submitter.py

@@ -229,9 +229,9 @@ async def expand_workflow(self, wf, rerun=False):
                                 "types across multiple processes (see bytes_repr() "
                                 '"singledispatch "function in pydra/utils/hash.py).'
                                 "You may need to implement a specific `bytes_repr()` "
-                                '"singledispatch overload"s or `__bytes_repr__()` '
-                                "dunder methods to handle one or more types in "
-                                "your interface inputs."
+                                "implementation (see pydra.utils.hash.register_serializer) "
+                                "s or `__bytes_repr__()` dunder methods to handle one "
+                                "or more types in your interface inputs."
                             )
                         raise RuntimeError(msg)
             for task in tasks:

pydra/utils/hash.py

@@ -220,7 +220,16 @@ def hash_object(
     try:
         return hash_single(obj, cache)
     except Exception as e:
-        add_exc_note(e, f"Therefore cannot hash object {obj!r}")
+        tp = type(obj)
+        add_exc_note(
+            e,
+            (
+                f"and therefore cannot hash `{obj!r}` of type "
+                f"`{tp.__module__}.{tp.__name__}`. Consider implementing a "
+                "specific `bytes_repr()`(see pydra.utils.hash.register_serializer) "
+                "or a `__bytes_repr__()` dunder methods for this type"
+            ),
+        )
         raise e
 
 

pydra/utils/tests/test_hash.py

@@ -385,3 +385,28 @@ def test_persistent_hash_cache_not_dir(text_file):
     """
     with pytest.raises(ValueError, match="is not a directory"):
         PersistentCache(text_file.fspath)
+
+
+def test_unhashable():
+    """
+    Test that an error is raised if an unhashable object is provided
+    """
+
+    class A:
+
+        def __bytes_repr__(self, cache: Cache) -> ty.Generator[bytes, None, None]:
+            raise TypeError("unhashable")
+
+        def __repr__(self):
+            return "A()"
+
+    # hash_object(A())
+
+    with pytest.raises(
+        TypeError,
+        match=(
+            "unhashable\nand therefore cannot hash `A\(\)` of type "
+            "`pydra.utils.tests.test_hash.A`"
+        ),
+    ):
+        hash_object(A())