Improve performance of asdict in the common case (#1463)

* Improve performance of asdict in the common case

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* fix for python 3.9

* fix for python3.9

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* coverage

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* docstring

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* add benchmark for asdict

* Remove now-redundant benchmark

* Fix test docstring

* Add news fragment

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Hynek Schlawack <hs@ox.cx>

Author: 3 people

changelog.d/1463.change.md

@@ -0,0 +1 @@
+The performance of `attrs.asdict()` has been improved by 45–260%.

src/attr/_funcs.py

@@ -8,6 +8,23 @@
 from .exceptions import AttrsAttributeNotFoundError
 
 
+_ATOMIC_TYPES = frozenset(
+    {
+        type(None),
+        bool,
+        int,
+        float,
+        str,
+        complex,
+        bytes,
+        type(...),
+        type,
+        range,
+        property,
+    }
+)
+
+
 def asdict(
     inst,
     recurse=True,
@@ -71,7 +88,10 @@ def asdict(
             v = value_serializer(inst, a, v)
 
         if recurse is True:
-            if has(v.__class__):
+            value_type = type(v)
+            if value_type in _ATOMIC_TYPES:
+                rv[a.name] = v
+            elif has(value_type):
                 rv[a.name] = asdict(
                     v,
                     recurse=True,
@@ -80,8 +100,8 @@ def asdict(
                     retain_collection_types=retain_collection_types,
                     value_serializer=value_serializer,
                 )
-            elif isinstance(v, (tuple, list, set, frozenset)):
-                cf = v.__class__ if retain_collection_types is True else list
+            elif issubclass(value_type, (tuple, list, set, frozenset)):
+                cf = value_type if retain_collection_types is True else list
                 items = [
                     _asdict_anything(
                         i,
@@ -101,7 +121,7 @@ def asdict(
                     # Workaround for TypeError: cf.__new__() missing 1 required
                     # positional argument (which appears, for a namedturle)
                     rv[a.name] = cf(*items)
-            elif isinstance(v, dict):
+            elif issubclass(value_type, dict):
                 df = dict_factory
                 rv[a.name] = df(
                     (
@@ -142,7 +162,12 @@ def _asdict_anything(
     """
     ``asdict`` only works on attrs instances, this works on anything.
     """
-    if getattr(val.__class__, "__attrs_attrs__", None) is not None:
+    val_type = type(val)
+    if val_type in _ATOMIC_TYPES:
+        rv = val
+        if value_serializer is not None:
+            rv = value_serializer(None, None, rv)
+    elif getattr(val_type, "__attrs_attrs__", None) is not None:
         # Attrs class.
         rv = asdict(
             val,
@@ -152,7 +177,7 @@ def _asdict_anything(
             retain_collection_types=retain_collection_types,
             value_serializer=value_serializer,
         )
-    elif isinstance(val, (tuple, list, set, frozenset)):
+    elif issubclass(val_type, (tuple, list, set, frozenset)):
         if retain_collection_types is True:
             cf = val.__class__
         elif is_key:
@@ -173,7 +198,7 @@ def _asdict_anything(
                 for i in val
             ]
         )
-    elif isinstance(val, dict):
+    elif issubclass(val_type, dict):
         df = dict_factory
         rv = df(
             (

tests/test_funcs.py

@@ -66,6 +66,22 @@ def test_recurse(self, C, dict_class):
             C(C(1, 2), C(3, 4)), dict_factory=dict_class
         )
 
+    def test_non_atomic_types(self, C):
+        """
+        Non-atomic types that don't have special treatment for are serialized
+        and the types are retained.
+        """
+
+        class Int(int):
+            pass
+
+        c = C(Int(10), [Int(1), 2])
+        expected = {"x": 10, "y": [1, 2]}
+
+        assert expected == asdict(c)
+        assert type(asdict(c)["x"]) is Int
+        assert type(asdict(c)["y"][0]) is Int
+
     def test_nested_lists(self, C):
         """
         Test unstructuring deeply nested lists.