deadcode 2.5.0__py3-none-any.whl → 2.6.1__py3-none-any.whl

.venv310/bin/activate_this.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+Activate virtualenv for current interpreter:
+
+import runpy
+runpy.run_path(this_file)
+
+This can be used when you must use an existing Python interpreter, not the virtualenv bin/python.
+"""  # noqa: D415
+
+from __future__ import annotations
+
+import os
+import site
+import sys
+
+try:
+    abs_file = os.path.abspath(__file__)
+except NameError as exc:
+    msg = "You must use import runpy; runpy.run_path(this_file)"
+    raise AssertionError(msg) from exc
+
+bin_dir = os.path.dirname(abs_file)
+base = bin_dir[: -len("bin") - 1]  # strip away the bin part from the __file__, plus the path separator
+
+# prepend bin to PATH (this file is inside the bin directory)
+os.environ["PATH"] = os.pathsep.join([bin_dir, *os.environ.get("PATH", "").split(os.pathsep)])
+os.environ["VIRTUAL_ENV"] = base  # virtual env is right above bin directory
+os.environ["VIRTUAL_ENV_PROMPT"] = "" or os.path.basename(base)  # noqa: SIM222
+
+# add the virtual environments libraries to the host python import mechanism
+prev_length = len(sys.path)
+for lib in "../lib/python3.10/site-packages".split(os.pathsep):
+    path = os.path.realpath(os.path.join(bin_dir, lib))
+    site.addsitedir(path)
+sys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]
+
+sys.real_prefix = sys.prefix
+sys.prefix = base

.venv311/bin/activate_this.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+Activate virtualenv for current interpreter:
+
+import runpy
+runpy.run_path(this_file)
+
+This can be used when you must use an existing Python interpreter, not the virtualenv bin/python.
+"""  # noqa: D415
+
+from __future__ import annotations
+
+import os
+import site
+import sys
+
+try:
+    abs_file = os.path.abspath(__file__)
+except NameError as exc:
+    msg = "You must use import runpy; runpy.run_path(this_file)"
+    raise AssertionError(msg) from exc
+
+bin_dir = os.path.dirname(abs_file)
+base = bin_dir[: -len("bin") - 1]  # strip away the bin part from the __file__, plus the path separator
+
+# prepend bin to PATH (this file is inside the bin directory)
+os.environ["PATH"] = os.pathsep.join([bin_dir, *os.environ.get("PATH", "").split(os.pathsep)])
+os.environ["VIRTUAL_ENV"] = base  # virtual env is right above bin directory
+os.environ["VIRTUAL_ENV_PROMPT"] = "" or os.path.basename(base)  # noqa: SIM222
+
+# add the virtual environments libraries to the host python import mechanism
+prev_length = len(sys.path)
+for lib in "../lib/python3.11/site-packages".split(os.pathsep):
+    path = os.path.realpath(os.path.join(bin_dir, lib))
+    site.addsitedir(path)
+sys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]
+
+sys.real_prefix = sys.prefix
+sys.prefix = base

.venv314/bin/activate_this.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+Activate virtualenv for current interpreter:
+
+import runpy
+runpy.run_path(this_file)
+
+This can be used when you must use an existing Python interpreter, not the virtualenv bin/python.
+"""  # noqa: D415
+
+from __future__ import annotations
+
+import os
+import site
+import sys
+
+try:
+    abs_file = os.path.abspath(__file__)
+except NameError as exc:
+    msg = "You must use import runpy; runpy.run_path(this_file)"
+    raise AssertionError(msg) from exc
+
+bin_dir = os.path.dirname(abs_file)
+base = bin_dir[: -len("bin") - 1]  # strip away the bin part from the __file__, plus the path separator
+
+# prepend bin to PATH (this file is inside the bin directory)
+os.environ["PATH"] = os.pathsep.join([bin_dir, *os.environ.get("PATH", "").split(os.pathsep)])
+os.environ["VIRTUAL_ENV"] = base  # virtual env is right above bin directory
+os.environ["VIRTUAL_ENV_PROMPT"] = "" or os.path.basename(base)  # noqa: SIM222
+
+# add the virtual environments libraries to the host python import mechanism
+prev_length = len(sys.path)
+for lib in "../lib/python3.14/site-packages".split(os.pathsep):
+    path = os.path.realpath(os.path.join(bin_dir, lib))
+    site.addsitedir(path)
+sys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]
+
+sys.real_prefix = sys.prefix
+sys.prefix = base

.venv315/bin/activate_this.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2020-202x The virtualenv developers
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""
+Activate virtualenv for current interpreter:
+
+import runpy
+runpy.run_path(this_file)
+
+This can be used when you must use an existing Python interpreter, not the virtualenv bin/python.
+"""  # noqa: D415
+
+from __future__ import annotations
+
+import os
+import site
+import sys
+
+try:
+    abs_file = os.path.abspath(__file__)
+except NameError as exc:
+    msg = "You must use import runpy; runpy.run_path(this_file)"
+    raise AssertionError(msg) from exc
+
+bin_dir = os.path.dirname(abs_file)
+base = bin_dir[: -len("bin") - 1]  # strip away the bin part from the __file__, plus the path separator
+
+# prepend bin to PATH (this file is inside the bin directory)
+os.environ["PATH"] = os.pathsep.join([bin_dir, *os.environ.get("PATH", "").split(os.pathsep)])
+os.environ["VIRTUAL_ENV"] = base  # virtual env is right above bin directory
+os.environ["VIRTUAL_ENV_PROMPT"] = "" or os.path.basename(base)  # noqa: SIM222
+
+# add the virtual environments libraries to the host python import mechanism
+prev_length = len(sys.path)
+for lib in "../lib/python3.15/site-packages".split(os.pathsep):
+    path = os.path.realpath(os.path.join(bin_dir, lib))
+    site.addsitedir(path)
+sys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]
+
+sys.real_prefix = sys.prefix
+sys.prefix = base

deadcode/__init__.py

@@ -2,7 +2,7 @@ try:
     import importlib.metadata
 
     __version__ = importlib.metadata.version(__package__ or __name__)
-except ImportError:
+except ImportError:  # pragma: no cover
     import importlib_metadata
 
     __version__ = importlib_metadata.version(__package__ or __name__)

deadcode/actions/find_python_filenames.py

@@ -1,5 +1,4 @@
 from logging import getLogger
-from typing import List
 from pathlib import Path
 
 from deadcode.data_types import Args
@@ -8,9 +7,9 @@ from deadcode.visitor.ignore import _match
 logger = getLogger()
 
 
-def find_python_filenames(args: Args) -> List[str]:
+def find_python_filenames(args: Args) -> list[str]:
     filenames = []
-    paths: List[str] = list(args.paths)
+    paths: list[str] = list(args.paths)
     while paths:
         path = Path(paths.pop())
 
@@ -32,18 +31,3 @@ def find_python_filenames(args: Args) -> List[str]:
         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

@@ -1,4 +1,4 @@
-from typing import List, Iterable
+from collections.abc import Iterable
 
 from deadcode.data_types import Args, Filename
 from deadcode.visitor.code_item import CodeItem
@@ -6,7 +6,7 @@ from deadcode.visitor.dead_code_visitor import DeadCodeVisitor
 
 
 def find_unused_names(
-    filenames: List[Filename],
+    filenames: list[Filename],
     args: Args,
 ) -> Iterable[CodeItem]:
     dead_code_visitor = DeadCodeVisitor(filenames, args)

deadcode/actions/fix_or_show_unused_code.py

@@ -1,8 +1,9 @@
 from collections import defaultdict
 from difflib import diff_bytes, unified_diff
-from typing import Iterable
+from collections.abc import Iterable
 import os
 
+from deadcode.actions.get_unused_import_parts import get_unused_import_parts
 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
@@ -19,7 +20,7 @@ def fix_or_show_unused_code(unused_items: Iterable[CodeItem], args: Args) -> str
     # 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
