PR feedback, lint stuff

Author: Diego Argueta

src/desert/_make.py

@@ -54,7 +54,7 @@ class User:
       Schema: t.ClassVar[Type[Schema]] = Schema # For the type checker
 """
 
-import collections.abc as coll_abc
+import collections.abc
 import dataclasses
 import datetime
 import decimal
@@ -245,7 +245,14 @@ def field_for_schema(
     if origin:
         arguments = typing_inspect.get_args(typ, True)
 
-        if origin in (list, t.List, coll_abc.Sequence, coll_abc.MutableSequence):
+        if origin in (
+            list,
+            t.List,
+            t.Sequence,
+            t.MutableSequence,
+            collections.abc.Sequence,
+            collections.abc.MutableSequence,
+        ):
             field = marshmallow.fields.List(field_for_schema(arguments[0]))
 
         if origin in (tuple, t.Tuple) and Ellipsis not in arguments:
@@ -257,7 +264,14 @@ def field_for_schema(
             field = VariadicTuple(
                 field_for_schema(only(arg for arg in arguments if arg != Ellipsis))
             )
-        elif origin in (dict, t.Dict, coll_abc.Mapping, coll_abc.MutableMapping):
+        elif origin in (
+            dict,
+            t.Dict,
+            t.Mapping,
+            t.MutableMapping,
+            collections.abc.Mapping,
+            collections.abc.MutableMapping,
+        ):
             field = marshmallow.fields.Dict(
                 keys=field_for_schema(arguments[0]),
                 values=field_for_schema(arguments[1]),

tests/test_make.py

@@ -166,24 +166,24 @@ class A:
 @pytest.mark.parametrize("annotation_class", (t.List, t.Sequence, t.MutableSequence))
 def test_list(module: DataclassModule, annotation_class: type) -> None:
     """Build a generic list *without* setting a factory on the dataclass."""
-    klass = type("A", (object,), {"__annotations__": {"y": annotation_class[int]}})
-    A = module.dataclass(klass)
+    cls = type("A", (object,), {"__annotations__": {"y": annotation_class[int]}})
+    A = module.dataclass(cls)
 
     schema = desert.schema_class(A)()
     data = schema.load({"y": [1]})
-    assert data == A([1])  # type: ignore[call-arg]
+    assert data == A([1])
 
 
 @pytest.mark.parametrize("annotation_class", (t.Dict, t.Mapping, t.MutableMapping))
 def test_dict(module: DataclassModule, annotation_class: type) -> None:
     """Build a dict without setting a factory on the dataclass."""
-    klass = type("A", (object,), {"__annotations__": {"y": annotation_class[int, int]}})
-    A = module.dataclass(klass)
+    cls = type("A", (object,), {"__annotations__": {"y": annotation_class[int, int]}})
+    A = module.dataclass(cls)
 
     schema = desert.schema_class(A)()
     data = schema.load({"y": {1: 2, 3: 4}})
 
-    assert data == A({1: 2, 3: 4})  # type: ignore[call-arg]
+    assert data == A({1: 2, 3: 4})
 
 
 def test_nested(module: DataclassModule) -> None: