Fix __parameters__ access in gen._generate_mapping

There are Generic types in the typing modules
from which you can inherit in your own classes
which do not have an __parameters__ attribute,
such classes are now ignored making
gen._generate_mapping effectively a no-op
in case the class do not have an __parameters__
attribute.

As https://github.com/ilevkivskyi/typing_inspect/blob/8f6aa2075ba448ab322def454137e7c59b9b302d/typing_inspect.py#L405
is showing there are also cases where __parameters__
could be None, so I test for both cases, that it
is None or that it does not exist.

See Also:
python-attrs#217

src/cattrs/gen.py

@@ -204,7 +204,17 @@ def _generate_mapping(
  cl: Type, old_mapping: Dict[str, type]
 ) -> Dict[str, type]:
  mapping = {}
- for p, t in zip(get_origin(cl).__parameters__, get_args(cl)):
+
+ # To handle the cases where classes in the typing module are using
+ # the GenericAlias structure but aren’t a Generic and hence
+ # end up in this function but do not have an `__parameters__`
+ # attribute. These classes are interface types, for example
+ # `typing.Hashable`.
+ parameters = getattr(get_origin(cl), "__parameters__", None)
+ if parameters is None:
+ return old_mapping
+
+ for p, t in zip(parameters, get_args(cl)):
  if isinstance(t, TypeVar):
  continue
  mapping[p.__name__] = t

tests/test_converter_inheritance.py

@@ -1,3 +1,5 @@
+import collections
+import typing
 from typing import Type
 
 import attr
@@ -43,3 +45,58 @@ class B(A):
 
  # This should still work, but using the new hook instead.
  assert converter.structure({"i": 1}, B) == B(2)
+
+
+@pytest.mark.parametrize("converter_cls", [Converter, GenConverter])
+@pytest.mark.parametrize(
+ "typing_cls", [typing.Hashable, typing.Iterable, typing.Reversible]
+)
+def test_inherit_typing(converter_cls: Type[Converter], typing_cls):
+ """Stuff from typing.* resolves to runtime to collections.abc.*.
+
+ Hence, typing.* are of a special alias type which we want to check if
+ cattrs handles them correctly.
+ """
+ converter = converter_cls()
+
+ @attr.define
+ class A(typing_cls):
+ i: int = 0
+
+ def __hash__(self):
+ return hash(self.i)
+
+ def __iter__(self):
+ return iter([self.i])
+
+ def __reversed__(self):
+ return iter([self.i])
+
+ assert converter.structure({"i": 1}, A) == A(i=1)
+
+
+@pytest.mark.parametrize("converter_cls", [Converter, GenConverter])
+@pytest.mark.parametrize(
+ "collections_abc_cls",
+ [collections.abc.Hashable, collections.abc.Iterable, collections.abc.Reversible],
+)
+def test_inherit_collections_abc(
+ converter_cls: Type[Converter], collections_abc_cls
+):
+ """As extension of test_inherit_typing, check if collections.abc.* work."""
+ converter = converter_cls()
+
+ @attr.define
+ class A(collections_abc_cls):
+ i: int = 0
+
+ def __hash__(self):
+ return hash(self.i)
+
+ def __iter__(self):
+ return iter([self.i])
+
+ def __reversed__(self):
+ return iter([self.i])
+
+ assert converter.structure({"i": 1}, A) == A(i=1)