Pull threading.local out of the generated repr's globals.

Generated `__repr__` methods for Pythons with f-strings included
a `threading.local` object in that method's `globals()` dictionary.
Because `cloudpickle` attempts to serialize all globals of this method,
it ends up trying to pickle the `threading.local`, which cannot be
pickled.

Instead, we now pull use of the thread-local out into its own function,
which `cloudpickle` will happily serialize. As an added benefit, this
eliminates some duplicated code between f-string and non–f-string
`__repr__`s.

Should fix:

- #458
- cloudpipe/cloudpickle#320

changelog.d/857.change.rst

@@ -0,0 +1 @@
+Fixes ``cloudpickle`` compatibility issue, allowing attrs classes to be safely pickled using CloudPickle.

src/attr/_make.py

@@ -1,5 +1,6 @@
 from __future__ import absolute_import, division, print_function
 
+import contextlib
 import copy
 import inspect
 import linecache
@@ -1872,7 +1873,38 @@ def _add_eq(cls, attrs=None):
 # For instance, if an instance contains a dict which contains that instance,
 # we need to know that we're already repr'ing the outside instance from within
 # the dict's repr() call.
-_already_repring = threading.local()
+_repr_context = threading.local()
+
+
+@contextlib.contextmanager
+def _is_already_repring(inst):
+    """
+    Checks whether the given instance of this class is already being repr'd.
+    If not, sets up the thread-local context to record that we are repr'ing
+    this instance.
+
+    Yields ``True`` if we're already repr'ing this class;
+    ``False`` if we are not already repr'ing it.
+    """
+    try:
+        working_set = _repr_context.working_set
+    except AttributeError:
+        # Since 'inst' remains on the stack (i.e.: strongly referenced)
+        # for the duration of this call, it's safe to depend on id(...)
+        # stability, and not need to track the instance and therefore
+        # worry about properties like weakref- or hash-ability.
+        _repr_context.working_set = working_set = {id(inst)}
+        was_repring = False
+    else:
+        was_repring = id(inst) in working_set
+        if not was_repring:
+            working_set.add(id(inst))
+    try:
+        yield was_repring
+    finally:
+        if not was_repring:
+            working_set.remove(id(inst))
+
 
 if HAS_F_STRINGS:
 
@@ -1891,7 +1923,7 @@ def _make_repr(attrs, ns, cls):
             for name, r, _ in attr_names_with_reprs
             if r != repr
         }
-        globs["_already_repring"] = _already_repring
+        globs["_is_already_repring"] = _is_already_repring
         globs["AttributeError"] = AttributeError
         globs["NOTHING"] = NOTHING
         attribute_fragments = []
@@ -1916,24 +1948,13 @@ def _make_repr(attrs, ns, cls):
         else:
             cls_name_fragment = ns + ".{self.__class__.__name__}"
 
-        lines = []
-        lines.append("def __repr__(self):")
-        lines.append("  try:")
-        lines.append("    working_set = _already_repring.working_set")
-        lines.append("  except AttributeError:")
-        lines.append("    working_set = {id(self),}")
-        lines.append("    _already_repring.working_set = working_set")
-        lines.append("  else:")
-        lines.append("    if id(self) in working_set:")
-        lines.append("      return '...'")
-        lines.append("    else:")
-        lines.append("      working_set.add(id(self))")
-        lines.append("  try:")
-        lines.append(
-            "    return f'%s(%s)'" % (cls_name_fragment, repr_fragment)
-        )
-        lines.append("  finally:")
-        lines.append("    working_set.remove(id(self))")
+        lines = [
+            "def __repr__(self):",
+            "  with _is_already_repring(self) as already:",
+            "    if already:",
+            "      return '...'",
+            "    return f'%s(%s)'" % (cls_name_fragment, repr_fragment),
+        ]
 
         return _make_method(
             "__repr__", "\n".join(lines), unique_filename, globs=globs
@@ -1961,34 +1982,24 @@ def __repr__(self):
             """
             Automatically created by attrs.
             """
-            try:
-                working_set = _already_repring.working_set
-            except AttributeError:
-                working_set = set()
-                _already_repring.working_set = working_set
-
-            if id(self) in working_set:
-                return "..."
-            real_cls = self.__class__
-            if ns is None:
-                qualname = getattr(real_cls, "__qualname__", None)
-                if qualname is not None:  # pragma: no cover
-                    # This case only happens on Python 3.5 and 3.6. We exclude
-                    # it from coverage, because we don't want to slow down our
-                    # test suite by running them under coverage too for this
-                    # one line.
-                    class_name = qualname.rsplit(">.", 1)[-1]
+            with _is_already_repring(self) as was_repring:
+                if was_repring:
+                    return "..."
+
+                real_cls = self.__class__
+                if ns is None:
+                    qualname = getattr(real_cls, "__qualname__", None)
+                    if qualname is not None:  # pragma: no cover
+                        # This case only happens on Python 3.5 and 3.6.
+                        # We exclude it from coverage, because we don't want to
+                        # slow down our test suite by running them under
+                        # coverage too for this one line.
+                        class_name = qualname.rsplit(">.", 1)[-1]
+                    else:
+                        class_name = real_cls.__name__
                 else:
-                    class_name = real_cls.__name__
-            else:
-                class_name = ns + "." + real_cls.__name__
+                    class_name = ns + "." + real_cls.__name__
 
-            # Since 'self' remains on the stack (i.e.: strongly referenced)
-            # for the duration of this call, it's safe to depend on id(...)
-            # stability, and not need to track the instance and therefore
-            # worry about properties like weakref- or hash-ability.
-            working_set.add(id(self))
-            try:
                 result = [class_name, "("]
                 first = True
                 for name, attr_repr in attr_names_with_reprs:
@@ -2000,8 +2011,6 @@ def __repr__(self):
                         (name, "=", attr_repr(getattr(self, name, NOTHING)))
                     )
                 return "".join(result) + ")"
-            finally:
-                working_set.remove(id(self))
 
         return __repr__