lapsed 2.4.1__py3-none-any.whl

deadcode/actions/parse_tach_config.py

@@ -0,0 +1,207 @@
+import re
+import sys
+from dataclasses import dataclass, field
+from logging import getLogger
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+logger = getLogger()
+
+
+@dataclass
+class TachInterface:
+    expose: List[str]
+    from_patterns: Optional[List[str]] = None
+
+
+@dataclass
+class TachModule:
+    path_patterns: List[str]
+    unchecked: bool = False
+
+
+@dataclass
+class TachConfig:
+    source_roots: List[Path]
+    modules: List[TachModule] = field(default_factory=list)
+    interfaces: List[TachInterface] = field(default_factory=list)
+
+
+class TachIndex:
+    """Answers dead-code-relevant questions derived from one or more tach.toml files."""
+
+    def __init__(self, configs: List[TachConfig]) -> None:
+        self._configs = configs
+
+    def is_unchecked(self, file: Path) -> bool:
+        for config in self._configs:
+            module_path = _dotted_module_path(file, config.source_roots)
+            if module_path is None:
+                continue
+            for module in config.modules:
+                if module.unchecked and _match_any_dotted_glob(module.path_patterns, module_path):
+                    return True
+        return False
+
+    def is_exposed(self, file: Path, name: str) -> bool:
+        for config in self._configs:
+            module_path = _dotted_module_path(file, config.source_roots)
+            if module_path is None:
+                continue
+            for interface in config.interfaces:
+                adopts_interface = interface.from_patterns is None or _match_any_regex(
+                    interface.from_patterns, module_path
+                )
+                if adopts_interface and _match_any_regex(interface.expose, name):
+                    return True
+        return False
+
+
+def load_tach_index(tach_config_paths: Iterable[str]) -> TachIndex:
+    configs = []
+    for raw_path in tach_config_paths:
+        path = Path(raw_path).resolve()
+        if not path.is_file():
+            logger.error(f'Error: tach config {path} could not be found.')
+            continue
+        configs.append(_parse_tach_toml(path))
+    return TachIndex(configs)
+
+
+def _parse_tach_toml(path: Path) -> TachConfig:
+    with open(path, 'rb') as f:
+        data = tomllib.load(f)
+
+    project_root = path.parent
+    raw_source_roots = data.get('source_roots') or ['.']
+    source_roots = [(project_root / root).resolve() for root in raw_source_roots]
+
+    config = TachConfig(source_roots=source_roots)
+    config.modules.extend(_extract_modules(data))
+    config.interfaces.extend(_extract_interfaces(data))
+
+    for source_root in source_roots:
+        if not source_root.is_dir():
+            continue
+        for domain_file in sorted(source_root.rglob('tach.domain.toml')):
+            _merge_domain_toml(config, domain_file, source_root)
+
+    return config
+
+
+def _extract_modules(data: Dict[str, Any]) -> List[TachModule]:
+    modules = []
+    for raw in data.get('modules', []):
+        if 'paths' in raw:
+            patterns = list(raw['paths'])
+        elif 'path' in raw:
+            patterns = [raw['path']]
+        else:
+            continue
+        modules.append(TachModule(path_patterns=patterns, unchecked=bool(raw.get('unchecked', False))))
+    return modules
+
+
+def _extract_interfaces(data: Dict[str, Any]) -> List[TachInterface]:
+    interfaces = []
+    for raw in data.get('interfaces', []):
+        expose = list(raw.get('expose', []))
+        if not expose:
+            continue
+        from_patterns = list(raw['from']) if 'from' in raw else None
+        interfaces.append(TachInterface(expose=expose, from_patterns=from_patterns))
+    return interfaces
+
+
+def _merge_domain_toml(config: TachConfig, domain_file: Path, source_root: Path) -> None:
+    with open(domain_file, 'rb') as f:
+        data = tomllib.load(f)
+
+    domain_root_dotted = _dotted_dir_path(domain_file.parent, source_root)
+
+    def resolve(entry: str) -> str:
+        if entry.startswith('//'):
+            return entry[2:]
+        if entry == '':
+            return domain_root_dotted
+        if domain_root_dotted:
+            return f'{domain_root_dotted}.{entry}'
+        return entry
+
+    modules = _extract_modules(data)
+    for module in modules:
+        module.path_patterns = [resolve(pattern) for pattern in module.path_patterns]
+    config.modules.extend(modules)
+
+    interfaces = _extract_interfaces(data)
+    for interface in interfaces:
+        if interface.from_patterns is not None:
+            interface.from_patterns = [resolve(pattern) for pattern in interface.from_patterns]
+    config.interfaces.extend(interfaces)
+
+    root_table = data.get('root')
+    if isinstance(root_table, dict) and root_table.get('unchecked'):
+        config.modules.append(TachModule(path_patterns=[domain_root_dotted], unchecked=True))
+
+
+def _dotted_dir_path(directory: Path, source_root: Path) -> str:
+    directory = directory.resolve()
+    source_root = source_root.resolve()
+    if directory == source_root:
+        return ''
+    return '.'.join(directory.relative_to(source_root).parts)
+
+
+def _dotted_module_path(file: Path, source_roots: List[Path]) -> Optional[str]:
+    file = file.resolve()
+
+    best_root: Optional[Path] = None
+    for source_root in source_roots:
+        source_root = source_root.resolve()
+        if source_root in file.parents and (best_root is None or len(source_root.parts) > len(best_root.parts)):
+            best_root = source_root
+
+    if best_root is None:
+        return None
+
+    parts = list(file.relative_to(best_root).parts)
+    if parts and parts[-1] == '__init__.py':
+        parts = parts[:-1]
+    elif parts and parts[-1].endswith('.py'):
+        parts[-1] = parts[-1][: -len('.py')]
+    else:
+        return None
+
+    return '.'.join(parts) if parts else None
+
+
+def _dotted_glob_to_regex(pattern: str) -> re.Pattern[str]:
+    regex_segments = [
+        '.*' if segment == '**' else re.escape(segment).replace(r'\*', '[^.]*') for segment in pattern.split('.')
+    ]
+    return re.compile(r'\.'.join(regex_segments))
+
+
+def _match_any_dotted_glob(patterns: Iterable[str], dotted_path: str) -> bool:
+    return any(_dotted_glob_to_regex(pattern).fullmatch(dotted_path) for pattern in patterns)
+
+
+def _try_compile_regex(pattern: str) -> Optional[re.Pattern[str]]:
+    try:
+        return re.compile(pattern)
+    except re.error:
+        logger.exception(f'Error: invalid tach interface regex pattern {pattern!r}.')
+        return None
+
+
+def _match_any_regex(patterns: Iterable[str], value: str) -> bool:
+    return any(
+        compiled.fullmatch(value)
+        for pattern in patterns
+        if (compiled := _try_compile_regex(pattern)) is not None
+    )

deadcode/actions/remove_file_parts_from_content.py

@@ -0,0 +1,166 @@
+import re
+from typing import List, Optional, TypeVar
+
+from deadcode.data_types import Part
+
+T = TypeVar('T')
+
+
+def list_get(list_: List[T], index: int) -> Optional[T]:
+    if len(list_) > index:
+        return list_[index]
+    return None
+
+
+def ends_with_semicolon(line: bytes) -> bool:
+    return line.strip().endswith(b':')
+
+
+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: bytes) -> bytes:
+    return bytes(re.findall(b'^\\s*', line)[0])
+
+
+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
+    if line_rstrip[:-2] != (line_with_removed_as := line_rstrip[:-2].rstrip()):
+        return line_with_removed_as
+    return line
+
+
+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 = []
+
+    # TODO: iterate by line and crop that line if needed.
+    unused_part_index = 0
+
+    previous_non_removed_line = b''
+    was_block_removed = False
+    next_line_after_removed_block = None
+    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
+        if unused_part := list_get(unused_file_parts, unused_part_index):
+            from_line, to_line, from_col, to_col = unused_part
+
+        # Skip lines, which have to be ignored.
+        if current_lineno > from_line and current_lineno < to_line:
+            continue
+
+        # Is it first line, which have to be ignored?
+        elif current_lineno == from_line:
+            indentation_of_first_removed_line = get_indentation(line)
+
+            if from_line == to_line:
+                # 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:
+                    # 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
+
+                if not line.strip():
+                    empty_lines_before_removed_block_list, empty_lines_in_a_row_list = (
+                        empty_lines_in_a_row_list,
+                        empty_lines_before_removed_block_list,
+                    )
+
+                    was_block_removed = True
+            else:
+                line = line[:from_col]
+
+            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(b'#'):
+                updated_content_lines.append(line)
+
+            empty_lines_before_removed_block_list, empty_lines_in_a_row_list = (
+                empty_lines_in_a_row_list,
+                empty_lines_before_removed_block_list,
+            )
+            was_block_removed = True
+
+        # Do not remove the line
+        else:
+            if not line.strip():
+                empty_lines_in_a_row_list.append(line)
+                continue
+
+                # if was_block_removed:  # These lines will be added when first non-empty line is found
+                #     continue
+            elif not was_block_removed:
+                updated_content_lines.extend(empty_lines_in_a_row_list)
+                empty_lines_in_a_row_list.clear()
+
+            else:
+                # Add pass if needed - if its a file end we should also check if pass have to be added.
+                next_line_after_removed_block = line
+
+                if ends_with_semicolon(previous_non_removed_line):
+                    if indentation_is_not_childs(
+                        previous_line=previous_non_removed_line, current_line=next_line_after_removed_block
+                    ):
+                        updated_content_lines.append(indentation_of_first_removed_line + b'pass\n')
+
+                    # Add empty lines
+                    if indentation_is_not_childs(
+                        previous_line=previous_non_removed_line, current_line=next_line_after_removed_block
+                    ):
+                        # Add lines after
+                        updated_content_lines.extend(empty_lines_in_a_row_list)
+                        empty_lines_in_a_row_list.clear()
+                        empty_lines_before_removed_block_list.clear()
+                    else:
+                        updated_content_lines.extend(empty_lines_before_removed_block_list)
+                        empty_lines_before_removed_block_list.clear()
+                        empty_lines_in_a_row_list.clear()
+
+                else:
+                    updated_content_lines.extend(empty_lines_before_removed_block_list)
+                    empty_lines_before_removed_block_list.clear()
+                    empty_lines_in_a_row_list.clear()
+
+            was_block_removed = False
+            previous_non_removed_line = line
+            updated_content_lines.append(line)
+
+    if was_block_removed:
+        if ends_with_semicolon(previous_non_removed_line):
+            updated_content_lines.append(indentation_of_first_removed_line + b'pass\n')
+
+    return updated_content_lines

deadcode/cli.py

@@ -0,0 +1,46 @@
+from typing import List, Optional
+import sys
+
+from deadcode import __version__
+from deadcode.actions.find_python_filenames import find_python_filenames
+from deadcode.actions.find_unused_names import find_unused_names
+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,
+)
+
+
+def main(
+    command_line_args: Optional[List[str]] = None,
+) -> Optional[str]:
+
+    if command_line_args and '--version' in command_line_args or '--version' in sys.argv:
+        return __version__
+
+    args = parse_arguments(command_line_args)
+
+    filenames = find_python_filenames(args=args)
+
+    # TODO: rename unused_names to unused_code_items
+    unused_names = find_unused_names(filenames=filenames, args=args)
+
+    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 + ('\n\n' + file_diff if file_diff else '')
+
+    if not args.count and not args.quiet:
+        print('\033[1mWell done!\033[0m ✨ 🚀 ✨')
+    return None
+
+
+def print_main() -> None:
+    if result := main():
+        print(result)
+
+
+if __name__ == '__main__':
+    print_main()

deadcode/constants.py

@@ -0,0 +1,49 @@
+from typing import Dict, Literal
+
+
+UnusedCodeType = Literal[
+    'attribute',
+    'class',
+    'function',
+    'import',
+    'method',
+    'property',
+    'variable',
+    'unreachable_code',
+    'name',
+    'unused_file',
+    'commented_out_code',
+    'ignore_expression',
+]
+
+
+UnusedCodeErrorCode = Literal[
+    'DC01',
+    'DC02',
+    'DC03',
+    'DC04',
+    'DC05',
+    'DC06',
+    'DC07',
+    'DC08',
+    'DC09',
+    'DC11',
+    'DC12',
+    'DC13',
+]
+
+
+ERROR_TYPE_TO_ERROR_CODE: Dict[UnusedCodeType, UnusedCodeErrorCode] = {
+    'variable': 'DC01',
+    'function': 'DC02',
+    'class': 'DC03',
+    'method': 'DC04',
+    'attribute': 'DC05',
+    'name': 'DC06',
+    'import': 'DC07',
+    'property': 'DC08',
+    'unreachable_code': 'DC09',
+    'unused_file': 'DC11',
+    'commented_out_code': 'DC12',
+    'ignore_expression': 'DC13',
+}