+    # TODO: remove leftover trailing commas, whitespace and empty lines for non-import expressions.
 
     filename_to_unused_items = defaultdict(list)
     for unused_item in unused_items:
@@ -28,13 +29,20 @@ def fix_or_show_unused_code(unused_items: Iterable[CodeItem], args: Args) -> str
     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])
+        import_items = [item for item in file_unused_items if item.type_ == 'import']
+        other_items = [item for item in file_unused_items if item.type_ != 'import']
 
-        unused_file_parts = merge_overlaping_file_parts(file_parts)
+        with open(filename, 'rb') as f:
+            file_content = f.read()
 
         with open(filename, 'rb') as f:
             file_content_lines = f.readlines()
 
+        import_parts = get_unused_import_parts(file_content, import_items) if import_items else []
+        file_parts = flatten_list([item.code_parts for item in other_items]) + import_parts
+
+        unused_file_parts = merge_overlaping_file_parts(file_parts)
+
         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():
@@ -58,7 +66,6 @@ def fix_or_show_unused_code(unused_items: Iterable[CodeItem], args: Args) -> str
 
                 elif args.fix:
                     with open(filename, 'wb') as f:
-                        # TODO: is there a method writelines?
                         f.write(updated_file_content)
         else:
             os.remove(filename)
@@ -66,7 +73,3 @@ def fix_or_show_unused_code(unused_items: Iterable[CodeItem], args: Args) -> str
     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_import_parts.py

