ignore erroneous mypy error

Author: jdidion

fgpyo/util/inspect.py

@@ -60,13 +60,17 @@ def split_at_given_level(
             decrease_in_depth += high_level_split.count(char)
         outer_depth_of_split += increase_in_depth - decrease_in_depth
 
-        assert outer_depth_of_split >= 0, "Unpaired depth character! Likely incorrect output"
+        assert (
+            outer_depth_of_split >= 0
+        ), "Unpaired depth character! Likely incorrect output"
 
         current_outer_splits.append(high_level_split)
         if outer_depth_of_split == 0:
             out_vals.append(split_delim.join(current_outer_splits))
             current_outer_splits = []
-    assert outer_depth_of_split == 0, "Unpaired depth character! Likely incorrect output!"
+    assert (
+        outer_depth_of_split == 0
+    ), "Unpaired depth character! Likely incorrect output!"
     return out_vals
 
 
@@ -148,7 +152,9 @@ def get_parser() -> partial:
                         if s == "{}"
                         else [
                             subtype_parser(item)
-                            for item in set(split_at_given_level(s[1:-1], split_delim=","))
+                            for item in set(
+                                split_at_given_level(s[1:-1], split_delim=",")
+                            )
                         ]
                     )
                 )
@@ -174,7 +180,9 @@ def tuple_parse(tuple_string: str) -> Tuple[Any, ...]:
                     if len(tuple_string) == 0:
                         return ()
                     else:
-                        val_strings = split_at_given_level(tuple_string, split_delim=",")
+                        val_strings = split_at_given_level(
+                            tuple_string, split_delim=","
+                        )
                         return tuple(
                             parser(val_str)
                             for parser, val_str in zip(subtype_parsers, val_strings)
@@ -210,10 +218,14 @@ def dict_parse(dict_string: str) -> Dict[Any, Any]:
                     if len(dict_string) == 0:
                         return {}
                     else:
-                        outer_splits = split_at_given_level(dict_string, split_delim=",")
+                        outer_splits = split_at_given_level(
+                            dict_string, split_delim=","
+                        )
                         out_dict = {}
                         for outer_split in outer_splits:
-                            inner_splits = split_at_given_level(outer_split, split_delim=";")
+                            inner_splits = split_at_given_level(
+                                outer_split, split_delim=";"
+                            )
                             assert (
                                 len(inner_splits) % 2 == 0
                             ), "Inner splits of dict didn't have matched key val pairs"
@@ -228,17 +240,23 @@ def dict_parse(dict_string: str) -> Dict[Any, Any]:
                 return types.make_enum_parser(type_)
             elif types.is_constructible_from_str(type_):
                 return functools.partial(type_)
-            elif type_ is type(None):  # type: ignore[E721]
+            elif type_ is type(None):  # type: ignore
                 return functools.partial(types.none_parser)
             elif types.get_origin_type(type_) is Union:
                 return types.make_union_parser(
                     union=type_,
-                    parsers=[_get_parser(cls, arg, parsers) for arg in types.get_arg_types(type_)],
+                    parsers=[
+                        _get_parser(cls, arg, parsers)
+                        for arg in types.get_arg_types(type_)
+                    ],
                 )
             elif types.get_origin_type(type_) is Literal:  # Py>=3.7.
                 return types.make_literal_parser(
                     type_,
-                    [_get_parser(cls, type(arg), parsers) for arg in types.get_arg_types(type_)],
+                    [
+                        _get_parser(cls, type(arg), parsers)
+                        for arg in types.get_arg_types(type_)
+                    ],
                 )
             else:
                 raise ParserNotFoundException(
@@ -293,7 +311,11 @@ def attr_from(
             # try setting by casting
             # Note that while bools *can* be cast from string, all non-empty strings evaluate to
             # True, because python, so we need to check for that explicitly
-            if not set_value and attribute.type is not None and not attribute.type == bool:
+            if (
+                not set_value
+                and attribute.type is not None
+                and not attribute.type == bool
+            ):
                 try:
                     return_value = attribute.type(str_value)
                     set_value = True