deadcode 0.0.1__tar.gz → 0.0.2__tar.gz

{deadcode-0.0.1 → deadcode-0.0.2}/PKG-INFO

@@ -1,7 +1,9 @@
 Metadata-Version: 2.1
 Name: deadcode
-Version: 0.0.1
+Version: 0.0.2
 Summary: Find and remove dead code.
+Project-URL: Homepage, https://github.com/albertas/deadcode
+Project-URL: Documentation, https://deadcode.readthedocs.io/
 Author-email: Albertas Gimbutas <albertasgim@gmail.com>
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3

deadcode-0.0.2/deadcode/actions/argument_parsing.py

@@ -0,0 +1,27 @@
+import argparse
+from typing import List, Optional
+import sys
+
+from deadcode.data_types import Args
+from deadcode.utils import split_comma_separated_values
+
+
+def parse_command_line_arguments(args: Optional[List[str]]) -> Args:
+    if not args:
+        args = sys.argv[1:]
+
+    parser = argparse.ArgumentParser()  # Docs: https://docs.python.org/3/library/argparse.html
+    parser.add_argument("paths", help="Paths where to search for python files", nargs="+")
+    parser.add_argument("--exclude", help="PATHS to files not to analyse at all (comma separated values)",
+                        nargs="*", action="append", default=[], type=str)
+    parser.add_argument("--ignore-names", help="NAMES not to report (comma separated values)",
+                        nargs="*", action="append", default=[], type=str)
+    parser.add_argument("--ignore-files", help="PATHS to files not to report NAMES from (comma separated values)",
+                        nargs="*", action="append", default=[], type=str)
+
+    parsed_args = parser.parse_args(args).__dict__
+
+    for field_name in ["exclude", "ignore_names", "ignore_files"]:
+        parsed_args[field_name] = split_comma_separated_values(parsed_args.get(field_name))
+
+    return Args(**parsed_args)

deadcode-0.0.2/deadcode/cli.py

@@ -0,0 +1,138 @@
+from typing import Dict, List, Optional
+from collections import defaultdict
+import os
+import sys
+import re
+from fnmatch import fnmatch
+
+from deadcode.data_types import Args, FileContent, Filename, Pathname, VariableName
+from deadcode.actions.argument_parsing import parse_command_line_arguments
+
+
+def does_path_match_patterns(path: Pathname, patterns: Optional[List[Pathname]]) -> bool:
+    if path != "." and patterns:
+        for pattern in patterns:
+            if fnmatch(path, pattern):
+                return True
+    return False
+
+
+def find_python_filenames(args: Args):
+    """Recursively searches for Python filenames in provided paths."""
+    python_filenames = []
+    for path in args.paths:
+        if does_path_match_patterns(path, args.exclude):
+            continue
+
+        if os.path.isfile(path):
+            filename = path
+            if os.path.splitext(filename)[1] == ".py":
+                python_filenames.append(filename)
+        else:
+            for path, _, filenames in os.walk(path):
+                if does_path_match_patterns(path, args.exclude):
+                    continue
+
+                for f in filenames:
+                    filename = os.path.join(path, f)
+                    if (os.path.splitext(filename)[1] == ".py" and
+                        not does_path_match_patterns(filename, args.exclude)):
+                        python_filenames.append(filename)
+
+    return python_filenames
+
+
+def read_files(filenames: List[Filename]) -> Dict[Filename, FileContent]:
+    files = {}
+    for filename in filenames:
+        with open(filename, "r") as f:
+            files[filename] = f.read()
+    return files
+
+
+def parse_global_names(
+    files: Dict[Filename, FileContent], args: Args
+) -> Dict[VariableName, Filename]:
+    patterns = [
+        r"^(\w+)\s*=",
+        r"^def\s+(\w+)\s*\(?",
+        r"^class\s+(\w+)\s*\(?:?",
+    ]
+
+    global_variable_names = {}
+    for filename, file_content in files.items():
+        if does_path_match_patterns(filename, args.ignore_files):
+            continue
+
+        for pattern in patterns:
+            for line_nr, line in enumerate(file_content.split("\n"), 1):
+                if global_variable_name_in_file := re.findall(pattern, line):
+                    variable_name = global_variable_name_in_file[0]
+                    # TODO: could find the column name and add it to the output.
+                    global_variable_names[variable_name] = f"{filename}:{line_nr}"
+
+    return global_variable_names
+
+
+def remove_comments_from_file_content(file_content: str) -> str:
+    # TODO: add a unit test for this feature.
+    file_lines_without_comments = []
+    for line in file_content:
+        if "#" in line:
+            # TODO: should ignore # in strings.
+            line = line.split("#", 1)[0]
+        file_lines_without_comments.append(line)
+    return "".join(file_lines_without_comments)
+
+
+def remove_comments(files: Dict[Filename, FileContent]) -> Dict[Filename, FileContent]:
+    files_without_comments = {}
+    for filename, file_content in files.items():
+        files_without_comments[filename] = remove_comments_from_file_content(file_content)
+    return files_without_comments
+        
+
+def find_unused_names(
+    files: Dict[str, str], global_names: Dict[VariableName, Filename], args: Args
+) -> Dict[VariableName, Filename]:
+    name_occourencies = defaultdict(int)
+    for name in global_names.keys():
+        for file_content in files.values():
+            name_occourencies[name] += file_content.count(name)
+
+    unused_variables = {
+        name: filename
+        for name, filename in global_names.items()
+        if name_occourencies[name] == 1 and name not in args.ignore_names
+    }
+    return unused_variables
+
+
+def print_unused_names(unused_names: Dict[VariableName, Filename]):
+    # TODO: add line number to output
+    for name, filename in unused_names.items():
+        print(
+            filename,
+            "\033[91mF851\033[0m",
+            f"Global \033[1m{name}\033[0m is never used",
+        )
+
+
+def main(command_line_args: Optional[List[str]] = None) -> Dict[VariableName, Filename]:
+    args = parse_command_line_arguments(command_line_args)
+
+    python_filenames = find_python_filenames(args=args)
+    files = read_files(python_filenames)
+    files_without_comments = remove_comments(files)
+
+    global_names = parse_global_names(files, args=args)
+    unused_names = find_unused_names(files_without_comments, global_names, args=args)
+
+    print_unused_names(unused_names)
+    if unused_names:
+        sys.exit(1)
+    return unused_names
+
+
+if __name__ == "__main__":
+    main()

deadcode-0.0.2/deadcode/data_types.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+FileContent = str
+Filename = str  # Contains full path to existing file
+Pathname = str  # Can contain wildewards
+VariableName = str
+
+
+@dataclass
+class Args:
+    paths: List[Pathname]
+    exclude: List[Pathname]
+    ignore_names: List[Pathname]
+    ignore_files: List[Pathname]

{deadcode-0.0.1/dead_code → deadcode-0.0.2/deadcode}/tests/test_case1/hello_world.py

@@ -19,4 +19,3 @@ class UnusedClass(object):
 class AnotherUnusedClass:
     def __init__(self):
         pass
-

{deadcode-0.0.1/dead_code → deadcode-0.0.2/deadcode}/tests/test_case1/subdir/another_subdir/__init__.py

@@ -1,2 +1 @@
-
 UNUSED_VARIABLE = 123

{deadcode-0.0.1/dead_code → deadcode-0.0.2/deadcode}/tests/test_case1/subdir/one_more_file.py

@@ -1,4 +1,2 @@
-
 def another_unused_function():
     pass
-

deadcode-0.0.2/deadcode/tests/test_deadcode.py

@@ -0,0 +1,76 @@
+from subprocess import PIPE, Popen
+from unittest import TestCase
+from unittest.mock import patch
+
+from deadcode.cli import main
+from deadcode.actions.argument_parsing import parse_command_line_arguments
+
+
+class FindDeadCodeTests(TestCase):
+    @patch("deadcode.cli.sys")
+    def test_run_dead_code_finder_with_a_subprocess_in_a_right_directory_main(self, sys_mock):
+        unused_names = main(["tests/test_case1"])
+        self.assertEqual(
+            unused_names,
+            {
+                "ANOTHER_GLOBAL_VARIABLE": "tests/test_case1/hello_world.py:4",
+                "AnotherUnusedClass": "tests/test_case1/hello_world.py:19",
+                "UNUSED_VARIABLE": "tests/test_case1/subdir/another_subdir/__init__.py:1",
+                "another_unused_function": "tests/test_case1/subdir/one_more_file.py:1",
+                "unused_global_variable": "tests/test_case1/hello_world.py:3",
+            },
+        )
+        sys_mock.exit.assert_called_once_with(1)
+
+    ## TODO: Add test for . path
+    # def test_using_dot_to_find_files_recursively(self):
+    #     unused_names = main([".", "--exclude=tests,venv"])
+
+    #     self.assertEqual(
+    #         unused_names, {
+    #             'not_used_function': './tests/module_a.py:5',
+    #             'FindDeadCodeTests': './tests/test_deadcode.py:7',
+    #             # "ANOTHER_GLOBAL_VARIABLE": "tests/test_case1/hello_world.py:4",
+    #             # "AnotherUnusedClass": "tests/test_case1/hello_world.py:19",
+    #             # "UNUSED_VARIABLE": "tests/test_case1/subdir/another_subdir/__init__.py:1",
+    #             # "another_unused_function": "tests/test_case1/subdir/one_more_file.py:1",
+    #             # "unused_global_variable": "tests/test_case1/hello_world.py:3",
+    #         },
+    #     )
+
+
+class CommandLineArgParsingTests(TestCase):
+    def test_calling_with_one_paths_argument(self):
+        args = parse_command_line_arguments(["."])
+        self.assertEqual(args.paths, ["."])
+        self.assertEqual(args.exclude, [])
+        self.assertEqual(args.ignore_names, [])
+        self.assertEqual(args.ignore_files, [])
+
+    def test_calling_with_several_paths_argument(self):
+        args = parse_command_line_arguments([".", "tests"])
+        self.assertEqual(args.paths, [".", "tests"])
+        self.assertEqual(args.exclude, [])
+        self.assertEqual(args.ignore_names, [])
+        self.assertEqual(args.ignore_files, [])
+
+    def test_calling_with_exclude(self):
+        args = parse_command_line_arguments([".", "--exclude=tests,venv"])
+        self.assertEqual(args.paths, ["."])
+        self.assertEqual(args.exclude, ["tests", "venv"])
+        self.assertEqual(args.ignore_names, [])
+        self.assertEqual(args.ignore_files, [])
+
+    def test_calling_with_several_exclude_options(self):
+        args = parse_command_line_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_files, [])
+
+    def test_ignore_names_and_ignore_files_command_line_argument_parsing(self):
+        args = parse_command_line_arguments([".", "--ignore-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_files, ["tests", "venv"])

deadcode-0.0.2/deadcode/utils.py

@@ -0,0 +1,16 @@
+from typing import List, Optional
+
+
+def split_comma_separated_values(list_of_comma_separated_values: Optional[List[str]]) -> List[str]:
+    """Concatenates lists into one list."""
+    if not list_of_comma_separated_values:
+        return []
+    list_of_comma_separated_values = flatten_list(list_of_comma_separated_values)
+    return flatten_list([v.split(",") for v in list_of_comma_separated_values])
+
+
+def flatten_list(list_of_lists: Optional[List[List[str]]]) -> List[str]:
+    """Concatenates lists into one list."""
+    if not list_of_lists:
+        return []
+    return [elem for elem_list in list_of_lists for elem in elem_list]

{deadcode-0.0.1 → deadcode-0.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deadcode"
-version = "0.0.1"
+version = "0.0.2"
 authors = [
     {name = "Albertas Gimbutas", email = "albertasgim@gmail.com"},
 ]
@@ -22,18 +22,28 @@ dependencies = [
 ]
 
 [project.scripts]
-deadcode = "dead_code.cli:main"
+deadcode = "deadcode.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/albertas/deadcode"
+Documentation = "https://deadcode.readthedocs.io/"
 
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
-[tool.hatch.publish.index]
+
+[tool.hatch.publish.index]  # Hatch docs: https://hatch.pypa.io/latest/config/build/
 disable = true
 
+[tool.hatch.build]
+include = ["**/*.py"]
+exclude = ["tests/**"]
+
 [tool.mypy]
 exclude = ["build", "dist", "venv"]
 python_version = "3.8"
+strict = true
 pretty = true
 color_output = true
 show_error_codes = true
@@ -43,13 +53,8 @@ warn_unused_configs = true
 [tool.isort]
 profile = "black"
 multi_line_output = 3
+known_third_party = ["deadcode"]
+
+
+
 
-# https://github.com/PyCQA/flake8/issues/234
-# [tool.flake8]
-# inline-quotes = "double"
-# exclude = ["venv"]
-# max-line-length = 120
-# max-complexity = 10
-# max-function-length= 120
-# import-order-style = "google"
-# ignore = "I101,"

deadcode-0.0.1/.flake8

@@ -1,9 +0,0 @@
-[flake8]
-exclude = build dist venv
-inline-quotes = double
-jobs = 4
-application-import-names = dead_code_finder
-max-complexity = 10
-max-function-length= 120
-max-line-length = 120
-ignore = T201 I001

deadcode-0.0.1/Makefile

@@ -1,23 +0,0 @@
-env: venv
-	venv/bin/pip install --upgrade pip
-	venv/bin/pip install -r requirements-dev.txt --use-pep517
-	venv/bin/pip install -e .
-
-venv:
-	python3.9 -m venv venv
-
-publish: venv
-	rm -fr dist/*
-	venv/bin/hatch build
-	venv/bin/hatch publish
-
-flake8:
-	venv/bin/flake8 dead_code_finder
-
-mypy:
-	venv/bin/mypy dead_code_finder
-
-test:
-	venv/bin/pytest $(PYTEST_ME_PLEASE)
-
-check: test flake8 mypy

deadcode-0.0.1/dead_code/Makefile

@@ -1,10 +0,0 @@
-flake8:
-	../venv/bin/flake8 .
-
-mypy:
-	../venv/bin/mypy .
-
-test:
-	../venv/bin/pytest -s $(PYTEST_ME_PLEASE)
-
-check: test flake8 mypy

deadcode-0.0.1/dead_code/cli.py

@@ -1,78 +0,0 @@
-from typing import Dict, List, Optional
-from collections import defaultdict
-import os
-import sys
-import re
-
-
-FileContent = str
-Filename = str
-Pathname = str
-VariableName = str
-
-
-def find_python_filenames(paths: List[Pathname]):
-    """Recursively searches for Python filenames in provided paths."""
-    filenames = []
-    for path in paths:
-        if os.path.isfile(path):
-            if os.path.splitext(path)[1] == ".py":
-                filenames.append(path)
-        else:
-            filenames += [os.path.join(dp, f) for dp, dn, filenames in os.walk(path)
-                          for f in filenames if os.path.splitext(f)[1] == ".py"]
-    return filenames
-
-
-def read_files(filenames: List[Filename]) -> Dict[Filename, FileContent]:
-    files = {}
-    for filename in filenames:
-        with open(filename, "r") as f:
-            files[filename] = f.read()
-    return files
-
-
-def parse_global_names(files: Dict[Filename, FileContent]) -> Dict[VariableName, Filename]:
-    patterns = [r"^(\w+)\s*=", r"^def\s+(\w+)\s*\(?", r"^class\s+(\w+)\s*\(?:?"]
-
-    global_variable_names = {}
-    for filename, file_content in files.items():
-        for pattern in patterns:
-            global_variable_names_in_file = re.findall(pattern, file_content, re.MULTILINE)
-            for name in global_variable_names_in_file:
-                global_variable_names[name] = filename
-    return global_variable_names
-
-
-def find_unused_names(files: Dict[str, str], global_names: Dict[VariableName, Filename]
-                      ) -> Dict[VariableName, Filename]:
-    name_occourencies = defaultdict(int)
-    for name in global_names.keys(): 
-        for file_content in files.values():
-            name_occourencies[name] += file_content.count(name)
-
-    unused_variables = {name: filename for name, filename in global_names.items() if name_occourencies[name] == 1}
-    return unused_variables
-
-
-def print_unused_names(unused_names: Dict[VariableName, Filename]):
-    # TODO: add line number to output
-    print()
-    for name, filename in unused_names.items():
-        print(filename, "\033[91mF851\033[0m", f"Global \033[1m{name}\033[0m is never used")
-
-
-def main(args: Optional[List[str]] = None) -> None:
-    args = args or sys.argv[1:]
-
-    python_filenames = find_python_filenames(paths=args)
-    files = read_files(python_filenames)
-
-    global_names = parse_global_names(files)
-    unused_names = find_unused_names(files, global_names)
-
-    print_unused_names(unused_names)
-
-
-if __name__ == "__main__":
-    main()

deadcode-0.0.1/dead_code/tests/test_dead_code_finder.py

@@ -1,17 +0,0 @@
-from subprocess import PIPE, Popen
-from unittest import TestCase
-
-from dead_code.cli import main
-
-
-class DeadCodeTests(TestCase):
-    def test_main(self):
-        self.assertIsNone(main())
-
-
-class DetectUnimportedDefinitionInRoot(TestCase):
-    def test_run_dead_code_finder_with_a_subprocess_in_a_right_directory_main(self):
-        main(["tests/test_case1"])
-
-    # def testrun_dead_code_finder_with_a_subprocess_in_a_right_directory(self):
-    #     result = Popen(["../venv/bin/dead-code-finder", "tests/test_case1"], stdout=PIPE).communicate()[0].decode()

deadcode-0.0.1/notes

@@ -1,88 +0,0 @@
- ##################
-### Aggreed plan ##########################################
-# Create a pip package with a good name, write some tests #
-###########################################################
-#
-# [2023-06-05]
-# Solution: load all the files 
-# Check accourance count of the definition in all the files (if more than 1) - is used.
-# Can remove string and comments before checking.
-#
-# Subtasks:
-#   expand provided file paths
-#   read all files into memory (filename, content)
-#   is string in for 5k file a long operation?
-#   Should use a counter instead.
-#
-# Check SolarCube checks and Ruff if it detects such cases
-# Check Vulture for false positives with Mainhive repository.
-
-
-
-#
-
-SonarQube and ide linters: do they detect unused class definitions in other files?
-#############
-
-List of imported objects in dot separated form (how does import as work for this?):
-sys.modules.keys()
-#############
-
-
-Go through files and detect, what has been defined in those files and whether all definitions are used.
-    entry point: lambdas_handler.py
-
-
-
-Get Tree Representation of Loaded Python Modules (Python recipe)
-    https://code.activestate.com/recipes/442478-get-tree-representation-of-loaded-python-modules/
-
-
-from xml.dom.minidom import Document
-
-def get_tree_representation_of_loaded_python_modules(self):
-        modules = sys.modules.keys()
-        modules.sort()
-
-        tree_data = Document()
-        node = tree_data.createElement('li')
-        text = tree_data.createTextNode('Loaded Python Modules')
-        node.appendChild(text)
-        tree_data.appendChild(node)
-        map = {}
-        for module in modules:
-            ms = module.split('.')
-            path = node
-            for level in range(len(ms)):
-                nodes = map.get(level)
-                if nodes == None:
-                    node1 = tree_data.createElement('ul')
-                    node2 = tree_data.createElement('li')
-                    textNode = tree_data.createTextNode(ms[level])
-                    node2.appendChild(textNode)
-                    node1.appendChild(node2)
-                    path.appendChild(node1)
-                    nodes = [node2]
-                    map[level] = nodes
-                else:
-                    node2 = None
-                    for tmpNode in nodes:
-                        if tmpNode.firstChild.data == ms[level]:
-                            node2 = tmpNode
-                            node1 = node2.parentNode
-                    if node2 == None:
-                        node1 = path.childNodes.item(1)
-                        if node1==None:
-                            node1 = tree_data.createElement('ul')
-                            path.appendChild(node1)
-                        node2 = tree_data.createElement('li')
-                        textNode = tree_data.createTextNode(ms[level])
-                        node2.appendChild(textNode)
-                        node1.appendChild(node2)
-                        nodes += [node2]
-                        map[level] = nodes
-                path = node2
-
-        str = tree_data.toprettyxml()
-        str = str[len('<?xml version="1.0" ?>')+1:]
-        return str

deadcode-0.0.1/requirements-dev.txt

@@ -1,30 +0,0 @@
--r requirements.txt
-
-cognitive-complexity==1.3.0
-flake8==5.0.4
-flake8-annotations-complexity==0.0.7
-flake8-bandit==4.1.1
-flake8-blind-except==0.2.1
-flake8-breakpoint==1.1.0
-flake8-bugbear==22.10.27
-flake8-builtins==2.0.1
-flake8-cognitive-complexity==0.1.0
-flake8-comprehensions==3.10.1
-flake8-eradicate==1.4.0
-flake8-expression-complexity==0.0.11
-flake8-functions==0.0.7
-flake8-import-order==0.18.1
-flake8-isort==5.0.0
-flake8-logging-format==0.8.1
-flake8-print==5.0.0
-flake8-quotes==3.3.1
-flake8-variables-names==0.0.5
-isort==5.10.1
-mypy==0.990
-mypy-extensions==0.4.3
-pep8-naming==0.13.2
-pylint==2.15.5
-pytest==7.2.0
-vulture==2.6
-hatch==1.6.3
-hatchling==1.11.1