deadcode/data_types.py

@@ -0,0 +1,46 @@
+import ast
+
+from dataclasses import dataclass
+from typing import Iterable, NamedTuple
+
+
+AbstractSyntaxTree = ast.Module  # Should be module instead of ast
+FileContent = bytes
+Filename = str  # Contains full path to existing file
+Pathname = str  # Can contain wildewards
+
+
+@dataclass
+class Args:
+    fix: bool = False
+    verbose: bool = False
+    version: bool = False
+    dry: bool = False
+    only: Iterable[Pathname] = ()
+    paths: Iterable[Pathname] = ()
+    exclude: Iterable[Pathname] = ()
+    ignore_definitions: Iterable[Pathname] = ()
+    ignore_definitions_if_decorated_with: Iterable[Pathname] = ()
+    ignore_definitions_if_inherits_from: Iterable[Pathname] = ()
+    ignore_bodies_of: Iterable[Pathname] = ()
+    ignore_bodies_if_decorated_with: Iterable[Pathname] = ()
+    ignore_bodies_if_inherits_from: Iterable[Pathname] = ()
+    ignore_if_decorated_with: Iterable[Pathname] = ()
+    ignore_if_inherits_from: Iterable[Pathname] = ()
+    ignore_names: Iterable[Pathname] = ()
+    ignore_names_if_decorated_with: Iterable[Pathname] = ()
+    ignore_names_if_inherits_from: Iterable[Pathname] = ()
+    ignore_names_in_files: Iterable[Pathname] = ()
+    tach_config: Iterable[Pathname] = ()
+    no_color: bool = False
+    quiet: bool = False
+    count: bool = False
+
+
+class Part(NamedTuple):
+    """Code file part"""
+
+    line_start: int
+    line_end: int
+    col_start: int
+    col_end: int

deadcode/utils/add_colors_to_diff.py

@@ -0,0 +1,10 @@
+def add_colors_to_diff(diff: bytes) -> bytes:
+    colorful_lines = []
+    for line in diff.split(b'\n'):
+        colorful_line = line
+        if line.startswith(b'-'):
+            colorful_line = b'\033[31m' + colorful_line + b'\033[0m'
+        if line.startswith(b'+'):
+            colorful_line = b'\033[32m' + colorful_line + b'\033[0m'
+        colorful_lines.append(colorful_line)
+    return b'\n'.join(colorful_lines)

deadcode/utils/base_test_case.py

