lapsed 2.4.1__py3-none-any.whl

deadcode/__init__.py

@@ -0,0 +1,8 @@
+try:
+    import importlib.metadata
+
+    __version__ = importlib.metadata.version(__package__ or __name__)
+except ImportError:
+    import importlib_metadata
+
+    __version__ = importlib_metadata.version(__package__ or __name__)

deadcode/actions/find_python_filenames.py

@@ -0,0 +1,57 @@
+from logging import getLogger
+from typing import List
+from pathlib import Path
+
+from deadcode.actions.parse_tach_config import load_tach_index
+from deadcode.data_types import Args
+from deadcode.visitor.ignore import _match
+
+logger = getLogger()
+
+
+def find_python_filenames(args: Args) -> List[str]:
+    tach_index = load_tach_index(args.tach_config)
+
+    filenames = []
+    paths: List[str] = list(args.paths)
+    while paths:
+        path = Path(paths.pop())
+
+        if _match(path, args.exclude):
+            if args.verbose:
+                logger.info(f'Ignoring: {path}')
+            continue
+
+        if path.is_file() and path.suffix == '.py' and tach_index.is_unchecked(path):
+            if args.verbose:
+                logger.info(f'Ignoring (unchecked tach module): {path}')
+            continue
+
+        if path.is_file() and path.suffix == '.py':
+            filenames.append(str(path))
+        elif path.is_dir():
+            paths += list([str(p) for p in path.glob('*')])
+        elif not path.exists():
+            # TODO: unify error logging and reporting
+            # Maybe a cli flag could be added to stop on error
+            logger.error(f'Error: {path} could not be found.')
+
+    if args.verbose:
+        sep = '\n  - '
+        logger.info(f'Files to be checked for dead code: {sep.join(filenames)}')
+    return filenames
+
+
+# Should show errors, if files do not exist.
+# Could mock directories: os.path.isfile os.walk -> replace this one with rglob
+
+# Should use list dir myself.
+
+# TODO: Whats the solution for mocking the file system checking?
+# Every single provided file is assumed to exist.
+
+
+# # TODO: investigate what can be reused from this module
+#     Loop over all given paths, abort if any ends with .pyc, add the other given
+#     files (even those not ending with .py) and collect all .py files under the
+#     given directories.

deadcode/actions/find_unused_names.py

@@ -0,0 +1,15 @@
+from typing import List, Iterable
+
+from deadcode.data_types import Args, Filename
+from deadcode.visitor.code_item import CodeItem
+from deadcode.visitor.dead_code_visitor import DeadCodeVisitor
+
+
+def find_unused_names(
+    filenames: List[Filename],
+    args: Args,
+) -> Iterable[CodeItem]:
+    dead_code_visitor = DeadCodeVisitor(filenames, args)
+    dead_code_visitor.visit_abstract_syntax_trees()
+    unused_code_items = dead_code_visitor.get_unused_code_items()
+    return unused_code_items

deadcode/actions/fix_or_show_unused_code.py

@@ -0,0 +1,72 @@
+from collections import defaultdict
+from difflib import diff_bytes, unified_diff
+from typing import Iterable
+import os
+
+from deadcode.actions.merge_overlaping_file_parts import merge_overlaping_file_parts
+from deadcode.actions.remove_file_parts_from_content import remove_file_parts_from_content
+from deadcode.data_types import Args
+from deadcode.visitor.code_item import CodeItem
+from deadcode.utils.flatten_lists import flatten_list
+from deadcode.utils.add_colors_to_diff import add_colors_to_diff
+from deadcode.visitor.ignore import _match
+
+
+def fix_or_show_unused_code(unused_items: Iterable[CodeItem], args: Args) -> str:
+    # Reading and writing should be patched in this file.
+
+    # Group unused_names by filenames
+    # For each filename find file parts, which have to be fixed.
+    # And fix those file parts.
+    #
+    # TODO: trailing commas, trailing white spaces and empty lines
+
+    filename_to_unused_items = defaultdict(list)
+    for unused_item in unused_items:
+        filename_to_unused_items[str(unused_item.filename)].append(unused_item)
+
+    result = []
+
+    for filename, file_unused_items in filename_to_unused_items.items():
+        file_parts = flatten_list([item.code_parts for item in file_unused_items])
+
+        unused_file_parts = merge_overlaping_file_parts(file_parts)
+
+        with open(filename, 'rb') as f:
+            file_content_lines = f.readlines()
+
+        updated_file_content_lines = remove_file_parts_from_content(file_content_lines, unused_file_parts)
+        updated_file_content = b''.join(updated_file_content_lines)
+        if updated_file_content.strip():
+            if not args.only or _match(filename, args.only):
+                if args.dry:
+                    with open(filename, 'rb') as f:
+                        filename_bytes = filename.encode()
+                        diff = diff_bytes(
+                            unified_diff,
+                            f.readlines(),
+                            updated_file_content_lines,
+                            fromfile=filename_bytes,
+                            tofile=filename_bytes,
+                        )
+                        # TODO: consider printing result instantly to save memory
+                        result_chunk = b''.join(diff)
+                        if args.no_color:
+                            result.append(result_chunk)
+                        else:
+                            result.append(add_colors_to_diff(result_chunk))
+
+                elif args.fix:
+                    with open(filename, 'wb') as f:
+                        # TODO: is there a method writelines?
+                        f.write(updated_file_content)
+        else:
+            os.remove(filename)
+
+    if result:
+        return b'\n'.join(result).decode()
+    return ''
+
+    # TODO: update this one: solution is to use read and write operations.
+    #
+    # Solution is to open file for reading and then for writing.

deadcode/actions/get_unused_names_error_message.py

@@ -0,0 +1,37 @@
+from typing import Iterable, Optional
+
+from deadcode.data_types import Args
+from deadcode.visitor.code_item import CodeItem
+from deadcode.visitor.ignore import _match
+
+
+def get_unused_names_error_message(unused_names: Iterable[CodeItem], args: Args) -> Optional[str]:
+    unused_names = list(unused_names)
+
+    if not unused_names:
+        return None
+
+    if args.quiet:
+        return ''
+
+    if args.count:
+        return f'{len(unused_names)}'
+
+    messages = []
+    for item in unused_names:
+        if not args.only or _match(item.filename, args.only):
+            message = f'{item.filename_with_position} \033[91m{item.error_code}\033[0m '
+            message += item.message or (
+                f"{item.type_.replace('_', ' ').capitalize()} " f"`\033[1m{item.name}\033[0m` " f"is never used"
+            )
+            if args.no_color:
+                message = message.replace('\033[91m', '').replace('\033[1m', '').replace('\033[0m', '')
+            messages.append(message)
+
+    if args.fix:
+        message = f"\nRemoved \033[1m{len(messages)}\033[0m unused code item{'s' if len(messages) > 1 else ''}!"
+        if args.no_color:
+            message = message.replace('\x1b[1m', '').replace('\x1b[0m', '')
+        messages.append(message)
+
+    return '\n'.join(messages)

deadcode/actions/merge_overlaping_file_parts.py

@@ -0,0 +1,83 @@
+from typing import List, Optional, Tuple
+from deadcode.data_types import Part
+
+
+def does_include(bigger_part: Part, smaller_part: Part) -> bool:
+    line_start_b, line_end_b, col_start_b, col_end_b = bigger_part
+    line_start_s, line_end_s, col_start_s, col_end_s = smaller_part
+
+    starts_later = (line_start_b > line_start_s) or ((line_start_b == line_start_s) and (col_start_b >= col_start_s))
+
+    ends_faster = (line_end_b < line_end_s) or ((line_end_b == line_end_b) and (col_end_b <= col_end_s))
+
+    return bool(starts_later and ends_faster)
+
+
+def sort_parts(bigger_part: Part, smaller_part: Part) -> Tuple[Part, Part]:
+    """Returns code part which begins first following by another code part."""
+    # TODO: Column should go first (tuple comparison would be possible)
+    line_start_b, line_end_b, col_start_b, col_end_b = bigger_part
+    line_start_s, line_end_s, col_start_s, col_end_s = smaller_part
+
+    # Pirmo pradžios eilutė ir stulpelis yra pirmiau.
+    if (line_start_s < line_start_b) or ((line_start_s == line_start_b) and (col_start_s < col_start_b)):
+        return smaller_part, bigger_part
+    return bigger_part, smaller_part
+
+
+def does_overlap(bigger_part: Part, smaller_part: Part) -> bool:
+    bigger_part, smaller_part = sort_parts(bigger_part, smaller_part)
+
+    line_start_b, line_end_b, col_start_b, col_end_b = bigger_part
+    line_start_s, line_end_s, col_start_s, col_end_s = smaller_part
+
+    # ar pirmo pabaiga perlipa antro pradžia
+    return bool((line_end_b > line_start_s) or ((line_end_b == line_start_s) and (col_end_b > col_start_s)))
+
+
+def merge_parts(p1: Part, p2: Part) -> Optional[Part]:
+    p1, p2 = sort_parts(p1, p2)
+
+    line_start1, line_end1, col_start1, col_end1 = p1
+    line_start2, line_end2, col_start2, col_end2 = p2
+
+    if (line_end1 > line_start2) or ((line_end1 == line_start2) and (col_end1 > col_start2)):
+        line_start = line_start1
+        col_start = col_start1
+        if line_end1 > line_end2:
+            line_end = line_end1
+            col_end = col_end1
+        elif line_end2 > line_end1:
+            line_end = line_end2
+            col_end = col_end2
+        else:
+            line_end = line_end1
+            col_end = max(col_end1, col_end2)
+        return Part(line_start, line_end, col_start, col_end)
+
+    return None
+
+
+def merge_overlaping_file_parts(overlaping_file_parts: List[Part]) -> List[Part]:
+    # Make algorithm O(n^2) by checking every single part if overlaps
+
+    non_overlaping_file_parts: List[Part] = []
+    for p1 in sorted(overlaping_file_parts):
+        merged_part = None
+        merged_with_index = None
+        for j, p2 in enumerate(non_overlaping_file_parts):
+            if does_include(p2, p1):
+                break
+
+            if does_overlap(p2, p1):
+                merged_part = merge_parts(p2, p1)
+                merged_with_index = j
+                break
+        else:
+            non_overlaping_file_parts.append(p1)
+
+        if merged_part and merged_with_index is not None:
+            non_overlaping_file_parts.pop(merged_with_index)
+            non_overlaping_file_parts.append(merged_part)
+
+    return non_overlaping_file_parts

