Merge pull request #322 from yukinarit/fix-more-type-errors

Fix more type errors

Author: yukinarit

serde/compat.py

@@ -33,7 +33,7 @@
 
 import typing_extensions
 import typing_inspect
-from typing_extensions import Type
+from typing_extensions import Type, TypeGuard
 
 if sys.version_info[:2] == (3, 7):
     Literal = typing_extensions.Literal
@@ -130,7 +130,7 @@ class SerdeSkip(Exception):
     """
 
 
-def get_origin(typ: Type[Any]) -> Optional[Any]:
+def get_origin(typ: Any) -> Optional[Any]:
     """
     Provide `get_origin` that works in all python versions.
     """
@@ -288,7 +288,7 @@ def union_args(typ: Union) -> Tuple[Type[Any], ...]:
     return tuple(types)
 
 
-def dataclass_fields(cls: Type[Any]) -> Iterator[dataclasses.Field]:
+def dataclass_fields(cls: Type[Any]) -> Iterator[dataclasses.Field]:  # type: ignore
     raw_fields = dataclasses.fields(cls)
 
     try:
@@ -341,33 +341,33 @@ def recursive(cls: TypeLike) -> None:
             lst.add(cls)
         elif is_opt(cls):
             lst.add(Optional)
-            arg = type_args(cls)
-            if arg:
-                recursive(arg[0])
+            args = type_args(cls)
+            if args:
+                recursive(args[0])
         elif is_union(cls):
             lst.add(Union)
             for arg in type_args(cls):
                 recursive(arg)
         elif is_list(cls) or is_set(cls):
             lst.add(List)
-            arg = type_args(cls)
-            if arg:
-                recursive(arg[0])
+            args = type_args(cls)
+            if args:
+                recursive(args[0])
         elif is_set(cls):
             lst.add(Set)
-            arg = type_args(cls)
-            if arg:
-                recursive(arg[0])
+            args = type_args(cls)
+            if args:
+                recursive(args[0])
         elif is_tuple(cls):
             lst.add(Tuple)
             for arg in type_args(cls):
                 recursive(arg)
         elif is_dict(cls):
             lst.add(Dict)
-            arg = type_args(cls)
-            if arg and len(arg) >= 2:
-                recursive(arg[0])
-                recursive(arg[1])
+            args = type_args(cls)
+            if args and len(args) >= 2:
+                recursive(args[0])
+                recursive(args[1])
         else:
             lst.add(cls)
 
@@ -393,21 +393,21 @@ def recursive(cls: TypeLike) -> None:
             for f in dataclass_fields(cls):
                 recursive(f.type)
         elif is_opt(cls):
-            arg = type_args(cls)
-            if arg:
-                recursive(arg[0])
+            args = type_args(cls)
+            if args:
+                recursive(args[0])
         elif is_list(cls) or is_set(cls):
-            arg = type_args(cls)
-            if arg:
-                recursive(arg[0])
+            args = type_args(cls)
+            if args:
+                recursive(args[0])
         elif is_tuple(cls):
             for arg in type_args(cls):
                 recursive(arg)
         elif is_dict(cls):
-            arg = type_args(cls)
-            if arg and len(arg) >= 2:
-                recursive(arg[0])
-                recursive(arg[1])
+            args = type_args(cls)
+            if args and len(args) >= 2:
+                recursive(args[0])
+                recursive(args[1])
 
     recursive(cls)
     return list(lst)
@@ -433,21 +433,21 @@ def recursive(cls: TypeLike) -> None:
             for f in dataclass_fields(cls):
                 recursive(f.type)
         elif is_opt(cls):
-            arg = type_args(cls)
-            if arg:
-                recursive(arg[0])
+            args = type_args(cls)
+            if args:
+                recursive(args[0])
         elif is_list(cls) or is_set(cls):
-            arg = type_args(cls)
-            if arg:
-                recursive(arg[0])
+            args = type_args(cls)
+            if args:
+                recursive(args[0])
         elif is_tuple(cls):
             for arg in type_args(cls):
                 recursive(arg)
         elif is_dict(cls):
-            arg = type_args(cls)
-            if arg and len(arg) >= 2:
-                recursive(arg[0])
-                recursive(arg[1])
+            args = type_args(cls)
+            if args and len(args) >= 2:
+                recursive(args[0])
+                recursive(args[1])
 
     recursive(cls)
     return list(lst)
@@ -695,7 +695,7 @@ def is_none(typ: Type[Any]) -> bool:
 PRIMITIVES = [int, float, bool, str]
 
 
-def is_enum(typ: Type[Any]) -> bool:
+def is_enum(typ: Type[Any]) -> TypeGuard[enum.Enum]:
     """
     Test if the type is `enum.Enum`.
     """

serde/core.py

@@ -63,7 +63,7 @@
 SETTINGS = dict(debug=False)
 
 
-def init(debug: bool = False):
+def init(debug: bool = False) -> None:
     SETTINGS['debug'] = debug
 
 
@@ -73,7 +73,7 @@ class SerdeScope:
     Container to store types and functions used in code generation context.
     """
 