@@ -0,0 +1,88 @@
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+from unittest import TestCase
+from unittest.mock import MagicMock, patch
+
+from deadcode.utils.fix_indent import fix_indent
+from deadcode.data_types import Args
+
+
+class BaseTestCase(TestCase):
+    files: Dict[str, bytes] = {}
+
+    maxDiff = None
+
+    def patch(self, path: str) -> MagicMock:
+        patcher = patch(path)
+        self.addCleanup(patcher.stop)
+        return patcher.start()
+
+    def _get_filenames(self, *args: Any, **kwargs: Any) -> List[str]:
+        return list(self.files.keys())
+
+    def _read_file_side_effect(self, filename: Union[str, Path], *args: Any, **kwargs: Any) -> MagicMock:
+        mock = MagicMock()
+        mock.filename = str(filename)
+
+        def cache_file_content(file_content: bytes) -> int:
+            self.updated_files[mock.filename] = file_content
+            return len(file_content)
+
+        if file_content := fix_indent(self.files[mock.filename]):
+            mock.__enter__().read.return_value = file_content
+            mock.__enter__().readlines.return_value = [line + b'\n' for line in file_content.split(b'\n')]
+            mock.__enter__().write.side_effect = cache_file_content
+        return mock
+
+    def setUp(self) -> None:
+        self.updated_files: Dict[str, bytes] = {}
+
+        self.find_python_filenames_mock = self.patch('deadcode.cli.find_python_filenames')
+        self.find_python_filenames_mock.side_effect = self._get_filenames
+
+        self.read_file_mock = self.patch('deadcode.visitor.dead_code_visitor.open')
+        self.read_file_mock.side_effect = self._read_file_side_effect
+
+        self.fix_file_mock = self.patch('deadcode.actions.fix_or_show_unused_code.open')
+        self.fix_file_mock.side_effect = self._read_file_side_effect
+
+        self.os_remove = self.patch('deadcode.actions.fix_or_show_unused_code.os.remove')
+
+        self.args = Args()
+
+    def assertFiles(self, files: Dict[str, bytes], removed: Optional[List[str]] = None) -> None:
+        expected_removed_files = removed
+        expected_files = files
+
+        # Check if removed files match
+        removed_filenames = [call.args[0] for call in self.os_remove.mock_calls]
+        if expected_removed_files:
+            self.assertEqual(removed_filenames, expected_removed_files)
+
+        # Check if non removed files are the same
+        unchanged_files = {
+            filename: file_content
+            for filename, file_content in self.files.items()
+            if filename not in self.updated_files and filename not in removed_filenames
+        }
+        self.assertListEqual(
+            list(expected_files.keys()), list(self.updated_files.keys()) + list(unchanged_files.keys())
+        )
+
+        # Check if non removed file contents match (both changed and unchanged)
+        for filename, content in expected_files.items():
+            self.assertEqual(
+                fix_indent(content),
+                fix_indent(self.updated_files.get(filename) or unchanged_files.get(filename) or ''),
+            )
+
+    def assertUpdatedFiles(self, expected_updated_files: Dict[str, bytes]) -> None:
+        """Checks if updated files match expected updated files."""
+
+        self.assertListEqual(list(expected_updated_files.keys()), list(self.updated_files.keys()))
+
+        for filename, content in expected_updated_files.items():
+            self.assertEqual(
+                fix_indent(content),
+                self.updated_files[filename],
+            )

deadcode/utils/fix_indent.py

@@ -0,0 +1,70 @@
+import sys
+from typing import Optional, TypeVar
+
+T = TypeVar('T')
+
+
+def fix_indent(doc: T) -> Optional[T]:
+    """Finds indentation of a first line and removes it from all following lines.
+
+    Implemented based on inspect.cleandoc by keeping trailing lines.
+    """
+    if isinstance(doc, bytes):
+        try:
+            byte_lines = doc.expandtabs().split(b'\n')
+        except UnicodeError:
+            return None
+        else:
+            # Find minimum indentation of any non-blank lines after first line.
+            margin = sys.maxsize
+            for byte_line in byte_lines[0:]:
+                content = len(byte_line.lstrip())
+                if content:
+                    indent = len(byte_line) - content
+                    margin = min(margin, indent)
+            # Remove indentation.
+            if byte_lines:
+                byte_lines[0] = byte_lines[0].lstrip()
+            if margin < sys.maxsize:
+                for i in range(1, len(byte_lines)):
+                    byte_lines[i] = byte_lines[i][margin:]
+
+            ## Do not remove trailing lines
+            # while lines and not lines[-1]:
+            #     lines.pop()
+
+            ## Remove any leading blank lines.
+            while byte_lines and not byte_lines[0]:
+                byte_lines.pop(0)
+            return b'\n'.join(byte_lines)  # type: ignore
+
+    if isinstance(doc, str):
+        try:
+            lines = doc.expandtabs().split('\n')
+        except UnicodeError:
+            return None
+        else:
+            # Find minimum indentation of any non-blank lines after first line.
+            margin = sys.maxsize
+            for line in lines[0:]:
+                content = len(line.lstrip())
+                if content:
+                    indent = len(line) - content
+                    margin = min(margin, indent)
+            # Remove indentation.
+            if lines:
+                lines[0] = lines[0].lstrip()
+            if margin < sys.maxsize:
+                for i in range(1, len(lines)):
+                    lines[i] = lines[i][margin:]
+
+            ## Do not remove trailing lines
+            # while lines and not lines[-1]:
+            #     lines.pop()
+
+            ## Remove any leading blank lines.
+            while lines and not lines[0]:
+                lines.pop(0)
+            return '\n'.join(lines)  # type: ignore
+
+    return None