pyrefactor 1.0.8__tar.gz → 1.0.9__tar.gz

{pyrefactor-1.0.8/src/pyrefactor.egg-info → pyrefactor-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrefactor
-Version: 1.0.8
+Version: 1.0.9
 Summary: A Python refactoring and optimization linter that analyzes code for performance issues, complexity problems, and opportunities for improvement
 Author: tboy1337
 Maintainer: tboy1337

{pyrefactor-1.0.8 → pyrefactor-1.0.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyrefactor"
-version = "1.0.8"
+version = "1.0.9"
 description = "A Python refactoring and optimization linter that analyzes code for performance issues, complexity problems, and opportunities for improvement"
 authors = [{name = "tboy1337"}]
 maintainers = [{name = "tboy1337"}]

pyrefactor-1.0.9/src/pyrefactor/__init__.py

@@ -0,0 +1,20 @@
+"""PyRefactor - A Python refactoring and optimization linter."""
+
+from pyrefactor._version import get_version
+from pyrefactor.analyzer import Analyzer
+from pyrefactor.config import Config
+from pyrefactor.models import AnalysisResult, FileAnalysis, Issue, Severity
+from pyrefactor.reporter import ConsoleReporter
+
+__version__ = get_version()
+
+__all__ = [
+    "Analyzer",
+    "AnalysisResult",
+    "Config",
+    "ConsoleReporter",
+    "FileAnalysis",
+    "Issue",
+    "Severity",
+    "__version__",
+]

{pyrefactor-1.0.8 → pyrefactor-1.0.9}/src/pyrefactor/__main__.py

@@ -3,6 +3,7 @@
 import argparse
 import logging
 import sys
+import tomllib
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
@@ -137,7 +138,7 @@ def _load_config(args: Args) -> Optional[Config]:
         config = Config.load(args.config)
         logger.info("Loaded configuration: %s", config)
         return config
-    except Exception as e:
+    except (ValueError, OSError, tomllib.TOMLDecodeError) as e:
         if args.verbose:
             logger.error("Error loading configuration: %s", e, exc_info=True)
         else:
@@ -163,7 +164,7 @@ def _analyze_files_safely(
     try:
         logger.info("Analyzing %d path(s)...", len(paths))
         return analyzer.analyze_files(paths, max_workers=max_workers)
-    except Exception as e:
+    except (OSError, RuntimeError) as e:
         if verbose:
             logger.error("Error during analysis: %s", e, exc_info=True)
         else:

{pyrefactor-1.0.8 → pyrefactor-1.0.9}/src/pyrefactor/ast_visitor.py

@@ -39,7 +39,6 @@ class BaseDetector(ast.NodeVisitor, ABC):
         self.source_lines = source_lines
         self.issues: list[Issue] = []
         self.current_function: Union[ast.FunctionDef, ast.AsyncFunctionDef, None] = None
-        self.nesting_level = 0
 
     @abstractmethod
     def get_detector_name(self) -> str:

{pyrefactor-1.0.8 → pyrefactor-1.0.9}/src/pyrefactor/config.py

@@ -355,6 +355,15 @@ class Config:
             exclude_patterns=exclude_patterns,
         )
 
+    @staticmethod
+    def _has_pyrefactor_config(data: dict[str, Any]) -> bool:
+        """Return True when parsed TOML contains a non-empty [tool.pyrefactor] table."""
+        tool_section = data.get("tool")
+        if not isinstance(tool_section, dict):
+            return False
+        pyrefactor = tool_section.get("pyrefactor")
+        return isinstance(pyrefactor, dict) and bool(pyrefactor)
+
     @classmethod
     def from_toml_file(cls, config_path: Path) -> "Config":
         """Load configuration from a TOML file."""
@@ -413,8 +422,11 @@ class Config:
             return cls.from_file(config_path)
 
         pyproject = Path("pyproject.toml")
-        if pyproject.exists():
-            return cls.from_toml_file(pyproject)
+        if pyproject.is_file():
+            with pyproject.open("rb") as config_file:
+                data = tomllib.load(config_file)
+            if cls._has_pyrefactor_config(data):
+                return cls.from_toml_data(data)
 
         ini_file = Path("pyrefactor.ini")
         if ini_file.exists():

{pyrefactor-1.0.8 → pyrefactor-1.0.9}/src/pyrefactor/detectors/comparisons.py

@@ -4,7 +4,7 @@ import ast
 from typing import Optional, Tuple, cast
 
 from ..ast_visitor import BaseDetector
-from ..models import Issue, Severity
+from ..models import Severity
 
 # Singleton values that should be compared with 'is' instead of '=='
 SINGLETON_VALUES = frozenset({True, False, None})
@@ -17,26 +17,6 @@ class ComparisonsDetector(BaseDetector):
         """Return the name of this detector."""
         return "comparisons"
 
-    def _create_issue(
-        self,
-        node: ast.AST,
-        *,
-        severity: Severity,
-        rule_id: str,
-        message: str,
-        suggestion: str,
-    ) -> Issue:
-        """Create an Issue object for comparison issues."""
-        return Issue(
-            file=self.file_path,
-            line=cast(int, getattr(node, "lineno", 0)),
-            column=cast(int, getattr(node, "col_offset", 0)),
-            severity=severity,
-            rule_id=rule_id,
-            message=message,
-            suggestion=suggestion,
-        )
-
     def visit_BoolOp(self, node: ast.BoolOp) -> None:
         """Check for patterns that could use 'in' operator or chained comparisons."""
         if self.is_suppressed(node):
@@ -75,30 +55,21 @@ class ComparisonsDetector(BaseDetector):
 
         # We have x == a or x == b pattern
         if len(comparisons) >= 2:
-            var_name = (
-                ast.unparse(comparisons[0].left) if hasattr(ast, "unparse") else "x"
-            )
+            var_name = ast.unparse(comparisons[0].left)
             values = []
             for comp in comparisons:
                 if comp.comparators:
-                    val = (
-                        ast.unparse(comp.comparators[0])
-                        if hasattr(ast, "unparse")
-                        else "value"
-                    )
-                    values.append(val)
+                    values.append(ast.unparse(comp.comparators[0]))
 
             values_str = ", ".join(values)
 
-            self.add_issue(
-                self._create_issue(
-                    node,
-                    severity=Severity.LOW,
-                    rule_id="R011",
-                    message="Multiple equality comparisons can be simplified using 'in' operator",
-                    suggestion=f"Use '{var_name} in ({values_str})' instead of multiple '==' comparisons. "
-                    f"Use a set if values are hashable for O(1) lookup.",
-                )
+            self.report_issue(
+                node,
+                severity=Severity.LOW,
+                rule_id="R011",
+                message="Multiple equality comparisons can be simplified using 'in' operator",
+                suggestion=f"Use '{var_name} in ({values_str})' instead of multiple '==' comparisons. "
+                f"Use a set if values are hashable for O(1) lookup.",
             )
 
     def _check_chained_comparison(self, node: ast.BoolOp) -> None:
@@ -152,13 +123,9 @@ class ComparisonsDetector(BaseDetector):
             return None
 
         # Extract string representations
-        left1_str = ast.unparse(comp1.left) if hasattr(ast, "unparse") else "a"
-        mid_str = ast.unparse(right1) if hasattr(ast, "unparse") else "b"
-        right2_str = (
-            ast.unparse(comp2.comparators[0])
-            if hasattr(ast, "unparse") and comp2.comparators
-            else "c"
-        )
+        left1_str = ast.unparse(comp1.left)
+        mid_str = ast.unparse(right1)
+        right2_str = ast.unparse(comp2.comparators[0]) if comp2.comparators else "c"
 
         return (left1_str, op1, mid_str, op2, right2_str)
 
@@ -167,15 +134,13 @@ class ComparisonsDetector(BaseDetector):
     ) -> None:
         """Report a chainable comparison issue."""
         left1_str, op1, mid_str, op2, right2_str = chain_info
-        self.add_issue(
-            self._create_issue(
-                node,
-                severity=Severity.LOW,
-                rule_id="R012",
-                message="Comparison can be chained for better readability",
-                suggestion=f"Use '{left1_str} {op1} {mid_str} {op2} {right2_str}' "
-                f"instead of separate comparisons",
-            )
+        self.report_issue(
+            node,
+            severity=Severity.LOW,
+            rule_id="R012",
+            message="Comparison can be chained for better readability",
+            suggestion=f"Use '{left1_str} {op1} {mid_str} {op2} {right2_str}' "
+            f"instead of separate comparisons",
         )
 
     def visit_Compare(self, node: ast.Compare) -> None:
@@ -206,33 +171,29 @@ class ComparisonsDetector(BaseDetector):
         """Report inappropriate None comparison."""
         correct_op = "is not" if checking_for_absence else "is"
         wrong_op = "!=" if checking_for_absence else "=="
-        self.add_issue(
-            self._create_issue(
-                node,
-                severity=Severity.MEDIUM,
-                rule_id="R014",
-                message="Comparison with None should use 'is' or 'is not'",
-                suggestion=f"Use '{correct_op}' instead of '{wrong_op}' when comparing with None",
-            )
+        self.report_issue(
+            node,
+            severity=Severity.MEDIUM,
+            rule_id="R014",
+            message="Comparison with None should use 'is' or 'is not'",
+            suggestion=f"Use '{correct_op}' instead of '{wrong_op}' when comparing with None",
         )
 
     def _report_bool_comparison(
         self, node: ast.Compare, op: ast.cmpop, singleton_val: bool, other: ast.AST
     ) -> None:
         """Report redundant True/False comparison."""
-        other_str = ast.unparse(other) if hasattr(ast, "unparse") else "expr"
+        other_str = ast.unparse(other)
 
         # Determine the suggested replacement
         suggestion = self._get_bool_comparison_suggestion(singleton_val, op, other_str)
 
-        self.add_issue(
-            self._create_issue(
-                node,
-                severity=Severity.INFO,
-                rule_id="R015",
-                message=f"Redundant comparison with {singleton_val}",
-                suggestion=suggestion,
-            )
+        self.report_issue(
+            node,
+            severity=Severity.INFO,
+            rule_id="R015",
+            message=f"Redundant comparison with {singleton_val}",
+            suggestion=suggestion,
         )
 
     def _get_bool_comparison_suggestion(
@@ -312,24 +273,18 @@ class ComparisonsDetector(BaseDetector):
             return
 
         # At this point, node.left is a Call with args
-        obj = ast.unparse(node.left.args[0]) if hasattr(ast, "unparse") else "obj"
-        type_name = (
-            ast.unparse(node.comparators[0])
-            if hasattr(ast, "unparse") and node.comparators
-            else "Type"
-        )
-
-        self.add_issue(
-            self._create_issue(
-                node,
-                severity=Severity.MEDIUM,
-                rule_id="R016",
-                message="Use isinstance() for type checking instead of type() comparison",
-                suggestion=(
-                    f"Use 'isinstance({obj}, {type_name})' instead of "
-                    f"'type({obj}) == {type_name}'"
-                ),
-            )
+        obj = ast.unparse(node.left.args[0])
+        type_name = ast.unparse(node.comparators[0]) if node.comparators else "Type"
+
+        self.report_issue(
+            node,
+            severity=Severity.MEDIUM,
+            rule_id="R016",
+            message="Use isinstance() for type checking instead of type() comparison",
+            suggestion=(
+                f"Use 'isinstance({obj}, {type_name})' instead of "
+                f"'type({obj}) == {type_name}'"
+            ),
         )
 
     def visit_Call(self, node: ast.Call) -> None:

{pyrefactor-1.0.8 → pyrefactor-1.0.9}/src/pyrefactor/detectors/complexity.py

@@ -91,11 +91,6 @@ class ComplexityDetector(BaseDetector):
         if self.is_suppressed(node):
             return
 
-        # Save current function context
-        old_function = self.current_function
-        self.current_function = node
-
-        # Group checks that don't require AST traversal
         self._check_function_length(node)
         self._check_arguments(node)
 
@@ -105,9 +100,6 @@ class ComplexityDetector(BaseDetector):
         self._check_nesting_depth(node)
         self._check_cyclomatic_complexity(node)
 
-        # Restore function context
-        self.current_function = old_function
-
     def _check_function_length(
         self, node: Union[ast.FunctionDef, ast.AsyncFunctionDef]
     ) -> None:

{pyrefactor-1.0.8 → pyrefactor-1.0.9}/src/pyrefactor/detectors/context_manager.py

@@ -3,7 +3,7 @@
 import ast
 from typing import Optional
 
-from ..ast_visitor import BaseDetector, node_col_offset, node_lineno
+from ..ast_visitor import BaseDetector, build_parent_map
 from ..config import Config
 from ..models import Issue, Severity
 
@@ -38,51 +38,19 @@ class ContextManagerDetector(BaseDetector):
 
     def analyze(self, tree: ast.AST) -> list[Issue]:
         """Run the detector on an AST and return issues found."""
-        # Build parent map once for the entire tree
-        self._build_parent_map(tree)
+        self.parent_map = build_parent_map(tree)
         self.visit(tree)
         return self.issues
 
-    def _build_parent_map(self, tree: ast.AST) -> None:
-        """Build a map of child -> parent for the entire tree."""
-        for parent in ast.walk(tree):
-            for child in ast.iter_child_nodes(parent):
-                self.parent_map[child] = parent
-
     def get_detector_name(self) -> str:
         """Return the name of this detector."""
         return "context_manager"
 
-    def _create_issue(
-        self,
-        node: ast.AST,
-        *,
-        severity: Severity,
-        rule_id: str,
-        message: str,
-        suggestion: str,
-    ) -> Issue | None:
-        """Create an Issue object for context manager issues."""
-        line = node_lineno(node)
-        if line is None:
-            return None
-        return Issue(
-            file=self.file_path,
-            line=line,
-            column=node_col_offset(node),
-            severity=severity,
-            rule_id=rule_id,
-            message=message,
-            suggestion=suggestion,
-        )
-
     def _is_context_manager_call(self, node: ast.Call) -> bool:
         """Check if a call returns a context manager."""
-        # Check for direct function calls (e.g., open(), file())
         if isinstance(node.func, ast.Name):
             return node.func.id in CONTEXT_MANAGER_FUNCS
 
-        # Check for method calls (e.g., lock.acquire(), Path.open())
         if isinstance(node.func, ast.Attribute):
             return node.func.attr in CONTEXT_MANAGER_METHODS
 
@@ -154,7 +122,7 @@ class ContextManagerDetector(BaseDetector):
         # Get the function name for a better error message
         func_name = self._get_func_name(cm_call)
 
-        issue = self._create_issue(
+        self.report_issue(
             node,
             severity=Severity.HIGH,
             rule_id="R001",
@@ -165,8 +133,6 @@ class ContextManagerDetector(BaseDetector):
                 f"Use 'with {func_name}(...) as resource:' to ensure proper resource cleanup"
             ),
         )
-        if issue is not None:
-            self.add_issue(issue)
 
     def _find_context_manager_call(self, node: ast.AST) -> Optional[ast.Call]:
         """Find a context manager call in an expression tree."""

{pyrefactor-1.0.8 → pyrefactor-1.0.9}/src/pyrefactor/detectors/control_flow.py

@@ -1,40 +1,14 @@
 """Control flow simplification detector for PyRefactor."""
 
 import ast
-from typing import cast
 
 from ..ast_visitor import BaseDetector
-from ..models import Issue, Severity
+from ..models import Severity
 
 
 class ControlFlowDetector(BaseDetector):
     """Detects unnecessary else/elif clauses after return/raise/break/continue."""
 
-    def get_detector_name(self) -> str:
-        """Return the name of this detector."""
-        return "control_flow"
-
-    def _create_issue(
-        self,
-        node: ast.AST,
-        *,
-        severity: Severity,
-        rule_id: str,
-        message: str,
-        suggestion: str,
-    ) -> Issue:
-        """Create an Issue object for control flow issues."""
-        return Issue(
-            file=self.file_path,
-            line=cast(int, getattr(node, "lineno", 0)),
-            column=cast(int, getattr(node, "col_offset", 0)),
-            severity=severity,
-            rule_id=rule_id,
-            message=message,
-            suggestion=suggestion,
-        )
-
-    # Map terminator types to rule IDs
     _TERMINATOR_RULES = {
         "return": "R002",
         "raise": "R003",
@@ -42,6 +16,10 @@ class ControlFlowDetector(BaseDetector):
         "continue": "R005",
     }
 
+    def get_detector_name(self) -> str:
+        """Return the name of this detector."""
+        return "control_flow"
+
     def visit_If(self, node: ast.If) -> None:
         """Check for unnecessary else clauses."""
         if self.is_suppressed(node):
@@ -144,13 +122,11 @@ class ControlFlowDetector(BaseDetector):
         else:
             clause_type = "else"
 
-        self.add_issue(
-            self._create_issue(
-                node,
-                severity=Severity.MEDIUM,
-                rule_id=rule_id,
-                message=f"Unnecessary '{clause_type}' after '{terminator}' statement",
-                suggestion=f"Remove '{clause_type}' and unindent its body since the "
-                f"preceding code always executes '{terminator}'",
-            )
+        self.report_issue(
+            node,
+            severity=Severity.MEDIUM,
+            rule_id=rule_id,
+            message=f"Unnecessary '{clause_type}' after '{terminator}' statement",
+            suggestion=f"Remove '{clause_type}' and unindent its body since the "
+            f"preceding code always executes '{terminator}'",
         )

{pyrefactor-1.0.8 → pyrefactor-1.0.9}/src/pyrefactor/detectors/dict_operations.py

@@ -4,7 +4,7 @@ import ast
 from typing import Optional, Tuple, cast
 
 from ..ast_visitor import BaseDetector
-from ..models import Issue, Severity
+from ..models import Severity
 
 
 class DictOperationsDetector(BaseDetector):
@@ -14,26 +14,6 @@ class DictOperationsDetector(BaseDetector):
         """Return the name of this detector."""
         return "dict_operations"
 
-    def _create_issue(
-        self,
-        node: ast.AST,
-        *,
-        severity: Severity,
-        rule_id: str,
-        message: str,
-        suggestion: str,
-    ) -> Issue:
-        """Create an Issue object for dictionary operation issues."""
-        return Issue(
-            file=self.file_path,
-            line=cast(int, getattr(node, "lineno", 0)),
-            column=cast(int, getattr(node, "col_offset", 0)),
-            severity=severity,
-            rule_id=rule_id,
-            message=message,
-            suggestion=suggestion,
-        )
-
     def visit_If(self, node: ast.If) -> None:
         """Check for dict.get() opportunities."""
         if self.is_suppressed(node):
@@ -58,15 +38,13 @@ class DictOperationsDetector(BaseDetector):
 
         var_name, key_name, dict_name, default_val = components
 
-        self.add_issue(
-            self._create_issue(
-                node,
-                severity=Severity.LOW,
-                rule_id="R006",
-                message="Consider using dict.get() instead of if/else for key lookup",
-                suggestion=f"Use '{var_name} = {dict_name}.get({key_name}, {default_val})' "
-                f"instead of if/else block",
-            )
+        self.report_issue(
+            node,
+            severity=Severity.LOW,
+            rule_id="R006",
+            message="Consider using dict.get() instead of if/else for key lookup",
+            suggestion=f"Use '{var_name} = {dict_name}.get({key_name}, {default_val})' "
+            f"instead of if/else block",
         )
 
     def _is_valid_dict_get_structure(self, node: ast.If) -> bool:
@@ -114,9 +92,7 @@ class DictOperationsDetector(BaseDetector):
             return None
 
         var_name = cast(ast.Name, if_assign.targets[0]).id
-        default_val = (
-            ast.unparse(else_assign.value) if hasattr(ast, "unparse") else "..."
-        )
+        default_val = ast.unparse(else_assign.value)
 
         return (var_name, key_name.id, dict_name.id, default_val)
 
@@ -185,6 +161,42 @@ class DictOperationsDetector(BaseDetector):
 
         return True
 
+    def visit_Compare(self, node: ast.Compare) -> None:
+        """Check for unnecessary .keys() in membership tests."""
+        if self.is_suppressed(node):
+            self.generic_visit(node)
+            return
+
+        self._check_unnecessary_keys_membership(node)
+        self.generic_visit(node)
+
+    def _check_unnecessary_keys_membership(self, node: ast.Compare) -> None:
+        """Check for pattern: key in dict.keys()."""
+        if len(node.ops) != 1 or not isinstance(node.ops[0], ast.In):
+            return
+        if not node.comparators:
+            return
+
+        comparator = node.comparators[0]
+        if not isinstance(comparator, ast.Call):
+            return
+        if not isinstance(comparator.func, ast.Attribute):
+            return
+        if comparator.func.attr != "keys":
+            return
+
+        dict_name = self._get_name(comparator.func.value)
+        if not dict_name:
+            return
+
+        self.report_issue(
+            node,
+            severity=Severity.INFO,
+            rule_id="R009",
+            message="Unnecessary .keys() call in membership test",
+            suggestion=f"Use 'key in {dict_name}' instead of 'key in {dict_name}.keys()'",
+        )
+
     def visit_For(self, node: ast.For) -> None:
         """Check for dictionary iteration improvements."""
         if self.is_suppressed(node):
@@ -216,15 +228,13 @@ class DictOperationsDetector(BaseDetector):
             return
 
         target_name = self._get_target_name(node.target)
-        self.add_issue(
-            self._create_issue(
-                node,
-                severity=Severity.INFO,
-                rule_id="R009",
-                message="Unnecessary .keys() call when iterating dictionary",
-                suggestion=f"Use 'for {target_name} in {dict_name}:' "
-                f"instead of 'for {target_name} in {dict_name}.keys():'",
-            )
+        self.report_issue(
+            node,
+            severity=Severity.INFO,
+            rule_id="R009",
+            message="Unnecessary .keys() call when iterating dictionary",
+            suggestion=f"Use 'for {target_name} in {dict_name}:' "
+            f"instead of 'for {target_name} in {dict_name}.keys():'",
         )
 
     def _check_dict_items_opportunity(self, node: ast.For) -> None:
@@ -242,15 +252,13 @@ class DictOperationsDetector(BaseDetector):
 
         # Check if body contains dict[key] accesses
         if self._has_dict_key_access(node.body, iter_name, key_name):
-            self.add_issue(
-                self._create_issue(
-                    node,
-                    severity=Severity.MEDIUM,
-                    rule_id="R007",
-                    message="Consider using .items() to access both keys and values",
-                    suggestion=f"Use 'for {key_name}, value in {iter_name}.items():' "
-                    f"to avoid repeated dict lookups",
-                )
+            self.report_issue(
+                node,
+                severity=Severity.MEDIUM,
+                rule_id="R007",
+                message="Consider using .items() to access both keys and values",
+                suggestion=f"Use 'for {key_name}, value in {iter_name}.items():' "
+                f"to avoid repeated dict lookups",
             )
 
     def _has_dict_key_access(
@@ -320,15 +328,13 @@ class DictOperationsDetector(BaseDetector):
         if len(arg.elt.elts) != 2:
             return
 
-        self.add_issue(
-            self._create_issue(
-                node,
-                severity=Severity.LOW,
-                rule_id="R010",
-                message="Consider using dictionary comprehension instead of dict()",
-                suggestion="Use '{k: v for ...}' instead of 'dict([(k, v) for ...])' "
-                "for better readability and performance",
-            )
+        self.report_issue(
+            node,
+            severity=Severity.LOW,
+            rule_id="R010",
+            message="Consider using dictionary comprehension instead of dict()",
+            suggestion="Use '{k: v for ...}' instead of 'dict([(k, v) for ...])' "
+            "for better readability and performance",
         )
 
     def _get_name(self, node: ast.AST) -> Optional[str]: