deadcode 2.2.2__py3-none-any.whl → 2.3.1__py3-none-any.whl

deadcode/actions/find_python_filenames.py

@@ -16,21 +16,21 @@ def find_python_filenames(args: Args) -> List[str]:
 
         if _match(path, args.exclude):
             if args.verbose:
-                logger.info(f"Ignoring: {path}")
+                logger.info(f'Ignoring: {path}')
             continue
 
-        if path.is_file() and path.suffix == ".py":
+        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("*")])
+            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.")
+            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)}")
+        sep = '\n  - '
+        logger.info(f'Files to be checked for dead code: {sep.join(filenames)}')
     return filenames
 
 

deadcode/actions/fix_or_show_unused_code.py

@@ -0,0 +1,66 @@
+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 args.dry and ('__all_files__' in args.dry or _match(filename, 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

@@ -11,25 +11,25 @@ def get_unused_names_error_message(unused_names: Iterable[CodeItem], args: Args)
         return None
 
     if args.quiet:
-        return ""
+        return ''
 
     if args.count:
-        return f"{len(unused_names)}"
+        return f'{len(unused_names)}'
 
     messages = []
     for item in unused_names:
-        message = f"{item.filename_with_position} \033[91m{item.error_code}\033[0m "
+        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", "")
+            message = message.replace('\033[91m', '').replace('\033[1m', '').replace('\033[0m', '')
         messages.append(message)
 
     if args.fix:
         message = f"\nRemoved \033[1m{len(unused_names)}\033[0m unused code item{'s' if len(unused_names) > 1 else ''}!"
         if args.no_color:
-            message = message.replace("\x1b[1m", "").replace("\x1b[0m", "")
+            message = message.replace('\x1b[1m', '').replace('\x1b[0m', '')
         messages.append(message)
 
-    return "\n".join(messages)
+    return '\n'.join(messages)

deadcode/actions/merge_overlaping_file_parts.py

@@ -10,9 +10,7 @@ def does_include(bigger_part: Part, smaller_part: Part) -> bool:
 
     ends_faster = (line_end_b < line_end_s) or ((line_end_b == line_end_b) and (col_end_b <= col_end_s))
 
-    if starts_later and ends_faster:
-        return True
-    return False
+    return bool(starts_later and ends_faster)
 
 
 def sort_parts(bigger_part: Part, smaller_part: Part) -> Tuple[Part, Part]:
@@ -34,10 +32,7 @@ def does_overlap(bigger_part: Part, smaller_part: Part) -> bool:
     line_start_s, line_end_s, col_start_s, col_end_s = smaller_part
 
     # ar pirmo pabaiga perlipa antro pradžia
-    if (line_end_b > line_start_s) or ((line_end_b == line_start_s) and (col_end_b > col_start_s)):
-        return True
-
-    return False
+    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]:

deadcode/actions/parse_abstract_syntax_tree.py

@@ -9,5 +9,5 @@ def parse_abstract_syntax_tree(file_content: FileContent, args: Args, filename:
         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.")
+            print(f'Error: Failed to parse {filename} file, ignoring it.')
         return ast.Module()

deadcode/actions/parse_arguments.py

@@ -26,163 +26,173 @@ def parse_arguments(args: Optional[List[str]]) -> Args:
 
     # 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('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",
+        '--fix',
+        help='Automatically remove detected unused code expressions from the code base.',
+        action='store_true',
         default=False,
     )
-
     parser.add_argument(
-        "-v",
-        "--verbose",
-        help="Shows logs useful for debuging",
-        action="store_true",
-        default=False,
+        '--dry',
+        help='Show changes which would be made in files with --fix option.',
+        nargs='*',
+        action='append',
+        default=[['__all_files__']],
+        type=str,
     )
     parser.add_argument(
-        "--exclude",
-        help="Filenames (or path expressions), which will be completely skipped without being analysed.",
-        nargs="*",
-        action="append",
+        '--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",
+        '--ignore-names',
         help=(
-            "Removes provided list of names from the output. "
-            "Regexp expressions to match multiple names can also be provided."
+            'Removes provided list of names from the output. '
+            'Regexp expressions to match multiple names can also be provided.'
         ),
-        nargs="*",
-        action="append",
+        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",
+        '--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",
+        '--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",
+        '--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",
+        '--ignore-definitions',
         help=(
-            "Ignores definition (including name and body) if a "
-            "name of an expression matches any of the provided ones."
+            'Ignores definition (including name and body) if a '
+            'name of an expression matches any of the provided ones.'
         ),
-        nargs="*",
-        action="append",
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
     parser.add_argument(
-        "--ignore-definitions-if-inherits-from",
+        '--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."
+            'Ignores definition (including name and body) of a class if '
+            'it inherits from any of the provided class names.'
         ),
-        nargs="*",
-        action="append",
+        nargs='*',
+        action='append',
         default=[],
         type=str,
     )
     parser.add_argument(
-        "--ignore-definitions-if-decorated-with",
+        '--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."
+            'Ignores definition (including name and body) of an expression, '
+            'which is decorated with any of the provided decorator names.'
         ),
-        nargs="*",
-        action="append",
+        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",
+        '--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",
+        '--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",
+        '--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",
+        '--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",
+        '--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(
-        "--no-color",
-        help="Turn off colors in the output",
-        action="store_true",
+        '--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",
+        '--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",
+        '--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,
     )
 
     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":
