Use a context variable to pass Schema context

src/marshmallow/experimental/__init__.py

@@ -0,0 +1,5 @@
+"""Experimental features.
+
+The features in this subpackage are experimental. Breaking changes may be
+introduced in minor marshmallow versions.
+"""

src/marshmallow/experimental/context.py

@@ -0,0 +1,25 @@
+"""Helper API for setting serialization/deserialization context."""
+
+import contextlib
+import contextvars
+import typing
+
+_T = typing.TypeVar("_T")
+_CURRENT_CONTEXT: contextvars.ContextVar = contextvars.ContextVar("context")
+
+
+class Context(contextlib.AbstractContextManager, typing.Generic[_T]):
+    def __init__(self, context: _T) -> None:
+        self.context = context
+
+    def __enter__(self) -> None:
+        self.token = _CURRENT_CONTEXT.set(self.context)
+
+    def __exit__(self, *args, **kwargs) -> None:
+        _CURRENT_CONTEXT.reset(self.token)
+
+    @classmethod
+    def get(cls, default=...) -> _T:
+        if default is not ...:
+            return _CURRENT_CONTEXT.get(default)
+        return _CURRENT_CONTEXT.get()

src/marshmallow/fields.py

@@ -395,13 +395,6 @@ def _deserialize(
         """
         return value
 
-    # Properties
-
-    @property
-    def context(self):
-        """The context dictionary for the parent :class:`Schema`."""
-        return self.parent.context
-
 
 class Raw(Field):
     """Field that applies no formatting."""
@@ -498,8 +491,6 @@ def schema(self):
             Renamed from `serializer` to `schema`.
         """
         if not self._schema:
-            # Inherit context from parent.
-            context = getattr(self.parent, "context", {})
             if callable(self.nested) and not isinstance(self.nested, type):
                 nested = self.nested()
             else:
@@ -512,7 +503,6 @@ def schema(self):
 
             if isinstance(nested, SchemaABC):
                 self._schema = copy.copy(nested)
-                self._schema.context.update(context)
                 # Respect only and exclude passed from parent and re-initialize fields
                 set_class = self._schema.set_class
                 if self.only is not None:
@@ -539,7 +529,6 @@ def schema(self):
                     many=self.many,
                     only=self.only,
                     exclude=self.exclude,
-                    context=context,
                     load_only=self._nested_normalized_option("load_only"),
                     dump_only=self._nested_normalized_option("dump_only"),
                 )
@@ -1909,14 +1898,12 @@ class Function(Field):
 
     :param serialize: A callable from which to retrieve the value.
         The function must take a single argument ``obj`` which is the object
-        to be serialized. It can also optionally take a ``context`` argument,
-        which is a dictionary of context variables passed to the serializer.
+        to be serialized.
         If no callable is provided then the ```load_only``` flag will be set
         to True.
     :param deserialize: A callable from which to retrieve the value.
         The function must take a single argument ``value`` which is the value
-        to be deserialized. It can also optionally take a ``context`` argument,
-        which is a dictionary of context variables passed to the deserializer.
+        to be deserialized.
         If no callable is provided then ```value``` will be passed through
         unchanged.
 
@@ -1951,21 +1938,13 @@ def __init__(
         self.deserialize_func = deserialize and utils.callable_or_raise(deserialize)
 
     def _serialize(self, value, attr, obj, **kwargs):
-        return self._call_or_raise(self.serialize_func, obj, attr)
+        return self.serialize_func(obj)
 
     def _deserialize(self, value, attr, data, **kwargs):
         if self.deserialize_func:
-            return self._call_or_raise(self.deserialize_func, value, attr)
+            return self.deserialize_func(value)
         return value
 
-    def _call_or_raise(self, func, value, attr):
-        if len(utils.get_func_args(func)) > 1:
-            if self.parent.context is None:
-                msg = f"No context available for Function field {attr!r}"
-                raise ValidationError(msg)
-            return func(value, self.parent.context)
-        return func(value)
-
 
 class Constant(Field):
     """A field that (de)serializes to a preset constant.  If you only want the

src/marshmallow/schema.py

@@ -248,8 +248,6 @@ class AlbumSchema(Schema):
         delimiters.
     :param many: Should be set to `True` if ``obj`` is a collection
         so that the object will be serialized to a list.
-    :param context: Optional context passed to :class:`fields.Method` and
-        :class:`fields.Function` fields.
     :param load_only: Fields to skip during serialization (write-only fields)
     :param dump_only: Fields to skip during deserialization (read-only fields)
     :param partial: Whether to ignore missing fields and not require
@@ -346,7 +344,6 @@ def __init__(
         only: types.StrSequenceOrSet | None = None,
         exclude: types.StrSequenceOrSet = (),
         many: bool | None = None,
-        context: dict | None = None,
         load_only: types.StrSequenceOrSet = (),
         dump_only: types.StrSequenceOrSet = (),
         partial: bool | types.StrSequenceOrSet | None = None,
@@ -373,7 +370,6 @@ def __init__(
             if unknown is None
             else validate_unknown_parameter_value(unknown)
         )
-        self.context = context or {}
         self._normalize_nested_options()
         #: Dictionary mapping field_names -> :class:`Field` objects
         self.fields = {}  # type: dict[str, ma_fields.Field]

src/marshmallow/utils.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import datetime as dt
-import functools
 import inspect
 import typing
 from collections.abc import Mapping
@@ -242,21 +241,6 @@ def _signature(func: typing.Callable) -> list[str]:
     return list(inspect.signature(func).parameters.keys())
 
 
-def get_func_args(func: typing.Callable) -> list[str]:
-    """Given a callable, return a list of argument names. Handles
-    `functools.partial` objects and class-based callables.
-
-    .. versionchanged:: 3.0.0a1
-        Do not return bound arguments, eg. ``self``.
-    """
-    if inspect.isfunction(func) or inspect.ismethod(func):
-        return _signature(func)
-    if isinstance(func, functools.partial):
-        return _signature(func.func)
-    # Callable class
-    return _signature(func)
-
-
 def resolve_field_instance(cls_or_instance):
     """Return a Schema instance from a Schema class or instance.