-    cls: Type
+    cls: Type[Any]
     """ The exact class this scope is for (needed to distinguish scopes between inherited classes) """
 
     funcs: Dict[str, Callable] = dataclasses.field(default_factory=dict)
@@ -581,7 +581,7 @@ def conv(f: Field, case: Optional[str] = None) -> str:
     return name
 
 
-def union_func_name(prefix: str, union_args: List[Type]) -> str:
+def union_func_name(prefix: str, union_args: List[Type[Any]]) -> str:
     """
     Generate a function name that contains all union types
 

serde/de.py

@@ -9,7 +9,7 @@
 import functools
 import typing
 from dataclasses import dataclass, is_dataclass
-from typing import Any, Callable, Dict, List, Optional, TypeVar
+from typing import Any, Callable, Dict, Iterator, List, Optional, TypeVar
 
 import jinja2
 from typing_extensions import Type, dataclass_transform
@@ -87,10 +87,10 @@
 __all__ = ['deserialize', 'is_deserializable', 'from_dict', 'from_tuple']
 
 # Interface of Custom deserialize function.
-DeserializeFunc = Callable[[Type, Any], Any]
+DeserializeFunc = Callable[[Type[Any], Any], Any]
 
 
-def serde_custom_class_deserializer(cls: Type, datavar, value, custom: DeserializeFunc, default: Callable):
+def serde_custom_class_deserializer(cls: Type[Any], datavar, value, custom: DeserializeFunc, default: Callable):
     """
     Handle custom deserialization. Use default deserialization logic if it receives `SerdeSkip` exception.
 
