Merge pull request #734 from jmmshn/jmmshn/strict

allow `strict="skip"` for `jsanitize`

Author: shyuep

src/monty/json.py

@@ -905,7 +905,8 @@ def jsanitize(
             jsanitize will try to get the as_dict() attribute of the object. If
             no such attribute is found, an attribute error will be thrown. If
             strict is False, jsanitize will simply call str(object) to convert
-            the object to a string representation.
+            the object to a string representation.  If "skip" is provided,
+            jsanitize will skip and return the original object without modification.
         allow_bson (bool): This parameter sets the behavior when jsanitize
             encounters a bson supported type such as objectid and datetime. If
             True, such bson types will be ignored, allowing for proper
@@ -1009,7 +1010,7 @@ def jsanitize(
         except AttributeError:
             pass
 
-    if not strict:
+    if strict is False:
         return str(obj)
 
     if isinstance(obj, str):
@@ -1024,13 +1025,18 @@ def jsanitize(
             recursive_msonable=recursive_msonable,
         )
 
-    return jsanitize(
-        obj.as_dict(),
-        strict=strict,
-        allow_bson=allow_bson,
-        enum_values=enum_values,
-        recursive_msonable=recursive_msonable,
-    )
+    try:
+        return jsanitize(
+            obj.as_dict(),
+            strict=strict,
+            allow_bson=allow_bson,
+            enum_values=enum_values,
+            recursive_msonable=recursive_msonable,
+        )
+    except Exception as exc_:
+        if strict == "skip":
+            return obj
+        raise exc_
 
 
 def _serialize_callable(o):

tests/test_json.py

@@ -875,6 +875,50 @@ def test_jsanitize(self):
         clean = jsanitize(d, strict=True)
         assert "@class" in clean["c"]
 
+    def test_unserializable_composite(self):
+        class Unserializable:
+            def __init__(self, a):
+                self._a = a
+
+            def __str__(self):
+                return "Unserializable"
+
+        class Composite(MSONable):
+            def __init__(self, name, unserializable, msonable):
+                self.name = name
+                self.unserializable = unserializable
+                self.msonable = msonable
+
+        composite_dictionary = {
+            "name": "test",
+            "unserializable": Unserializable(1),
+            "msonable": GoodMSONClass(1, 2, 3),
+        }
+
+        with pytest.raises(AttributeError):
+            jsanitize(composite_dictionary, strict=True)
+
+        composite_obj = Composite.from_dict(composite_dictionary)
+
+        with pytest.raises(AttributeError):
+            jsanitize(composite_obj, strict=True)
+
+        # Test that skip mode preserves unserializable objects
+        skipped_dict = jsanitize(composite_obj, strict="skip", recursive_msonable=True)
+        assert skipped_dict["name"] == "test", "String values should remain unchanged"
+        assert (
+            skipped_dict["unserializable"]._a == 1
+        ), "Unserializable object should be preserved in skip mode"
+        assert (
+            skipped_dict["msonable"]["a"] == 1
+        ), "MSONable object should be properly serialized"
+
+        # Test non-strict mode converts unserializable to string
+        dict_with_str = jsanitize(composite_obj, strict=False, recursive_msonable=True)
+        assert isinstance(
+            dict_with_str["unserializable"], str
+        ), "Unserializable object should be converted to string in non-strict mode"
+
     @pytest.mark.skipif(pd is None, reason="pandas not present")
     def test_jsanitize_pandas(self):
         s = pd.Series({"a": [1, 2, 3], "b": [4, 5, 6]})