lapsed 2.7.2__tar.gz → 2.9.0__tar.gz

{lapsed-2.7.2 → lapsed-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lapsed
-Version: 2.7.2
+Version: 2.9.0
 Summary: Find and remove dead code.
 Project-URL: homepage, https://github.com/albertas/deadcode
 Project-URL: documentation, https://deadcode.readthedocs.io/

{lapsed-2.7.2 → lapsed-2.9.0}/deadcode/actions/find_python_filenames.py

@@ -33,9 +33,11 @@ def find_python_filenames(args: Args) -> List[str]:
             continue
 
         if path.is_file() and path.suffix == '.py':
-            filenames.append(str(path))
+            # .as_posix() (not str()) so filenames stay forward-slash on every
+            # OS, matching the paths given on the command line.
+            filenames.append(path.as_posix())
         elif path.is_dir():
-            paths += list([str(p) for p in path.glob('*')])
+            paths += list([p.as_posix() 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

{lapsed-2.7.2 → lapsed-2.9.0}/deadcode/actions/fix_or_show_unused_code.py

@@ -23,7 +23,10 @@ def fix_or_show_unused_code(unused_items: Iterable[CodeItem], args: Args) -> str
 
     filename_to_unused_items = defaultdict(list)
     for unused_item in unused_items:
-        filename_to_unused_items[str(unused_item.filename)].append(unused_item)
+        # .as_posix() (not str()) to match the forward-slash filenames
+        # find_python_filenames() produces, which the mocked/real `open()`
+        # calls below key off of.
+        filename_to_unused_items[unused_item.filename.as_posix()].append(unused_item)
 
     result = []
 

{lapsed-2.7.2 → lapsed-2.9.0}/deadcode/actions/parse_tach_config.py

@@ -1,9 +1,10 @@
 import re
 import sys
 from dataclasses import dataclass, field
+from functools import lru_cache
 from logging import getLogger
 from pathlib import Path
-from typing import Any, Dict, Iterable, List, Optional
+from typing import Any, Dict, Iterable, List, Optional, Tuple
 
 if sys.version_info >= (3, 11):
     import tomllib
@@ -46,6 +47,9 @@ class TachIndex:
         every other tach project it might also belong to. Paths unrelated to any tach project
         (e.g. an explicitly provided directory that lives elsewhere entirely) are unaffected.
         """
+        if not self._configs:
+            return False
+
         path = path.resolve()
 
         related_to_any_config = False
@@ -89,6 +93,14 @@ class TachIndex:
 
 
 def load_tach_index(tach_config_paths: Iterable[str]) -> TachIndex:
+    # find_python_filenames() and DeadCodeVisitor.__init__() both load the
+    # tach index from the same args.tach_config, so cache it per path set to
+    # avoid re-parsing (and re-globbing for tach.domain.toml files) twice.
+    return _load_tach_index_cached(tuple(tach_config_paths))
+
+
+@lru_cache(maxsize=None)
+def _load_tach_index_cached(tach_config_paths: Tuple[str, ...]) -> TachIndex:
     configs = []
     for raw_path in tach_config_paths:
         path = Path(raw_path).resolve()

{lapsed-2.7.2 → lapsed-2.9.0}/deadcode/cli.py

@@ -33,14 +33,25 @@ def main(
         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 ✨ 🚀 ✨')
+        try:
+            print('\033[1mWell done!\033[0m ✨ 🚀 ✨')
+        except UnicodeEncodeError:
+            # Some terminals (e.g. Windows' default cp1252 console codepage) cannot
+            # encode emoji. Fall back to a plain message rather than crashing.
+            print('\033[1mWell done!\033[0m')
     return None
 
 
 def print_main() -> None:
-    if result := main():
+    is_version_request = '--version' in sys.argv
+
+    result = main()
+    if result:
         print(result)
 
+    if not is_version_request and result is not None:
+        sys.exit(1)
+
 
 if __name__ == '__main__':
     print_main()

{lapsed-2.7.2 → lapsed-2.9.0}/deadcode/utils/nested_scopes.py

@@ -2,6 +2,15 @@ from typing import Any, Dict, List, Optional, Union
 
 from deadcode.visitor.code_item import CodeItem
 
+# Sentinel key used to store a scope's own CodeItem definitions in a dict
+# separate from its nested child-scope dicts. A scope-part name (e.g. a class
+# or function name) and a CodeItem's name can be the same string (a class
+# named `Bar` nested under module `foo` is both a child scope `foo.Bar` and a
+# CodeItem named `Bar` defined in scope `foo`), so they can't share one dict's
+# key space without ambiguity. `object()` can't equal any string or CodeItem,
+# so it can't collide with either.
+_ITEMS = object()
+
 
 class NestedScope:
     """This data structure is used to track what types are defined in each scope.
@@ -15,7 +24,7 @@ class NestedScope:
     """
 
     def __init__(self) -> None:
-        self._scopes: Dict[Union[str, CodeItem], Any] = {}
+        self._scopes: Dict[Union[str, CodeItem, object], Any] = {}
 
     def add(self, code_item: CodeItem) -> None:
         """Adds code item to nested scope."""
@@ -31,8 +40,12 @@ class NestedScope:
                 current_scope[scope_part] = {}  # Could use None if type cannot have scope
             current_scope = current_scope[scope_part]
 
-        # > TODO: leaf should be replaced. Is it replaced with new code item?
-        current_scope[code_item] = {}
+        # Store this scope's own definitions in their own dict (keyed by
+        # _ITEMS) instead of mixing them into current_scope's child-scope
+        # keys, so get() below can do a direct O(1) dict lookup by name
+        # instead of scanning current_scope.keys() for a match.
+        items: Dict[Union[str, CodeItem], CodeItem] = current_scope.setdefault(_ITEMS, {})
+        items[code_item] = code_item
 
     def get(self, name: str, scope: str) -> Optional[Union[CodeItem, str]]:
         """Returns CodeItem which matches scoped_name (e.g. package.class.method.variable)
@@ -45,7 +58,7 @@ class NestedScope:
         #       projects.models, billing.models, auth.models: only one root scope called models would be registered.
 
         # Create a stack of scopes begining from nearest and following with parent one
-        scopes: List[Dict[Union[CodeItem, str], Dict[Any, Any]]] = []
+        scopes: List[Dict[Union[str, CodeItem, object], Any]] = []
         next_scope = self._scopes
         for scope_part in scope.split('.'):
             if scope_part not in next_scope:
@@ -53,11 +66,14 @@ class NestedScope:
             next_scope = next_scope[scope_part]
             scopes.insert(0, next_scope)
 
-        # Search for definition with provided name in scopes
+        # Search for definition with provided name in scopes.
+        # CodeItem.__hash__/__eq__ accept plain strings, so a dict.get() with
+        # the string name directly finds the matching CodeItem key's value in
+        # O(1) average time.
         for current_scope in scopes:
-            if name in current_scope:
-                current_scope_keys = list(current_scope.keys())
-                return current_scope_keys[current_scope_keys.index(name)]
+            found_items: Optional[Dict[Union[str, CodeItem], CodeItem]] = current_scope.get(_ITEMS)
+            if found_items and (code_item := found_items.get(name)) is not None:
+                return code_item
 
         return None
 

{lapsed-2.7.2 → lapsed-2.9.0}/deadcode/visitor/code_item.py

@@ -92,7 +92,9 @@ class CodeItem:  # TODO: This should also be a dataclass, because hash and tuple
 
     @property
     def filename_with_position(self) -> str:
-        filename_with_position = str(self.filename)
+        # .as_posix() (not str()) so output is forward-slash on every OS,
+        # matching how the path was originally given on the command line.
+        filename_with_position = self.filename.as_posix()
         if self.name_line is not None:
             filename_with_position += f':{self.name_line}'
             if self.name_column is not None:

{lapsed-2.7.2 → lapsed-2.9.0}/deadcode/visitor/dead_code_visitor.py

@@ -87,6 +87,12 @@ class DeadCodeVisitor(ast.NodeVisitor):
         self.scopes = NestedScope()
         self.tach_index = load_tach_index(args.tach_config)
 
+        # Caches getattr(self, 'visit_' + node type name, None) per AST node
+        # type, since visit() below is called once per AST node (potentially
+        # millions of times) and both the string concatenation and the
+        # getattr MRO walk are otherwise repeated for every single node.
+        self._visitor_cache: Dict[type, Optional[Callable[[ast.AST], None]]] = {}
+
     @property
     def scope(self) -> str:
         return '.'.join(self.scope_parts)
@@ -510,8 +516,12 @@ class DeadCodeVisitor(ast.NodeVisitor):
                 self.should_ignore_new_definitions = True
                 should_turn_off_ignore_new_definitions = True
 
-        method_name = 'visit_' + node.__class__.__name__
-        visitor = getattr(self, method_name, None)
+        node_type = node.__class__
+        try:
+            visitor = self._visitor_cache[node_type]
+        except KeyError:
+            visitor = getattr(self, 'visit_' + node_type.__name__, None)
+            self._visitor_cache[node_type] = visitor
 
         if visitor:
             visitor(node)

{lapsed-2.7.2 → lapsed-2.9.0}/deadcode/visitor/ignore.py

@@ -1,5 +1,6 @@
 import ast
 from fnmatch import fnmatch, fnmatchcase
+from functools import lru_cache
 from pathlib import Path
 from typing import Iterable, Set, Union
 
@@ -63,14 +64,21 @@ def _is_special_name(name: str) -> bool:
 
 def _match(name: Union[str, Path], patterns: Iterable[str], case: bool = True) -> bool:
     func = fnmatchcase if case else fnmatch
-    return any(func(str(name), pattern) for pattern in patterns)
+    # .as_posix() (not str()) for Path names, so a pattern like '*/tests/*'
+    # matches consistently regardless of the OS's native path separator.
+    name_str = name.as_posix() if isinstance(name, Path) else name
+    return any(func(name_str, pattern) for pattern in patterns)
 
 
 def _match_many(names: Union[Iterable[str], Iterable[Path]], patterns: Iterable[str], case: bool = True) -> bool:
     return any(_match(name, patterns, case) for name in names)
 
 
+@lru_cache(maxsize=None)
 def _is_test_file(filename: Path) -> bool:
+    # Called once per definition (function/class/method) in a file, so cache
+    # per-filename: `filename.resolve()` is a filesystem syscall and the
+    # answer never changes for repeated calls with the same file.
     return _match(
         filename.resolve(),
         ['*/test/*', '*/tests/*', '*/test*.py', '*[-_]test.py'],

{lapsed-2.7.2 → lapsed-2.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lapsed"
-version = "2.7.2"
+version = "2.9.0"
 authors = [
     {name = "Albertas Gimbutas", email = "albertasgim@gmail.com"},
 ]