Added options to ignore lambdas and nested functions.

Author: joaoe

README.md

@@ -11,6 +11,10 @@ Configuration options also exist:
  - `unused-arguments-ignore-abstract-functions` - don't show warnings for abstract functions.
  - `unused-arguments-ignore-stub-functions` - don't show warnings for empty functions.
  - `unused-arguments-ignore-variadic-names` - don't show warnings for unused *args and **kwargs.
+ - `unused-arguments-ignore-lambdas` - don't show warnings for all lambdas.
+ - `unused-arguments-ignore-nested-functions` - don't show warnings for nested
+   functions. Only show warnings for functions in the top level of a module, or methods
+   of a class in the top level of a module.
 
 
 ## Changelog

flake8_unused_arguments.py

@@ -17,6 +17,8 @@ class Plugin:
     ignore_abstract = False
     ignore_stubs = False
     ignore_variadic_names = False
+    ignore_lambdas = False
+    ignore_nested_functions = False
 
     def __init__(self, tree: ast.Module):
         self.tree = tree
@@ -50,14 +52,37 @@ def add_options(cls, option_manager: flake8.options.manager.OptionManager) -> No
             help="If provided, then unused *args and **kwargs won't produce warnings.",
         )
 
+        option_manager.add_option(
+            "--unused-arguments-ignore-lambdas",
+            action="store_true",
+            parse_from_config=True,
+            default=cls.ignore_lambdas,
+            dest="unused_arguments_ignore_lambdas",
+            help="If provided, all lambdas are ignored.",
+        )
+
+        option_manager.add_option(
+            "--unused-arguments-ignore-nested-functions",
+            action="store_true",
+            parse_from_config=True,
+            default=cls.ignore_nested_functions,
+            dest="unused_arguments_ignore_nested_functions",
+            help=(
+                "If provided, only functions at the top level of a module or "
+                "methods of a class in the top level of a module are checked.",
+            ),
+        )
+
     @classmethod
     def parse_options(cls, options: optparse.Values) -> None:
         cls.ignore_abstract = options.unused_arguments_ignore_abstract_functions
         cls.ignore_stubs = options.unused_arguments_ignore_stub_functions
         cls.ignore_variadic_names = options.unused_arguments_ignore_variadic_names
+        cls.ignore_lambdas = options.unused_arguments_ignore_lambdas
+        cls.ignore_nested_functions = options.unused_arguments_ignore_nested_functions
 
     def run(self) -> Iterable[LintResult]:
-        finder = FunctionFinder()
+        finder = FunctionFinder(self.ignore_nested_functions)
         finder.visit(self.tree)
 
         for function in finder.functions:
@@ -70,6 +95,10 @@ def run(self) -> Iterable[LintResult]:
             if self.ignore_stubs and is_stub_function(function):
                 continue
 
+            # ignore lambdas
+            if self.ignore_lambdas and isinstance(function, ast.Lambda):
+                continue
+
             for i, argument in get_unused_arguments(function):
                 name = argument.arg
                 if self.ignore_variadic_names:
@@ -198,12 +227,15 @@ def is_stub_function(function: FunctionTypes) -> bool:
 class FunctionFinder(NodeVisitor):
     functions: List[FunctionTypes]
 
-    def __init__(self) -> None:
+    def __init__(self, only_top_level=False) -> None:
         super().__init__()
         self.functions = []
+        self.only_top_level = only_top_level
 
     def visit_function_types(self, function: FunctionTypes) -> None:
         self.functions.append(function)
+        if self.only_top_level:
+            return
         if isinstance(function, ast.Lambda):
             self.visit(function.body)
         else:

test_unused_arguments.py

@@ -223,6 +223,44 @@ def foo(**kwargs):
             {"ignore_variadic_names": False},
             [(2, 10, "U100 Unused argument 'kwargs'", "unused argument")],
         ),
+        (
+            "foo = lambda a: 1\n",
+            {"ignore_lambdas": True},
+            [],
+        ),
+        (
+            "foo = lambda a: 1\n",
+            {"ignore_lambdas": False},
+            [(1, 13, "U100 Unused argument 'a'", "unused argument")],
+        ),
+        (
+            """
+            def foo(a):
+                def bar(b):
+                    pass
+            zed = lambda c: lambda d: 1
+            """,
+            {"ignore_nested_functions": False},
+            [
+                (2, 8, "U100 Unused argument 'a'", "unused argument"),
+                (3, 12, "U100 Unused argument 'b'", "unused argument"),
+                (5, 13, "U100 Unused argument 'c'", "unused argument"),
+                (5, 23, "U100 Unused argument 'd'", "unused argument"),
+            ],
+        ),
+        (
+            """
+            def foo(a):
+                def bar(b):
+                    pass
+            zed = lambda c: lambda d: 1
+            """,
+            {"ignore_nested_functions": True},
+            [
+                (2, 8, "U100 Unused argument 'a'", "unused argument"),
+                (5, 13, "U100 Unused argument 'c'", "unused argument"),
+            ],
+        ),
         (
             """
     def foo(_a):
@@ -309,6 +347,43 @@ def test_check_version() -> None:
     assert get_most_recent_tag() == Plugin.version
 
 
+FF_CODE = """
+def some_function(a=1):
+    def some_nested_function(b=1):
+        return b
+    return some_nested_function(a)
+
+class SomeClass:
+    def some_method(a=1):
+        def some_nested_method(b=1):
+            return b
+        return some_nested_method(a)
+"""
+FF_ALL_FUNCTIONS = [
+    "some_function",
+    "some_nested_function",
+    "some_method",
+    "some_nested_method",
+]
+
+
+@pytest.mark.parametrize(
+    "only_top_level, expected",
+    [
+        (False, FF_ALL_FUNCTIONS),
+        (True, [n for n in FF_ALL_FUNCTIONS if "nested" not in n]),
+    ],
+)
+def test_function_finder(only_top_level, expected):
+    from flake8_unused_arguments import FunctionFinder
+
+    finder = FunctionFinder(only_top_level=only_top_level)
+    finder.visit(ast.parse(FF_CODE))
+    names = [node.name for node in finder.functions]
+
+    assert names == expected
+
+
 def get_most_recent_tag() -> str:
     return (
         subprocess.check_output(["git", "describe", "--tags", "--abbrev=0"], text=True)