Release v2.5.0

Author: sco1

.dependabot/config.yml renamed to .github/dependabot.yml

@@ -1,9 +1,10 @@
-version: 1
+version: 2
 
-update_configs:
-  - package_manager: "python"
+updates:
+  - package_manager: "pip"
     directory: "/"
     update_schedule: "weekly"
+    target-branch: "dev-next"
     ignored_updates:
       # Ignore dev dependencies, these are pinned fairly liberally so they don't need to be
       # rigorously tracked for updates

.github/workflows/lint_test.yml

@@ -33,7 +33,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.6, 3.7, 3.8, 3.9-dev]
+        python-version: [3.6, 3.7, 3.8, 3.9, 3.10-dev]
       fail-fast: false
 
     steps:

.pre-commit-config.yaml

@@ -13,14 +13,14 @@ repos:
     hooks:
       - id: black
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v3.2.0
+    rev: v3.4.0
     hooks:
       - id: check-merge-conflict
       - id: check-toml
       - id: check-yaml
       - id: end-of-file-fixer
       - id: mixed-line-ending
   - repo: https://github.com/pre-commit/pygrep-hooks
-    rev: v1.6.0
+    rev: v1.7.0
     hooks:
     -   id: python-check-blanket-noqa

CHANGELOG.md

@@ -1,6 +1,10 @@
 # Changelog
 Versions follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html) (`<major>`.`<minor>`.`<patch>`)
 
+## [v2.5.0]
+### Added
+* #103 add `--allow-untyped-nested` to suppress all errors from dynamically typted nested functions. A function is considered dynamically typed if it does not contain any type hints.
+
 ## [v2.4.1]
 ### Fixed
 * #100 Fix incorrect positioning of posonlyargs in the `Function` argument list, causing incorrect classification of the type of missing argument.

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 sco1
+Copyright (c) 2019-2021 sco1
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -19,7 +19,7 @@ You can verify it's being picked up by invoking the following in your shell:
 
 ```bash
 $ flake8 --version
-3.8.3 (flake8-annotations: 2.4.1, mccabe: 0.6.1, pycodestyle: 2.6.0, pyflakes: 2.2.0) CPython 3.8.2 on Darwin
+3.8.4 (flake8-annotations: 2.5.0, mccabe: 0.6.1, pycodestyle: 2.6.0, pyflakes: 2.2.0) CPython 3.9.0 on Darwin
 ```
 
 ## Table of Warnings
@@ -76,6 +76,11 @@ Suppress all errors for dynamically typed functions. A function is considered dy
 
 Default: `False`
 