@@ -106,7 +106,7 @@ def serde_custom_class_deserializer(cls: Type, datavar, value, custom: Deseriali
         return default()
 
 
-def default_deserializer(_cls: Type, obj):
+def default_deserializer(_cls: Type[Any], obj):
     """
     Marker function to tell serde to use the default deserializer. It's used when custom deserializer is specified
     at the class but you want to override a field with the default deserializer.
@@ -590,7 +590,8 @@ def data(self, d):
         self.datavar = d
 
 
-defields = functools.partial(fields, DeField)
+def defields(cls: Type[Any]) -> List[DeField]:
+    return fields(DeField, cls)
 
 
 @dataclass
@@ -884,7 +885,7 @@ def default(self, arg: DeField, code: str) -> str:
             return code
 
 
-def to_arg(f: DeField, index, rename_all: Optional[str] = None) -> DeField:
+def to_arg(f: DeField, index: int, rename_all: Optional[str] = None) -> DeField:
     f.index = index
     f.data = 'data'
     f.case = f.case or rename_all
@@ -897,7 +898,7 @@ def to_iter_arg(f: DeField, *args, **kwargs) -> DeField:
     return f
 
 
-def render_from_iter(cls: Type, custom: Optional[DeserializeFunc] = None, type_check: TypeCheck = NoCheck) -> str:
+def render_from_iter(cls: Type[Any], custom: Optional[DeserializeFunc] = None, type_check: TypeCheck = NoCheck) -> str:
     template = """
 def {{func}}(cls=cls, maybe_generic=None, data=None, reuse_instances = {{serde_scope.reuse_instances_default}}):
   if reuse_instances is Ellipsis:
@@ -933,7 +934,7 @@ def {{func}}(cls=cls, maybe_generic=None, data=None, reuse_instances = {{serde_s
 
 
 def render_from_dict(
-    cls: Type,
+    cls: Type[Any],
     rename_all: Optional[str] = None,
     custom: Optional[DeserializeFunc] = None,
     type_check: TypeCheck = NoCheck,
@@ -981,7 +982,7 @@ def {{func}}(cls=cls, maybe_generic=None, data=None,
     return res
 
 
-def render_union_func(cls: Type, union_args: List[Type], tagging: Tagging = DefaultTagging) -> str:
+def render_union_func(cls: Type[Any], union_args: List[Type], tagging: Tagging = DefaultTagging) -> str:
     template = """
 def {{func}}(cls=cls, maybe_generic=None, data=None, reuse_instances = {{serde_scope.reuse_instances_default}}):
   errors = []
@@ -1039,7 +1040,7 @@ def {{func}}(cls=cls, maybe_generic=None, data=None, reuse_instances = {{serde_s
     )
 
 
-def render_literal_func(cls: Type, literal_args: List[Any], tagging: Tagging = DefaultTagging) -> str:
+def render_literal_func(cls: Type[Any], literal_args: List[Any], tagging: Tagging = DefaultTagging) -> str:
     template = """
 def {{func}}(cls=cls, maybe_generic=None, data=None, reuse_instances = {{serde_scope.reuse_instances_default}}):
   if data in ({%- for v in literal_args -%}{{v|repr}},{%- endfor -%}):

serde/se.py

@@ -9,7 +9,7 @@
 import functools
 import typing
 from dataclasses import dataclass, is_dataclass
-from typing import Any, Callable, Dict, Iterator, List, Optional, Type, TypeVar
+from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Type, TypeVar
 
 import jinja2
 from typing_extensions import dataclass_transform
@@ -29,7 +29,6 @@
     is_datetime,
     is_datetime_instance,
     is_dict,
-    is_ellipsis,
     is_enum,
     is_generic,
     is_list,
@@ -381,14 +380,14 @@ def serializable_to_obj(object):
         raise SerdeError(e)
 
 
-def astuple(v):
+def astuple(v: Any) -> Tuple[Any, ...]:
     """
     Serialize object into tuple.
     """
     return to_tuple(v, reuse_instances=False, convert_sets=False)
 
 
-def to_tuple(o, reuse_instances: bool = ..., convert_sets: bool = ...) -> Any:
+def to_tuple(o, reuse_instances: bool = ..., convert_sets: bool = ...) -> Tuple[Any, ...]:
     """
     Serialize object into tuple.
 
@@ -411,14 +410,14 @@ def to_tuple(o, reuse_instances: bool = ..., convert_sets: bool = ...) -> Any:
     return to_obj(o, named=False, reuse_instances=reuse_instances, convert_sets=convert_sets)
 
 
-def asdict(v: Any) -> Dict[str, Any]:
+def asdict(v: Any) -> Dict[Any, Any]:
     """
     Serialize object into dictionary.
     """
     return to_dict(v, reuse_instances=False, convert_sets=False)
 
 
-def to_dict(o, reuse_instances: bool = ..., convert_sets: bool = ...) -> Any:
+def to_dict(o, reuse_instances: bool = ..., convert_sets: bool = ...) -> Dict[Any, Any]:
     """
     Serialize object into dictionary.
 
@@ -462,7 +461,7 @@ def varname(self) -> str:
                 raise SerdeError("Field name is None.")
             return self.name
 
-    def __getitem__(self, n) -> "SeField":
+    def __getitem__(self, n: int) -> "SeField":
         typ = type_args(self.type)[n]
         return SeField(typ, name=None)
 
@@ -473,7 +472,6 @@ def sefields(cls: Type[Any], serialize_class_var: bool = False) -> Iterator[SeFi
     """
     for f in fields(SeField, cls, serialize_class_var=serialize_class_var):
         f.parent = SeField(None, "obj")  # type: ignore
-        assert isinstance(f, SeField)
         yield f
 
 
@@ -725,7 +723,9 @@ def render(self, arg: SeField) -> str:
         elif is_any(arg.type) or isinstance(arg.type, TypeVar):
             res = f"to_obj({arg.varname}, True, False, False)"
         elif is_generic(arg.type):
-            arg.type = get_origin(arg.type)
+            origin = get_origin(arg.type)
+            assert origin
+            arg.type = origin
             res = self.render(arg)
         elif is_literal(arg.type):
             res = self.literal(arg)
@@ -852,7 +852,7 @@ def literal(self, arg: SeField) -> str:
         return f"{arg.varname}"
 
 
-def enum_value(cls, e):
+def enum_value(cls: Any, e: Any) -> Any:
     """
     Helper function to get value from enum or enum compatible value.
     """