deadcode 0.0.2__py3-none-any.whl → 0.1.0__py3-none-any.whl

deadcode/actions/find_python_filenames.py

@@ -0,0 +1,28 @@
+import os
+
+from deadcode.data_types import Args
+from deadcode.utils.path_matching import does_path_match_patterns
+
+
+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

deadcode/actions/find_unused_names.py

@@ -0,0 +1,26 @@
+import re
+from typing import Dict
+from collections import defaultdict
+
+from deadcode.data_types import Args, Filename, VariableName, AbstractSyntaxTree
+
+
+def find_unused_names(
+    files: Dict[Filename, AbstractSyntaxTree],
+    global_names: Dict[VariableName, Filename],
+    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}\'"
+        )
+        for abstract_syntax_tree in files.values():
+            name_occourencies[name] += len(re.findall(pattern, abstract_syntax_tree))
+
+    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

deadcode/actions/get_unused_names_error_message.py

@@ -0,0 +1,19 @@
+from typing import Dict, Optional
+
+from deadcode.data_types import Filename, VariableName
+from deadcode.data_types import Args
+
+
+def get_unused_names_error_message(unused_names: Dict[VariableName, Filename], args: Args) -> Optional[str]:
+    if not unused_names:
+        return None
+
+    if args.no_color:
+        return "\n".join([f"{filename} DC100 Global {name} is never used" for name, filename in unused_names.items()])
+
+    return "\n".join(
+        [
+            f"{filename} \033[91mDC100\033[0m Global \033[1m{name}\033[0m is never used"
+            for name, filename in unused_names.items()
+        ]
+    )

deadcode/actions/parse_abstract_syntax_trees.py

@@ -0,0 +1,16 @@
+import ast
+from typing import Dict
+
+from deadcode.data_types import FileContent, Filename, AbstractSyntaxTree
+
+
+def parse_abstract_syntax_trees(files: Dict[Filename, FileContent]) -> 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.")
+            abstract_syntax_trees_for_files[filename] = ""
+    return abstract_syntax_trees_for_files

deadcode/actions/parse_arguments.py

@@ -0,0 +1,88 @@
+import argparse
+from typing import Any, Dict, List, Optional
+import sys
+import os
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+from deadcode.data_types import Args
+from deadcode.utils.flatten_lists import flatten_lists_of_comma_separated_values
+
+
+def parse_arguments(args: Optional[List[str]]) -> Args:
+    """Parses arguments (execution options) for deadcode tool.
+
+    Arguments for DeadCode can be provided via:
+    - via command line
+    - via pyproject.toml
+    - via function arguments
+    """
+
+    if not args:
+        args = sys.argv[1:]
+
+    # Docs: https://docs.python.org/3/library/argparse.html
+    parser = argparse.ArgumentParser()
+    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-names-in-files",
+        help="PATHS to files not to report NAMES from (comma separated values)",
+        nargs="*",
+        action="append",
+        default=[],
+        type=str,
+    )
+    parser.add_argument(
+        "--no-color",
+        help="Turn off colors in the output",
+        action="store_true",
+        default=False,
+    )
+
+    parsed_args = parser.parse_args(args).__dict__
+
+    for field_name in ["exclude", "ignore_names", "ignore_names_in_files"]:
+        parsed_args[field_name] = flatten_lists_of_comma_separated_values(parsed_args.get(field_name))
+
+    # Extend the Args with the values provided in the pyproject.toml
+    for key, item in parse_pyproject_toml().items():
+        if key in parsed_args:
+            parsed_args[key].extend(item)
+
+    return Args(**parsed_args)
+
+
+def parse_pyproject_toml() -> Dict[str, Any]:
+    """Parse a pyproject toml file, pulling out relevant parts for Black.
+
+    If parsing fails, will raise a tomllib.TOMLDecodeError.
+    Copied from: https://github.com/psf/black/blob/01b8d3d4095ebdb91d0d39012a517931625c63cb/src/black/files.py#LL113C15-L113C15
+    """
+    pyproject_toml_filename = "pyproject.toml"
+    if not os.path.isfile(pyproject_toml_filename):
+        return {}
+
+    with open(pyproject_toml_filename, "rb") as f:
+        pyproject_toml = tomllib.load(f)
+    config: Dict[str, Any] = pyproject_toml.get("tool", {}).get("deadcode", {})
+    config = {k.replace("--", "").replace("-", "_"): v for k, v in config.items()}
+    return config

deadcode/actions/parse_global_names.py