+### `--allow-untyped-nested`: `bool`
+Suppress all errors for dynamically typed nested functions. A function is considered dynamically typed if it does not contain any type hints.
+
+Default: `False`
+
 ### `--mypy-init-return`: `bool`
 Allow omission of a return type hint for `__init__` if at least one argument is annotated. See [mypy's documentation](https://mypy.readthedocs.io/en/stable/class_basics.html?#annotating-init-methods) for additional details.
 

flake8_annotations/__init__.py

@@ -17,7 +17,7 @@
 
     PY_GTE_38 = False
 
-__version__ = "2.4.1"
+__version__ = "2.5.0"
 
 # The order of AST_ARG_TYPES must match Python's grammar
 # See: https://docs.python.org/3/library/ast.html#abstract-grammar
@@ -114,6 +114,7 @@ def __init__(
         has_type_comment: bool = False,
         has_only_none_returns: bool = True,
         is_overload_decorated: bool = False,
+        is_nested: bool = False,
         args: List[Argument] = None,
     ):
         self.name = name
@@ -126,6 +127,7 @@ def __init__(
         self.has_type_comment = has_type_comment
         self.has_only_none_returns = has_only_none_returns
         self.is_overload_decorated = is_overload_decorated
+        self.is_nested = is_nested
         self.args = args
 
     def is_fully_annotated(self) -> bool:
@@ -175,6 +177,7 @@ def __repr__(self) -> str:
             f"has_type_comment={self.has_type_comment}, "
             f"has_only_none_returns={self.has_only_none_returns}, "
             f"is_overload_decorated={self.is_overload_decorated}, "
+            f"is_nested={self.is_nested}, "
             f"args={self.args}"
             ")"
         )
@@ -268,7 +271,7 @@ def colon_seeker(node: AST_FUNCTION_TYPES, lines: List[str]) -> Tuple[int, int]:
             # the function node's body begins.
             # If the docstring is on one line then no rewinding is necessary.
             n_triple_quotes = lines[def_end_lineno].count('"""')
-            if n_triple_quotes == 1:
+            if n_triple_quotes == 1:  # pragma: no branch
                 # Docstring closure, rewind until the opening is found & take the line prior
                 while True:
                     def_end_lineno -= 1
@@ -431,6 +434,8 @@ def has_overload_decorator(function_node: AST_FUNCTION_TYPES) -> bool:
 class FunctionVisitor(ast.NodeVisitor):
     """An ast.NodeVisitor instance for walking the AST and describing all contained functions."""
 
+    AST_FUNC_TYPES = (ast.FunctionDef, ast.AsyncFunctionDef)
+
     def __init__(self, lines: List[str]):
         self.lines = lines
         self.function_definitions: List[Function] = []
@@ -445,13 +450,19 @@ def switch_context(self, node: AST_DEF_NODES) -> None:
 
         Thank you for the inspiration @isidentical :)
         """
-        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        if isinstance(node, self.AST_FUNC_TYPES):
             # Check for non-empty context first to prevent IndexErrors for non-nested nodes
-            if self._context and isinstance(self._context[-1], ast.ClassDef):
-                # Check if current context is a ClassDef node & pass the appropriate flag
-                self.function_definitions.append(
-                    Function.from_function_node(node, self.lines, is_class_method=True)
-                )
+            if self._context:
+                if isinstance(self._context[-1], ast.ClassDef):
+                    # Check if current context is a ClassDef node & pass the appropriate flag
+                    self.function_definitions.append(
+                        Function.from_function_node(node, self.lines, is_class_method=True)
+                    )
+                elif isinstance(self._context[-1], self.AST_FUNC_TYPES):  # pragma: no branch
+                    # Check for nested function & pass the appropriate flag
+                    self.function_definitions.append(
+                        Function.from_function_node(node, self.lines, is_nested=True)
+                    )
             else:
                 self.function_definitions.append(Function.from_function_node(node, self.lines))
 
@@ -501,7 +512,7 @@ def visit_Return(self, node: ast.Return) -> None:
             # In the event of an explicit `None` return (`return None`), the node body will be an
             # instance of either `ast.Constant` (3.8+) or `ast.NameConstant`, which we need to check
             # to see if it's actually `None`
-            if isinstance(node.value, (ast.Constant, ast.NameConstant)):
+            if isinstance(node.value, (ast.Constant, ast.NameConstant)):  # pragma: no branch
                 if node.value.value is None:
                     return
 

flake8_annotations/checker.py

@@ -39,6 +39,7 @@ def __init__(self, tree: ast.Module, lines: List[str]):
         self.suppress_none_returning: bool
         self.suppress_dummy_args: bool
         self.allow_untyped_defs: bool
+        self.allow_untyped_nested: bool
         self.mypy_init_return: bool
 
     def run(self) -> Generator[FORMATTED_ERROR, None, None]:
@@ -61,9 +62,13 @@ def run(self) -> Generator[FORMATTED_ERROR, None, None]:
         #
         # Flake8 handles all noqa and error code ignore configurations after the error is yielded
         for function in visitor.function_definitions:
-            if self.allow_untyped_defs and function.is_dynamically_typed():
-                # Skip yielding errors from dynamically typed functions
-                continue
+            if function.is_dynamically_typed():
+                if self.allow_untyped_defs:
+                    # Skip yielding errors from dynamically typed functions
+                    continue
+                elif function.is_nested and self.allow_untyped_nested:
+                    # Skip yielding errors from dynamically typed nested functions
+                    continue
 
             # Create sentinels to check for mixed hint styles
             if function.has_type_comment:
@@ -153,6 +158,14 @@ def add_options(cls, parser: OptionManager) -> None:  # pragma: no cover
             help="Suppress all errors for dynamically typed functions. (Default: False)",
         )
 
+        parser.add_option(
+            "--allow-untyped-nested",
+            default=False,
+            action="store_true",
+            parse_from_config=True,
+            help="Suppress all errors for dynamically typed nested functions. (Default: False)",
+        )
+
         parser.add_option(
             "--mypy-init-return",
             default=False,
@@ -170,6 +183,7 @@ def parse_options(cls, options: Namespace) -> None:  # pragma: no cover
         cls.suppress_none_returning = options.suppress_none_returning
         cls.suppress_dummy_args = options.suppress_dummy_args
         cls.allow_untyped_defs = options.allow_untyped_defs
+        cls.allow_untyped_nested = options.allow_untyped_nested
         cls.mypy_init_return = options.mypy_init_return
 
     @staticmethod