AI junk

CHANGES.rst

@@ -3,8 +3,9 @@ Version 2.3.0
 
 Unreleased
 
--   Drop support for Python 3.8 and 3.9.
--   Remove previously deprecated code.
+-   Add ``deserializer_kwargs`` to ``Serializer``. These are passed to
+    ``serializer.loads`` during ``load_payload``, matching
+    ``serializer_kwargs`` for ``dumps``. :issue:`389`
 
 
 Version 2.2.0

src/itsdangerous/serializer.py

@@ -60,6 +60,11 @@ class Serializer(t.Generic[_TSerialized]):
         :attr:`default_serializer`, which defaults to :mod:`json`.
     :param serializer_kwargs: Keyword arguments to pass when calling
         ``serializer.dumps``.
+    :param deserializer_kwargs: Keyword arguments to pass when calling
+        ``serializer.loads``. These are stored separately because
+        ``dumps`` and ``loads`` often accept different options (for
+        example ``json.dumps(..., skipkeys=True)`` is not valid for
+        ``json.loads``).
     :param signer: A ``Signer`` class to instantiate when signing data.
         Defaults to :attr:`default_signer`, which defaults to
         :class:`~itsdangerous.signer.Signer`.
@@ -71,6 +76,9 @@ class Serializer(t.Generic[_TSerialized]):
         ``(signer, signer_kwargs)``. Defaults to
         :attr:`default_fallback_signers`.
 
+    .. versionchanged:: 2.3
+        Added ``deserializer_kwargs``, passed to ``serializer.loads``.
+
     .. versionchanged:: 2.0
         Added support for key rotation by passing a list to
         ``secret_key``.
@@ -111,6 +119,7 @@ def __init__(
         salt: str | bytes | None = b"itsdangerous",
         serializer: None | _PDataSerializer[str] = None,
         serializer_kwargs: dict[str, t.Any] | None = None,
+        deserializer_kwargs: dict[str, t.Any] | None = None,
         signer: type[Signer] | None = None,
         signer_kwargs: dict[str, t.Any] | None = None,
         fallback_signers: list[
@@ -127,6 +136,7 @@ def __init__(
         salt: str | bytes | None,
         serializer: _PDataSerializer[bytes],
         serializer_kwargs: dict[str, t.Any] | None = None,
+        deserializer_kwargs: dict[str, t.Any] | None = None,
         signer: type[Signer] | None = None,
         signer_kwargs: dict[str, t.Any] | None = None,
         fallback_signers: list[
@@ -144,6 +154,7 @@ def __init__(
         *,
         serializer: _PDataSerializer[bytes],
         serializer_kwargs: dict[str, t.Any] | None = None,
+        deserializer_kwargs: dict[str, t.Any] | None = None,
         signer: type[Signer] | None = None,
         signer_kwargs: dict[str, t.Any] | None = None,
         fallback_signers: list[
@@ -162,6 +173,7 @@ def __init__(
         salt: str | bytes | None,
         serializer: t.Any,
         serializer_kwargs: dict[str, t.Any] | None = None,
+        deserializer_kwargs: dict[str, t.Any] | None = None,
         signer: type[Signer] | None = None,
         signer_kwargs: dict[str, t.Any] | None = None,
         fallback_signers: list[
@@ -179,6 +191,7 @@ def __init__(
         *,
         serializer: t.Any,
         serializer_kwargs: dict[str, t.Any] | None = None,
+        deserializer_kwargs: dict[str, t.Any] | None = None,
         signer: type[Signer] | None = None,
         signer_kwargs: dict[str, t.Any] | None = None,
         fallback_signers: list[
@@ -193,6 +206,7 @@ def __init__(
         salt: str | bytes | None = b"itsdangerous",
         serializer: t.Any | None = None,
         serializer_kwargs: dict[str, t.Any] | None = None,
+        deserializer_kwargs: dict[str, t.Any] | None = None,
         signer: type[Signer] | None = None,
         signer_kwargs: dict[str, t.Any] | None = None,
         fallback_signers: list[
@@ -232,6 +246,7 @@ def __init__(
             dict[str, t.Any] | tuple[type[Signer], dict[str, t.Any]] | type[Signer]
         ] = fallback_signers
         self.serializer_kwargs: dict[str, t.Any] = serializer_kwargs or {}
+        self.deserializer_kwargs: dict[str, t.Any] = deserializer_kwargs or {}
 
     @property
     def secret_key(self) -> bytes:
@@ -252,15 +267,17 @@ def load_payload(
         if serializer is None:
             use_serializer = self.serializer
             is_text = self.is_text_serializer
+            loads_kwargs = self.deserializer_kwargs
         else:
             use_serializer = serializer
             is_text = is_text_serializer(serializer)
+            loads_kwargs = {}
 
         try:
             if is_text:
-                return use_serializer.loads(payload.decode("utf-8"))  # type: ignore[arg-type]
+                return use_serializer.loads(payload.decode("utf-8"), **loads_kwargs)  # type: ignore[arg-type]
 
-            return use_serializer.loads(payload)  # type: ignore[arg-type]
+            return use_serializer.loads(payload, **loads_kwargs)  # type: ignore[arg-type]
         except Exception as e:
             raise BadPayload(
                 "Could not load the payload because an exception"

tests/test_itsdangerous/test_serializer.py

@@ -152,6 +152,39 @@ def test_serializer_kwargs(self, serializer_factory):
 
         assert serializer.loads(serializer.dumps({(): 1})) == {}
 
+    def test_deserializer_kwargs(self, serializer_factory):
+        class Codec:
+            def dumps(self, obj, prefix=""):
+                return ";".join(f"{prefix}{k}={v}" for k, v in obj.items())
+
+            def loads(self, s, prefix=""):
+                out = {}
+                if not s:
+                    return out
+                for item in s.split(";"):
+                    key, value = item.split("=", 1)
+                    if prefix and key.startswith(prefix):
+                        key = key[len(prefix) :]
+                    out[int(key) if key.isdigit() else key] = value
+                return out
+
+        data = {0: "foo", 1: "bar"}
+        both = serializer_factory(
+            serializer=Codec(),
+            serializer_kwargs={"prefix": "id:"},
+            deserializer_kwargs={"prefix": "id:"},
+        )
+        assert both.loads(both.dumps(data)) == data
+
+        dumps_only = serializer_factory(
+            serializer=Codec(),
+            serializer_kwargs={"prefix": "id:"},
+        )
+        assert dumps_only.loads(dumps_only.dumps(data)) == {
+            "id:0": "foo",
+            "id:1": "bar",
+        }
+
     def test_fallback_signers(self, serializer_factory, value: Any):
         serializer = serializer_factory(signer_kwargs={"digest_method": hashlib.sha256})
         signed = serializer.dumps(value)