@@ -0,0 +1,33 @@
+import re
+from typing import Dict
+
+from deadcode.utils.path_matching import does_path_match_patterns
+from deadcode.data_types import (
+    Args,
+    FileContent,
+    Filename,
+    VariableName,
+    FilenameWithPosition,
+)
+
+
+def parse_global_names(files: Dict[Filename, FileContent], args: Args) -> Dict[VariableName, FilenameWithPosition]:
+    patterns = [
+        re.compile(r"^(\w+)\s*="),
+        re.compile(r"^def\s+(\w+)\s*\(?"),
+        re.compile(r"^class\s+(\w+)\s*\(?:?"),
+    ]
+
+    global_variable_names = {}
+    for filename, file_content in files.items():
+        if does_path_match_patterns(filename, args.ignore_names_in_files):
+            continue
+
+        for pattern in patterns:
+            for line_nr, line in enumerate(file_content.split("\n"), 1):
+                if global_variable_name_match := re.search(pattern, line):
+                    variable_name = global_variable_name_match.groups()[0]
+                    column_nr = global_variable_name_match.regs[-1][0]
+                    global_variable_names[variable_name] = f"{filename}:{line_nr}:{column_nr}:"
+
+    return global_variable_names

deadcode/actions/read_files.py

@@ -0,0 +1,11 @@
+from typing import Dict, List
+
+from deadcode.data_types import FileContent, Filename
+
+
+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

deadcode/cli.py

@@ -1,137 +1,34 @@
-from typing import Dict, List, Optional
-from collections import defaultdict
-import os
-import sys
-import re
-from fnmatch import fnmatch
+from typing import List, Optional
 
-from deadcode.data_types import Args, FileContent, Filename, Pathname, VariableName
-from deadcode.actions.argument_parsing import parse_command_line_arguments
+from deadcode.actions.find_python_filenames import find_python_filenames
+from deadcode.actions.find_unused_names import find_unused_names
+from deadcode.actions.parse_arguments import parse_arguments
+from deadcode.actions.parse_global_names import parse_global_names
+from deadcode.actions.read_files import read_files
 
+from deadcode.actions.parse_abstract_syntax_trees import parse_abstract_syntax_trees
+from deadcode.actions.get_unused_names_error_message import (
+    get_unused_names_error_message,
+)
 
-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)
+def main(
+    command_line_args: Optional[List[str]] = None,
+) -> Optional[str]:
+    args = parse_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)
+    abstract_syntax_trees_of_files = parse_abstract_syntax_trees(files)
+    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_unused_names(unused_names)
-    if unused_names:
-        sys.exit(1)
-    return unused_names
+    print("\033[1mWell done!\033[0m ✨ 🚀 ✨")
+    return None
 
 
 if __name__ == "__main__":

deadcode/data_types.py

@@ -1,9 +1,11 @@
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import List
 
 
+AbstractSyntaxTree = str
 FileContent = str
 Filename = str  # Contains full path to existing file
+FilenameWithPosition = str  # filename:line:column:
 Pathname = str  # Can contain wildewards
 VariableName = str
 
@@ -13,4 +15,5 @@ class Args:
     paths: List[Pathname]
     exclude: List[Pathname]
     ignore_names: List[Pathname]
-    ignore_files: List[Pathname]
+    ignore_names_in_files: List[Pathname]
+    no_color: bool

deadcode/tests/files/classes.py

@@ -0,0 +1,15 @@
+class UnusedClass(object):
+    pass
+
+
+class ThisClassIsUsed:
+    name = "One"
+
+
+instance_of_a_used_class = ThisClassIsUsed()
+print(instance_of_a_used_class)
+
+
+class AnotherUnusedClass:
+    def __init__(self):
+        pass

deadcode/tests/files/functions.py

@@ -0,0 +1,18 @@
+def unused_function():
+    if 2 > 1:
+        pass
+
+
+def this_one_is_used():
+    pass
+
+
+this_one_is_used()
+
+
+def another_unused_function(arg1: str = "", arg2: str = "Hello") -> None:
+    print(arg1, arg2)
+
+
+# def this_method_is_commented():
+#     pass

deadcode/tests/files/variables.py

@@ -0,0 +1,8 @@
+unused_global_variable = True
+
+ANOTHER_GLOBAL_VARIABLE = "This variable is unused"
+
+third_global_varialbe = 12 * 25
+
+THIS_ONE_IS_USED = "World"
+print(THIS_ONE_IS_USED)