@@ -0,0 +1,207 @@
+import ast
+
+from collections.abc import Iterable
+
+from deadcode.data_types import Part
+from deadcode.utils.flatten_lists import flatten_list
+from deadcode.visitor.code_item import CodeItem
+
+ImportAliasKey = tuple[str, int | None, int | None]
+
+
+def get_import_alias_key(alias: ast.alias) -> ImportAliasKey:
+    """Returns the key that identifies an import alias in reported findings."""
+    return alias.asname or alias.name.partition('.')[0], alias.lineno, alias.col_offset
+
+
+def _line_bytes(content_lines: list[bytes], line_number: int) -> bytes:
+    if 1 <= line_number <= len(content_lines):
+        return content_lines[line_number - 1]
+    return b''
+
+
+def _find_byte(content_lines: list[bytes], line_number: int, start_col: int, end_col: int, needle: bytes) -> int | None:
+    position = _line_bytes(content_lines, line_number).find(needle, start_col, end_col)
+    if position == -1:
+        return None
+    return position
+
+
+def _find_comma_between(
+    content_lines: list[bytes], start: tuple[int, int], end: tuple[int, int]
+) -> tuple[int, int] | None:
+    """Returns the position of the first comma between two source positions."""
+    start_line, start_col = start
+    end_line, end_col = end
+
+    for line_number in range(start_line, end_line + 1):
+        line = _line_bytes(content_lines, line_number)
+        if line_number == start_line and line_number == end_line:
+            position = _find_byte(content_lines, line_number, start_col, end_col, b',')
+        elif line_number == start_line:
+            position = _find_byte(content_lines, line_number, start_col, len(line), b',')
+        elif line_number == end_line:
+            position = _find_byte(content_lines, line_number, 0, end_col, b',')
+        else:
+            position = _find_byte(content_lines, line_number, 0, len(line), b',')
+
+        if position is not None:
+            return line_number, position
+
+    return None
+
+
+def _end_of_line_content(content_lines: list[bytes], line_number: int) -> int:
+    """Returns the length of a line without its trailing line terminator."""
+    line = _line_bytes(content_lines, line_number)
+    for terminator in (b'\r\n', b'\n', b'\r'):
+        if line.endswith(terminator):
+            return len(line) - len(terminator)
+    return len(line)
+
+
+def _first_non_whitespace_column(content_lines: list[bytes], line_number: int, start_column: int) -> int | None:
+    """Returns the first non-whitespace column at or after ``start_column``."""
+    line = _line_bytes(content_lines, line_number)
+    end_column = _end_of_line_content(content_lines, line_number)
+    for column in range(start_column, end_column):
+        if line[column : column + 1] not in (b' ', b'\t'):
+            return column
+    return None
+
+
+def _last_non_whitespace_column_before(content_lines: list[bytes], line_number: int, end_column: int) -> int | None:
+    """Returns the last non-whitespace column strictly before ``end_column``."""
+    line = _line_bytes(content_lines, line_number)
+    for column in range(end_column - 1, -1, -1):
+        if line[column : column + 1] not in (b' ', b'\t'):
+            return column
+    return None
+
+
+def _is_only_whitespace_or_comment(remainder: bytes) -> bool:
+    """Returns whether the remainder is whitespace or a trailing comment."""
+    stripped_remainder = remainder.strip()
+    return not stripped_remainder or stripped_remainder.startswith(b'#')
+
+
+def _end_of_whitespace_after_comma(content_lines: list[bytes], comma: tuple[int, int]) -> int:
+    line = _line_bytes(content_lines, comma[0])
+    end_col = comma[1] + 1
+    while end_col < len(line) and line[end_col : end_col + 1] in (b' ', b'\t'):
+        end_col += 1
+    return end_col
+
+
+def get_unused_import_parts(content: bytes, unused_import_items: Iterable[CodeItem]) -> list[Part]:
+    """Returns code parts to remove for unused import findings.
+
+    When every non-wildcard alias of an import statement is unused, the whole
+    statement is returned as a single part. Otherwise each unused alias is
+    returned together with one adjacent comma, so the remaining aliases keep
+    valid comma placement.
+    """
+    unused_import_items = list(unused_import_items)
+    fallback_parts = flatten_list([item.code_parts for item in unused_import_items])
+    removable_keys = {(item.name, item.name_line, item.name_column) for item in unused_import_items}
+
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return fallback_parts
+
+    content_lines = content.splitlines(keepends=True)
+    import_parts: list[Part] = []
+    matched_keys: set[ImportAliasKey] = set()
+
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.Import, ast.ImportFrom)):
+            continue
+
+        # A wildcard alias is never removable.
+        aliases = [alias for alias in node.names if alias.name != '*']
+        if not aliases:
+            continue
+
+        alias_keys = [get_import_alias_key(alias) for alias in aliases]
+
+        if all(key in removable_keys for key in alias_keys):
+            if node.end_lineno is None or node.end_col_offset is None:
+                continue
+
+            start_column = node.col_offset
+            end_column = node.end_col_offset
+            following_column = _first_non_whitespace_column(content_lines, node.end_lineno, end_column)
+            if (
+                following_column is not None
+                and _line_bytes(content_lines, node.end_lineno)[following_column : following_column + 1] == b';'
+            ):
+                end_column = following_column + 1
+                after_separator_column = _first_non_whitespace_column(content_lines, node.end_lineno, end_column)
+                if after_separator_column is not None:
+                    end_column = after_separator_column
+            else:
+                preceding_column = _last_non_whitespace_column_before(content_lines, node.lineno, node.col_offset)
+                if (
+                    preceding_column is not None
+                    and _line_bytes(content_lines, node.lineno)[preceding_column : preceding_column + 1] == b';'
+                ):
+                    start_column = preceding_column
+
+            line_content_end = _end_of_line_content(content_lines, node.end_lineno)
+            remainder = _line_bytes(content_lines, node.end_lineno)[end_column:line_content_end]
+            if _is_only_whitespace_or_comment(remainder):
+                end_column = line_content_end
+
+            import_parts.append(Part(node.lineno, node.end_lineno, start_column, end_column))
+            matched_keys.update(alias_keys)
+            continue
+
+        for index, alias in enumerate(aliases):
+            key = alias_keys[index]
+            if key not in removable_keys or alias.end_lineno is None or alias.end_col_offset is None:
+                continue
+
+            if index + 1 < len(aliases):
+                next_alias = aliases[index + 1]
+                comma = _find_comma_between(
+                    content_lines,
+                    (alias.end_lineno, alias.end_col_offset),
+                    (next_alias.lineno, next_alias.col_offset),
+                )
+                if comma is None:
+                    matched_keys.add(key)
+                    continue
+                end_col = _end_of_whitespace_after_comma(content_lines, comma)
+                import_parts.append(Part(alias.lineno, comma[0], alias.col_offset, end_col))
+            else:
+                previous_alias = aliases[index - 1]
+                if previous_alias.end_lineno is None or previous_alias.end_col_offset is None:
+                    import_parts.append(Part(alias.lineno, alias.end_lineno, alias.col_offset, alias.end_col_offset))
+                else:
+                    comma = _find_comma_between(
+                        content_lines,
+                        (previous_alias.end_lineno, previous_alias.end_col_offset),
+                        (alias.lineno, alias.col_offset),
+                    )
+                    if comma is None:
+                        matched_keys.add(key)
+                        continue
+                    if previous_alias.end_lineno != alias.lineno:
+                        import_parts.append(
+                            Part(comma[0], comma[0], comma[1], _end_of_line_content(content_lines, comma[0]))
+                        )
+                        import_parts.append(Part(alias.lineno, alias.end_lineno, 0, alias.end_col_offset))
+                    else:
+                        import_parts.append(Part(comma[0], alias.end_lineno, comma[1], alias.end_col_offset))
+
+            matched_keys.add(key)
+
+    remaining_fallback_parts = [
+        part
+        for item in unused_import_items
+        if (item.name, item.name_line, item.name_column) not in matched_keys
+        for part in item.code_parts
+    ]
+
+    return list(dict.fromkeys(import_parts + remaining_fallback_parts))