deadcode/actions/parse_abstract_syntax_tree.py

@@ -0,0 +1,13 @@
+import ast
+
+from deadcode.data_types import Args, FileContent, AbstractSyntaxTree
+
+
+def parse_abstract_syntax_tree(file_content: FileContent, args: Args, filename: str) -> AbstractSyntaxTree:
+    """Did my code coverage just increased? Answer is no: a doc string was ignored :tada:"""
+    try:
+        return ast.parse(file_content, filename=filename, type_comments=True)
+    except:  # noqa: E722
+        if not args.count and not args.quiet:
+            print(f'Error: Failed to parse {filename} file, ignoring it.')
+        return ast.Module()

deadcode/actions/parse_arguments.py

@@ -0,0 +1,250 @@
+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(
+        '--fix',
+        help='Automatically remove detected unused code expressions from the code base.',
+        action='store_true',
+        default=False,
+    )
+    parser.add_argument(
+        '--dry',
+        help='Show changes which would be made in files with --fix option.',
+        action='store_true',
+        default=False,
+    )
+    parser.add_argument(
+        '--only',
+        help='Filenames (or path expressions), that will be reflected in the output and modified.',
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+    parser.add_argument(
+        '--exclude',
+        help='Filenames (or path expressions), which will be completely skipped without being analysed.',
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+    parser.add_argument(
+        '--ignore-names',
+        help=(
+            'Removes provided list of names from the output. '
+            'Regexp expressions to match multiple names can also be provided.'
+        ),
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+    parser.add_argument(
+        '--ignore-bodies-of',
+        help='Ignores body of an expression if its name matches any of the provided names.',
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+    parser.add_argument(
+        '--ignore-bodies-if-decorated-with',
+        help='Ignores body of an expression if its decorated with one of the provided decorator names.',
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+    parser.add_argument(
+        '--ignore-bodies-if-inherits-from',
+        help='Ignores body of a class if it inherits from any of the provided class names.',
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+    parser.add_argument(
+        '--ignore-definitions',
+        help=(
+            'Ignores definition (including name and body) if a '
+            'name of an expression matches any of the provided ones.'
+        ),
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+    parser.add_argument(
+        '--ignore-definitions-if-inherits-from',
+        help=(
+            'Ignores definition (including name and body) of a class if '
+            'it inherits from any of the provided class names.'
+        ),
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+    parser.add_argument(
+        '--ignore-definitions-if-decorated-with',
+        help=(
+            'Ignores definition (including name and body) of an expression, '
+            'which is decorated with any of the provided decorator names.'
+        ),
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+
+    parser.add_argument(
+        '--ignore-if-decorated-with',
+        help='Ignores both the name and its definition if its decorated with one of the provided decorator names.',
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+    parser.add_argument(
+        '--ignore-if-inherits-from',
+        help='Ignores both the name and its definition if the class inerits from the provided class name.',
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+
+    parser.add_argument(
+        '--ignore-names-if-inherits-from',
+        help='Ignores names of classes, which inherit from provided class names.',
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+    parser.add_argument(
+        '--ignore-names-if-decorated-with',
+        help='Ignores names of an expression, which is decorated with one of the provided decorator names.',
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+
+    parser.add_argument(
+        '--ignore-names-in-files',
+        help='Ignores unused names in files, which filenames match provided path expressions.',
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+
+    parser.add_argument(
+        '--tach-config',
+        help=(
+            'Paths to one or more tach.toml files (https://docs.gauge.sh) whose [[interfaces]] '
+            'declarations mark names as public API (never reported as unused), and whose '
+            'unchecked modules are skipped entirely.'
+        ),
+        nargs='*',
+        action='append',
+        default=[],
+        type=str,
+    )
+
+    parser.add_argument(
+        '--no-color',
+        help='Turn off colors in the output',
+        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,
+    )
+    parser.add_argument(
+        '-v',
+        '--verbose',
+        help='Shows logs useful for debuging',
+        action='store_true',
+        default=False,
+    )
+    parser.add_argument(
+        '--version',
+        help='Shows deadcode version',
+        action='store_true',
+        default=False,
+    )
+
+    parsed_args = parser.parse_args(args).__dict__
+
+    for arg_name, arg_value in parsed_args.items():
+        if isinstance(arg_value, list) and arg_name != 'paths':
+            parsed_args[arg_name] = flatten_lists_of_comma_separated_values(parsed_args.get(arg_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)
+
+    # Do not fix if dry option is provided:
+    if parsed_args['dry']:
+        parsed_args['fix'] = False
+
+    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