+        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
@@ -190,6 +200,14 @@ def parse_arguments(args: Optional[List[str]]) -> Args:
         if key in parsed_args:
             parsed_args[key].extend(item)
 
+    # Show changes for only provided files instead of all
+    if len(parsed_args['dry']) > 1 or '--dry' not in args:
+        parsed_args['dry'].remove('__all_files__')
+
+    # Do not fix if dry option is provided:
+    if parsed_args['dry']:
+        parsed_args['fix'] = False
+
     return Args(**parsed_args)
 
 
@@ -199,13 +217,13 @@ def parse_pyproject_toml() -> Dict[str, Any]:
     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"
+    pyproject_toml_filename = 'pyproject.toml'
     if not os.path.isfile(pyproject_toml_filename):
         return {}
 
-    with open(pyproject_toml_filename, "rb") as f:
+    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()}
+    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/remove_file_parts_from_content.py

@@ -3,7 +3,7 @@ from typing import List, Optional, TypeVar
 
 from deadcode.data_types import Part
 
-T = TypeVar("T")
+T = TypeVar('T')
 
 
 def list_get(list_: List[T], index: int) -> Optional[T]:
@@ -12,20 +12,20 @@ def list_get(list_: List[T], index: int) -> Optional[T]:
     return None
 
 
-def ends_with_semicolon(line: str) -> bool:
-    return line.strip().endswith(":")
+def ends_with_semicolon(line: bytes) -> bool:
+    return line.strip().endswith(b':')
 
 
-def indentation_is_not_childs(previous_line: str, current_line: str) -> bool:
+def indentation_is_not_childs(previous_line: bytes, current_line: bytes) -> bool:
     return len(get_indentation(previous_line)) >= len(get_indentation(current_line))
 
 
-def get_indentation(line: str) -> str:
-    return str(re.findall("^\s*", line)[0])
+def get_indentation(line: bytes) -> bytes:
+    return bytes(re.findall(b'^\\s*', line)[0])
 
 
-def remove_as_from_end(line: str) -> str:
-    if not (line_rstrip := line.rstrip()).endswith("as"):
+def remove_as_from_end(line: bytes) -> bytes:
+    if not (line_rstrip := line.rstrip()).endswith(b'as'):
         return line
 
     # Is there white spaces before as
@@ -34,7 +34,14 @@ def remove_as_from_end(line: str) -> str:
     return line
 
 
-def remove_file_parts_from_content(content_lines: List[str], unused_file_parts: List[Part]) -> List[str]:
+def remove_comma_from_begining(line: bytes) -> bytes:
+    if not line.lstrip().startswith(b','):
+        return line
+
+    return line.lstrip()[1:].lstrip()
+
+
+def remove_file_parts_from_content(content_lines: List[bytes], unused_file_parts: List[Part]) -> List[bytes]:
     """ """
     # How should move through the lines of content?
     updated_content_lines = []