deadcode/actions/get_unused_names_error_message.py

@@ -1,15 +1,20 @@
-from typing import Iterable, Optional
+from collections.abc import Iterable
 
 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]:
+def get_unused_names_error_message(unused_names: Iterable[CodeItem], args: Args) -> str | None:
     unused_names = list(unused_names)
+    had_unused_names = bool(unused_names)
+
+    if args.only:
+        unused_names = [item for item in unused_names if _match(item.filename, args.only)]
 
     if not unused_names:
-        return None
+        # Filtering away every finding keeps the historical empty message instead of reporting a clean run.
+        return '' if had_unused_names and not args.count and not args.quiet else None
 
     if args.quiet:
         return ''
@@ -19,17 +24,16 @@ def get_unused_names_error_message(unused_names: Iterable[CodeItem], args: Args)
 
     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)
+        message = f'{item.filename_with_position} \033[91m{item.error_code}\033[0m '
+        message += item.message or (
+            f'{item.type_.replace("_", " ").capitalize()} `\033[1m{item.name}\033[0m` 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 ''}!"
+        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)

deadcode/actions/merge_overlaping_file_parts.py

@@ -1,4 +1,3 @@
-from typing import List, Optional, Tuple
 from deadcode.data_types import Part
 
 
@@ -13,11 +12,11 @@ def does_include(bigger_part: Part, smaller_part: Part) -> bool:
     return bool(starts_later and ends_faster)
 
 
-def sort_parts(bigger_part: Part, smaller_part: Part) -> Tuple[Part, Part]:
+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
+    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)):
@@ -28,14 +27,14 @@ def sort_parts(bigger_part: Part, smaller_part: Part) -> Tuple[Part, 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
+    _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]:
+def merge_parts(p1: Part, p2: Part) -> Part | None:
     p1, p2 = sort_parts(p1, p2)
 
     line_start1, line_end1, col_start1, col_end1 = p1
@@ -58,10 +57,10 @@ def merge_parts(p1: Part, p2: Part) -> Optional[Part]:
     return None
 
 
-def merge_overlaping_file_parts(overlaping_file_parts: List[Part]) -> List[Part]:
+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] = []
+    non_overlaping_file_parts: list[Part] = []
     for p1 in sorted(overlaping_file_parts):
         merged_part = None
         merged_with_index = None