deadcode 0.1.0__tar.gz → 1.1.1__tar.gz

{deadcode-0.1.0 → deadcode-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deadcode
-Version: 0.1.0
+Version: 1.1.1
 Summary: Find and remove dead code.
 Project-URL: Homepage, https://github.com/albertas/deadcode
 Project-URL: Documentation, https://deadcode.readthedocs.io/
@@ -22,7 +22,7 @@ Description-Content-Type: text/markdown
 `deadcode` package implements `DC100` - `unused-global-name` check for detecting
 variable/function/class names which are never used in a whole code base.
 Only globally defined names are being checked.
-Unused local names can be detected by other tools like `ruff`.
+Unused local names can be detected by other tools like [ruff](https://pypi.org/project/ruff/).
 
 ## Installation
 ```shell
@@ -36,7 +36,7 @@ deadcode .
 
 Or with command line options:
 ```
-deadcode . --exclude=venv,tests --ignore-names=BaseTestCase --ignore-names-in-files=migrations
+deadcode . --exclude=venv,tests --ignore-names=BaseTestCase,.*Mixin --ignore-names-in-files=migrations
 ```
 
 The same options can be provided in `pyproject.toml` settings file:
@@ -48,26 +48,37 @@ ignore-names-in-files = ["migrations"]
 ```
 
 Command line options:
-|       Option      | Type  | Meaning  |
-|---------------------------|-------|----------|
-|`--exclude`                | list | Path expressions to completely skips files from being analysed. |
-|`--ignore-names`           | list | Removes provided list of names from the error output. |
-|`--ignore-names-in-files`  | list | Unused names from files matching provided path expressions. |
-|`--no-color`               | None | Removes colors from the output. |
+
+| Option                            | Type | Meaning  |
+|-----------------------------------|------|----------|
+|<pre>--exclude</pre>               | list | Path expressions to completely skip files from being analysed. |
+|<pre>--ignore-names</pre>          | list | Removes provided list of names from the error output. Regexp expressions to match multiple names can also be provided, e.g. `.*Mixin` will match all classes ending with `Mixin`. |
+|<pre>--ignore-names-in-files</pre> | list | Unused names from files matching provided path expressions. |
+|<pre>--no-color</pre>              | None | Removes colors from the output. |
+|<pre>--count</pre>                 | None | Provides the count of the detected unused names instead of printing them all out. |
+|<pre>--quiet</pre>                 | None | Does not output anything. Makefile still fails with exit code 1 if unused names are found. |
+
 
 ## Contributing
 - `make check` - runs unit tests and other checks using virtual environment.
 
 ## Rationale
-`ruff` and `flake8` - don't have rules for unused global code detection, only for local ones `F823`, `F841`, `F842`.
-`deadcode` package tries to add a new `DC100` check for detecting variables/functions/classes which are not used in a whole code base.
+[ruff](https://pypi.org/project/ruff/) and
+[flake8](https://pypi.org/project/flake8/) - don't have rules for unused global
+code detection, only for local ones `F823`, `F841`, `F842`. `deadcode` package
+tries to add a new `DC100` check for detecting variables/functions/classes
+which are not used in a whole code base.
 
-There is an alternative `vulture` package, which provides many false positives. `deadcode` - tries to find less, but findings are with higher confidence.
+There is an alternative [vulture](https://pypi.org/project/vulture/) package,
+which provides many false positives.
+`deadcode` - tries to find less, but findings are with higher confidence.
 `deadcode` - is supposed to be used inline with other static code checkers like `ruff`.
 
 ## Known limitations
 If the same unused name is repeated in several files - it wont be detected.
 
-Files with syntax errors will be ignored, because `deadcode` uses `ast` to build abstract syntax tree for name usage detection.
+Files with syntax errors will be ignored, because `deadcode` uses `ast` to
+build abstract syntax tree for name usage detection.
 
-It is assumed that `deadcode` will be run using the same Python version as the checked code base is implemented in.
+It is assumed that `deadcode` will be run using the same Python version as the
+checked code base is implemented in.

deadcode-1.1.1/README.md

@@ -0,0 +1,64 @@
+# deadcode
+`deadcode` package implements `DC100` - `unused-global-name` check for detecting
+variable/function/class names which are never used in a whole code base.
+Only globally defined names are being checked.
+Unused local names can be detected by other tools like [ruff](https://pypi.org/project/ruff/).
+
+## Installation
+```shell
+pip install deadcode
+```
+
+## Usage
+```shell
+deadcode .
+```
+
+Or with command line options:
+```
+deadcode . --exclude=venv,tests --ignore-names=BaseTestCase,.*Mixin --ignore-names-in-files=migrations
+```
+
+The same options can be provided in `pyproject.toml` settings file:
+```
+[tool.deadcode]
+exclude = ["venv", "tests"]
+ignore-names = ["BaseTestCase"]
+ignore-names-in-files = ["migrations"]
+```
+
+Command line options:
+
+| Option                            | Type | Meaning  |
+|-----------------------------------|------|----------|
+|<pre>--exclude</pre>               | list | Path expressions to completely skip files from being analysed. |
+|<pre>--ignore-names</pre>          | list | Removes provided list of names from the error output. Regexp expressions to match multiple names can also be provided, e.g. `.*Mixin` will match all classes ending with `Mixin`. |
+|<pre>--ignore-names-in-files</pre> | list | Unused names from files matching provided path expressions. |
+|<pre>--no-color</pre>              | None | Removes colors from the output. |
+|<pre>--count</pre>                 | None | Provides the count of the detected unused names instead of printing them all out. |
+|<pre>--quiet</pre>                 | None | Does not output anything. Makefile still fails with exit code 1 if unused names are found. |
+
+
+## Contributing
+- `make check` - runs unit tests and other checks using virtual environment.
+
+## Rationale
+[ruff](https://pypi.org/project/ruff/) and
+[flake8](https://pypi.org/project/flake8/) - don't have rules for unused global
+code detection, only for local ones `F823`, `F841`, `F842`. `deadcode` package
+tries to add a new `DC100` check for detecting variables/functions/classes
+which are not used in a whole code base.
+
+There is an alternative [vulture](https://pypi.org/project/vulture/) package,
+which provides many false positives.
+`deadcode` - tries to find less, but findings are with higher confidence.
+`deadcode` - is supposed to be used inline with other static code checkers like `ruff`.
+
+## Known limitations
+If the same unused name is repeated in several files - it wont be detected.
+
+Files with syntax errors will be ignored, because `deadcode` uses `ast` to
+build abstract syntax tree for name usage detection.
+
+It is assumed that `deadcode` will be run using the same Python version as the
+checked code base is implemented in.

{deadcode-0.1.0 → deadcode-1.1.1}/deadcode/actions/find_unused_names.py

@@ -11,16 +11,28 @@ def find_unused_names(
     args: Args,
 ) -> Dict[VariableName, Filename]:
     name_occourencies: Dict[str, int] = defaultdict(int)
+
     for name in global_names.keys():
         pattern = re.compile(
-            rf"FunctionDef\(name=\'{name}\'|ClassDef\(name=\'{name}\'|Name\(id=\'{name}\'|alias\(name=\'{name}\'"
+            "|".join(
+                [
+                    rf"FunctionDef\(name=\'{name}\'",
+                    rf"ClassDef\(name=\'{name}\'",
+                    rf"Name\(id=\'{name}\'",
+                    rf"alias\(name=\'{name}\'",
+                ]
+            )
         )
         for abstract_syntax_tree in files.values():
             name_occourencies[name] += len(re.findall(pattern, abstract_syntax_tree))
 
+    # Filter out used and ignored names
+    ignore_names_pattern = "|".join(args.ignore_names) or "^$"
+    ignore_names_re = re.compile(ignore_names_pattern)
+
     unused_variables = {
         name: filename
         for name, filename in global_names.items()
-        if name_occourencies[name] == 1 and name not in args.ignore_names
+        if name_occourencies[name] == 1 and not re.findall(ignore_names_re, name)
     }
     return unused_variables

{deadcode-0.1.0 → deadcode-1.1.1}/deadcode/actions/get_unused_names_error_message.py

@@ -8,6 +8,12 @@ def get_unused_names_error_message(unused_names: Dict[VariableName, Filename], a
     if not unused_names:
         return None
 
+    if args.quiet:
+        return ""
+
+    if args.count:
+        return f"{len(unused_names)}"
+
     if args.no_color:
         return "\n".join([f"{filename} DC100 Global {name} is never used" for name, filename in unused_names.items()])
 

{deadcode-0.1.0 → deadcode-1.1.1}/deadcode/actions/parse_abstract_syntax_trees.py

@@ -1,16 +1,17 @@
 import ast
 from typing import Dict
 
-from deadcode.data_types import FileContent, Filename, AbstractSyntaxTree
+from deadcode.data_types import Args, FileContent, Filename, AbstractSyntaxTree
 
 
-def parse_abstract_syntax_trees(files: Dict[Filename, FileContent]) -> Dict[Filename, AbstractSyntaxTree]:
+def parse_abstract_syntax_trees(files: Dict[Filename, FileContent], args: Args) -> Dict[Filename, AbstractSyntaxTree]:
     """Did my code coverage just increased? Answer is no: a doc string was ignored :tada:"""
     abstract_syntax_trees_for_files = {}
     for filename, file_content in files.items():
         try:
             abstract_syntax_trees_for_files[filename] = ast.dump(ast.parse(file_content))  # Note: indent=1 for debug
         except:  # noqa: E722
-            print(f"Error: Failed to parse {filename} file, ignoring it.")
+            if not args.count and not args.quiet:
+                print(f"Error: Failed to parse {filename} file, ignoring it.")
             abstract_syntax_trees_for_files[filename] = ""
     return abstract_syntax_trees_for_files

{deadcode-0.1.0 → deadcode-1.1.1}/deadcode/actions/parse_arguments.py

@@ -57,6 +57,18 @@ def parse_arguments(args: Optional[List[str]]) -> Args:
         action="store_true",
         default=False,
     )
+    parser.add_argument(
+        "--quiet",
+        help="Does not output anything. Makefile still fails with exit code 1 if unused names are found.",
+        action="store_true",
+        default=False,
+    )
+    parser.add_argument(
+        "--count",
+        help="Provides the count of the detected unused names instead of printing them all out.",
+        action="store_true",
+        default=False,
+    )
 
     parsed_args = parser.parse_args(args).__dict__
 

{deadcode-0.1.0 → deadcode-1.1.1}/deadcode/cli.py

@@ -21,13 +21,14 @@ def main(
     files = read_files(python_filenames)
 
     global_names = parse_global_names(files, args=args)
-    abstract_syntax_trees_of_files = parse_abstract_syntax_trees(files)
+    abstract_syntax_trees_of_files = parse_abstract_syntax_trees(files, args=args)
     unused_names = find_unused_names(abstract_syntax_trees_of_files, global_names, args=args)
 
     if error_message := get_unused_names_error_message(unused_names, args=args):
         return error_message
 
-    print("\033[1mWell done!\033[0m ✨ 🚀 ✨")
+    if not args.count and not args.quiet:
+        print("\033[1mWell done!\033[0m ✨ 🚀 ✨")
     return None
 
 

{deadcode-0.1.0 → deadcode-1.1.1}/deadcode/data_types.py

@@ -17,3 +17,5 @@ class Args:
     ignore_names: List[Pathname]
     ignore_names_in_files: List[Pathname]
     no_color: bool
+    quiet: bool
+    count: bool

deadcode-1.1.1/deadcode/tests/base.py

@@ -0,0 +1,9 @@
+from unittest import TestCase
+from unittest.mock import MagicMock, patch
+
+
+class BaseTestCase(TestCase):
+    def patch(self, path: str) -> MagicMock:
+        patcher = patch(path)
+        self.addCleanup(patcher.stop)
+        return patcher.start()

deadcode-1.1.1/deadcode/tests/test_command_line_argument_parsing.py

@@ -0,0 +1,62 @@
+from deadcode.actions.parse_arguments import parse_arguments
+from deadcode.tests.base import BaseTestCase
+
+
+class CommandLineArgParsingTests(BaseTestCase):
+    def setUp(self):
+        self.tomlib_load_mock = self.patch("deadcode.actions.parse_arguments.tomllib.load")
+        self.tomlib_load_mock.return_value = {
+            "tool": {
+                "deadcode": {
+                    "exclude": [],
+                    "ignore_names": [],
+                    "ignore_names_in_files": [],
+                }
+            }
+        }
+
+    def test_calling_with_one_paths_argument(self):
+        args = parse_arguments(["."])
+        self.assertEqual(args.paths, ["."])
+        self.assertEqual(args.exclude, [])
+        self.assertEqual(args.ignore_names, [])
+        self.assertEqual(args.ignore_names_in_files, [])
+
+    def test_calling_with_several_paths_argument(self):
+        args = parse_arguments([".", "tests"])
+        self.assertEqual(args.paths, [".", "tests"])
+        self.assertEqual(args.exclude, [])
+        self.assertEqual(args.ignore_names, [])
+        self.assertEqual(args.ignore_names_in_files, [])
+
+    def test_calling_with_exclude(self):
+        args = parse_arguments([".", "--exclude=tests,venv"])
+        self.assertEqual(args.paths, ["."])
+        self.assertEqual(args.exclude, ["tests", "venv"])
+        self.assertEqual(args.ignore_names, [])
+        self.assertEqual(args.ignore_names_in_files, [])
+
+    def test_calling_with_several_exclude_options(self):
+        args = parse_arguments([".", "--exclude=tests,venv", "--exclude=migrations"])
+        self.assertEqual(args.paths, ["."])
+        self.assertEqual(args.exclude, ["tests", "venv", "migrations"])
+        self.assertEqual(args.ignore_names, [])
+        self.assertEqual(args.ignore_names_in_files, [])
+
+    def test_calling_with_no_color_option(self):
+        args = parse_arguments([".", "--no-color"])
+        self.assertEqual(args.paths, ["."])
+        self.assertEqual(args.no_color, True)
+
+    def test_ignore_names_and_ignore_files_command_line_argument_parsing(self):
+        args = parse_arguments(
+            [
+                ".",
+                "--ignore-names-in-files=tests,venv",
+                "--ignore-names=BaseTestCase,lambda_handler",
+            ]
+        )
+        self.assertEqual(args.paths, ["."])
+        self.assertEqual(args.exclude, [])
+        self.assertEqual(args.ignore_names, ["BaseTestCase", "lambda_handler"])
+        self.assertEqual(args.ignore_names_in_files, ["tests", "venv"])

deadcode-1.1.1/deadcode/tests/test_count_output.py

@@ -0,0 +1,49 @@
+from deadcode.cli import main
+from deadcode.tests.base import BaseTestCase
+
+
+class IgnoreNamesByPatternTests(BaseTestCase):
+    def test_count_several_classes(self):
+        # Having
+        self.read_files_mock = self.patch("deadcode.cli.read_files")
+        self.read_files_mock.return_value = {
+            "ignore_names_by_pattern.py": """
+class MyModel:
+    pass
+
+class MyUserModel:
+    pass
+
+class Unused:
+    pass
+
+class ThisClassShouldBeIgnored:
+    pass
+"""
+        }
+
+        # When
+        unused_name_count = main(["ignore_names_by_pattern.py", "--no-color", "--count"])
+
+        # Then
+        self.assertEqual(unused_name_count, "4")
+
+    def test_count_variables_function_and_class(self):
+        # Having
+        self.read_files_mock = self.patch("deadcode.cli.read_files")
+        self.read_files_mock.return_value = {
+            "ignore_names_by_pattern.py": """
+first_variable = 0
+def this_is_a_function():
+    pass
+class MyModel:
+    def __init__(self):
+        pass
+"""
+        }
+
+        # When
+        unused_name_count = main(["ignore_names_by_pattern.py", "--no-color", "--count"])
+
+        # Then
+        self.assertEqual(unused_name_count, "3")

{deadcode-0.1.0 → deadcode-1.1.1}/deadcode/tests/test_deadcode.py

@@ -1,18 +1,8 @@
-from unittest import TestCase
-from unittest.mock import MagicMock, patch
-
 from deadcode.cli import main
-from deadcode.actions.parse_arguments import parse_arguments
-
-
-class BaseTestCase(TestCase):
-    def patch(self, path: str) -> MagicMock:
-        patcher = patch(path)
-        self.addCleanup(patcher.stop)
-        return patcher.start()
+from deadcode.tests.base import BaseTestCase
 
 
-class FindDeadCodeTests(BaseTestCase):
+class DeadCodeIntegrationTests(BaseTestCase):
     def test_unused_variable_name_found(self):
         unused_names = main(["tests/files/variables.py", "--no-color"])
 
@@ -137,62 +127,5 @@ print(THIS_ONE_IS_USED)"""
             ),
         )
 
-
-class CommandLineArgParsingTests(BaseTestCase):
-    def setUp(self):
-        self.tomlib_load_mock = self.patch("deadcode.actions.parse_arguments.tomllib.load")
-        self.tomlib_load_mock.return_value = {
-            "tool": {
-                "deadcode": {
-                    "exclude": [],
-                    "ignore_names": [],
-                    "ignore_names_in_files": [],
-                }
-            }
-        }
-
-    def test_calling_with_one_paths_argument(self):
-        args = parse_arguments(["."])
-        self.assertEqual(args.paths, ["."])
-        self.assertEqual(args.exclude, [])
-        self.assertEqual(args.ignore_names, [])
-        self.assertEqual(args.ignore_names_in_files, [])
-
-    def test_calling_with_several_paths_argument(self):
-        args = parse_arguments([".", "tests"])
-        self.assertEqual(args.paths, [".", "tests"])
-        self.assertEqual(args.exclude, [])
-        self.assertEqual(args.ignore_names, [])
-        self.assertEqual(args.ignore_names_in_files, [])
-
-    def test_calling_with_exclude(self):
-        args = parse_arguments([".", "--exclude=tests,venv"])
-        self.assertEqual(args.paths, ["."])
-        self.assertEqual(args.exclude, ["tests", "venv"])
-        self.assertEqual(args.ignore_names, [])
-        self.assertEqual(args.ignore_names_in_files, [])
-
-    def test_calling_with_several_exclude_options(self):
-        args = parse_arguments([".", "--exclude=tests,venv", "--exclude=migrations"])
-        self.assertEqual(args.paths, ["."])
-        self.assertEqual(args.exclude, ["tests", "venv", "migrations"])
-        self.assertEqual(args.ignore_names, [])
-        self.assertEqual(args.ignore_names_in_files, [])
-
-    def test_calling_with_no_color_option(self):
-        args = parse_arguments([".", "--no-color"])
-        self.assertEqual(args.paths, ["."])
-        self.assertEqual(args.no_color, True)
-
-    def test_ignore_names_and_ignore_files_command_line_argument_parsing(self):
-        args = parse_arguments(
-            [
-                ".",
-                "--ignore-names-in-files=tests,venv",
-                "--ignore-names=BaseTestCase,lambda_handler",
-            ]
-        )
-        self.assertEqual(args.paths, ["."])
-        self.assertEqual(args.exclude, [])
-        self.assertEqual(args.ignore_names, ["BaseTestCase", "lambda_handler"])
-        self.assertEqual(args.ignore_names_in_files, ["tests", "venv"])
+    def test_variable_is_marked_as_used_even_if_its_imported_as_a_different_name(self):
+        pass

deadcode-1.1.1/deadcode/tests/test_ignore_names_by_pattern.py

@@ -0,0 +1,52 @@
+from deadcode.cli import main
+from deadcode.tests.base import BaseTestCase
+
+
+class IgnoreNamesByPatternTests(BaseTestCase):
+    def test_ignore_names_matched_by_word_and_group_regexp_patterns(self):
+        self.read_files_mock = self.patch("deadcode.cli.read_files")
+        self.read_files_mock.return_value = {
+            "ignore_names_by_pattern.py": """
+class MyModel:
+    pass
+
+class MyUserModel:
+    pass
+
+class Unused:
+    pass
+
+class ThisClassShouldBeIgnored:
+    pass
+"""
+        }
+        unused_names = main(["ignore_names_by_pattern.py", "--no-color", "--ignore-names=\\w*Model,.*[Ii]{1}gnore.*"])
+
+        self.assertEqual(
+            unused_names,
+            ("ignore_names_by_pattern.py:8:6: DC100 Global Unused is never used"),
+        )
+
+    def test_ignore_names_matched_by_dot_regexp_pattern(self):
+        self.read_files_mock = self.patch("deadcode.cli.read_files")
+        self.read_files_mock.return_value = {
+            "ignore_names_by_pattern.py": """
+class MyModel:
+    pass
+
+class MyUserModel:
+    pass
+
+class Unused:
+    pass
+
+class ThisClassShouldBeIgnored:
+    pass
+"""
+        }
+        unused_names = main(["ignore_names_by_pattern.py", "--no-color", "--ignore-names=.*Model,.*Ignore.*"])
+
+        self.assertEqual(
+            unused_names,
+            ("ignore_names_by_pattern.py:8:6: DC100 Global Unused is never used"),
+        )

{deadcode-0.1.0 → deadcode-1.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deadcode"
-version = "0.1.0"
+version = "1.1.1"
 authors = [
     {name = "Albertas Gimbutas", email = "albertasgim@gmail.com"},
 ]
@@ -69,4 +69,4 @@ target_version = ["py38"]
 
 
 [tool.pytest.ini_options]
-addopts = "--cov=. --cov-fail-under=90.0"
+addopts = "--cov=. --cov-fail-under=92.0"

deadcode-0.1.0/README.md

@@ -1,53 +0,0 @@
-# deadcode
-`deadcode` package implements `DC100` - `unused-global-name` check for detecting
-variable/function/class names which are never used in a whole code base.
-Only globally defined names are being checked.
-Unused local names can be detected by other tools like `ruff`.
-
-## Installation
-```shell
-pip install deadcode
-```
-
-## Usage
-```shell
-deadcode .
-```
-
-Or with command line options:
-```
-deadcode . --exclude=venv,tests --ignore-names=BaseTestCase --ignore-names-in-files=migrations
-```
-
-The same options can be provided in `pyproject.toml` settings file:
-```
-[tool.deadcode]
-exclude = ["venv", "tests"]
-ignore-names = ["BaseTestCase"]
-ignore-names-in-files = ["migrations"]
-```
-
-Command line options:
-|       Option      | Type  | Meaning  |
-|---------------------------|-------|----------|
-|`--exclude`                | list | Path expressions to completely skips files from being analysed. |
-|`--ignore-names`           | list | Removes provided list of names from the error output. |
-|`--ignore-names-in-files`  | list | Unused names from files matching provided path expressions. |
-|`--no-color`               | None | Removes colors from the output. |
-
-## Contributing
-- `make check` - runs unit tests and other checks using virtual environment.
-
-## Rationale
-`ruff` and `flake8` - don't have rules for unused global code detection, only for local ones `F823`, `F841`, `F842`.
-`deadcode` package tries to add a new `DC100` check for detecting variables/functions/classes which are not used in a whole code base.
-
-There is an alternative `vulture` package, which provides many false positives. `deadcode` - tries to find less, but findings are with higher confidence.
-`deadcode` - is supposed to be used inline with other static code checkers like `ruff`.
-
-## Known limitations
-If the same unused name is repeated in several files - it wont be detected.
-
-Files with syntax errors will be ignored, because `deadcode` uses `ast` to build abstract syntax tree for name usage detection.
-
-It is assumed that `deadcode` will be run using the same Python version as the checked code base is implemented in.