@@ -42,12 +49,12 @@ def remove_file_parts_from_content(content_lines: List[str], unused_file_parts:
     # TODO: iterate by line and crop that line if needed.
     unused_part_index = 0
 
-    previous_non_removed_line = ""
+    previous_non_removed_line = b''
     was_block_removed = False
     next_line_after_removed_block = None
-    indentation_of_first_removed_line = ""
-    empty_lines_in_a_row_list: List[str] = []
-    empty_lines_before_removed_block_list: List[str] = []
+    indentation_of_first_removed_line = b''
+    empty_lines_in_a_row_list: List[bytes] = []
+    empty_lines_before_removed_block_list: List[bytes] = []
 
     for current_lineno, line in enumerate(content_lines, start=1):
         from_line, to_line, from_col, to_col = 0, 0, 0, 0
@@ -63,10 +70,14 @@ def remove_file_parts_from_content(content_lines: List[str], unused_file_parts:
             indentation_of_first_removed_line = get_indentation(line)
 
             if from_line == to_line:
-                if (line[:from_col] + line[to_col:]).strip().startswith("="):
+                # TODO: this check is a workaround for an assignment expression.
+                # Clean-ups have to be applied based on removable expression type.
+                if (line[:from_col] + line[to_col:]).strip().startswith(b'='):
                     line = line[:from_col]
                 else:
-                    line = remove_as_from_end(line[:from_col]) + line[to_col:]
+                    # TODO: should apply `as` removal rule only for particular expression type only
+                    # as well as comma removal.
+                    line = remove_as_from_end(line[:from_col]) + remove_comma_from_begining(line[to_col:])
 
                 unused_part_index += 1
 
@@ -80,16 +91,22 @@ def remove_file_parts_from_content(content_lines: List[str], unused_file_parts:
             else:
                 line = line[:from_col]
 
-            if line.strip() and not line.startswith("#"):
+            if line.strip() and not line.startswith(b'#'):
                 previous_non_removed_line = line
                 updated_content_lines.append(line)
 
         # Is it last line, from the block, which have to be ignored?
         elif current_lineno == to_line:
             line = line[to_col:]
+
+            # Remove trailing comma, if we have removed something.
+            # TODO: this should be applied only for specific expression types only.
+            if line.lstrip().startswith(b','):
+                line = line.lstrip()[1:].lstrip()
+
             unused_part_index += 1
             # TODO: Add tests for case, when comments are added at the start or end of the removed block
-            if line.strip() and not line.startswith("#"):
+            if line.strip() and not line.startswith(b'#'):
                 updated_content_lines.append(line)
 
             empty_lines_before_removed_block_list, empty_lines_in_a_row_list = (
@@ -118,7 +135,7 @@ def remove_file_parts_from_content(content_lines: List[str], unused_file_parts:
                     if indentation_is_not_childs(
                         previous_line=previous_non_removed_line, current_line=next_line_after_removed_block
                     ):
-                        updated_content_lines.append(f"{indentation_of_first_removed_line}pass\n")
+                        updated_content_lines.append(indentation_of_first_removed_line + b'pass\n')
 
                     # Add empty lines
                     if indentation_is_not_childs(
@@ -144,6 +161,6 @@ def remove_file_parts_from_content(content_lines: List[str], unused_file_parts:
 
     if was_block_removed:
         if ends_with_semicolon(previous_non_removed_line):
-            updated_content_lines.append(f"{indentation_of_first_removed_line}pass\n")
+            updated_content_lines.append(indentation_of_first_removed_line + b'pass\n')
 
     return updated_content_lines

deadcode/cli.py

@@ -2,7 +2,7 @@ from typing import List, Optional
 
 from deadcode.actions.find_python_filenames import find_python_filenames
 from deadcode.actions.find_unused_names import find_unused_names
-from deadcode.actions.fix_unused_code import fix_unused_code
+from deadcode.actions.fix_or_show_unused_code import fix_or_show_unused_code
 from deadcode.actions.parse_arguments import parse_arguments
 from deadcode.actions.get_unused_names_error_message import (
     get_unused_names_error_message,
@@ -19,16 +19,17 @@ def main(
     # TODO: rename unused_names to unused_code_items
     unused_names = find_unused_names(filenames=filenames, args=args)
 
-    if args.fix and unused_names:
-        fix_unused_code(unused_names)
+    file_diff = None
+    if (args.fix or args.dry) and unused_names:
+        file_diff = fix_or_show_unused_code(unused_names, args=args)
 
     if (error_message := get_unused_names_error_message(unused_names, args=args)) is not None:
-        return error_message
+        return error_message + ('\n\n' + file_diff if file_diff else '')
 
     if not args.count and not args.quiet:
-        print("\033[1mWell done!\033[0m ✨ 🚀 ✨")
+        print('\033[1mWell done!\033[0m ✨ 🚀 ✨')
     return None
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()