pyrefactor 1.0.7__tar.gz → 1.0.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrefactor
-Version: 1.0.7
+Version: 1.0.8
 Summary: A Python refactoring and optimization linter that analyzes code for performance issues, complexity problems, and opportunities for improvement
 Author: tboy1337
 Maintainer: tboy1337
@@ -70,7 +70,7 @@ A Python refactoring and optimization linter that uses AST analysis to identify
 ## Detectors
 
 - **Complexity**: High cyclomatic complexity functions
-- **Performance**: String concatenation in loops, uncached calls, inefficient operations
+- **Performance**: String concatenation in loops (thresholded), repeated uncached calls in loops, inefficient operations
 - **Boolean Logic**: Overcomplicated boolean expressions
 - **Loops**: Nested loops, invariant code, comprehension opportunities
 - **Duplication**: Duplicate code blocks
@@ -145,7 +145,13 @@ Configure via TOML file (e.g., `pyproject.toml`):
 exclude_patterns = ["__pycache__", ".venv", "build", "dist"]
 
 [tool.pyrefactor.complexity]
-max_complexity = 10
+enabled = true
+max_cyclomatic_complexity = 10
+max_branches = 10
+max_nesting_depth = 3
+max_function_lines = 50
+max_arguments = 5
+max_local_variables = 15
 
 [tool.pyrefactor.performance]
 enabled = true
@@ -154,16 +160,15 @@ min_duplicate_calls = 3
 
 [tool.pyrefactor.boolean_logic]
 enabled = true
-min_depth = 3
+max_boolean_operators = 3
 
 [tool.pyrefactor.loops]
 enabled = true
-max_nesting = 3
 
 [tool.pyrefactor.duplication]
 enabled = true
-min_lines = 5
-similarity_threshold = 0.8
+min_duplicate_lines = 5
+similarity_threshold = 0.85
 
 [tool.pyrefactor.context_manager]
 enabled = true
@@ -180,6 +185,8 @@ enabled = true
 
 Configuration is searched in: `--config` → `pyproject.toml` → `pyrefactor.ini` → defaults
 
+**Note:** The PyPI package version (`pyproject.toml`) may differ from GitHub release build numbers used for standalone executables.
+
 ## CI/CD Integration
 
 ### Pre-commit Hook

{pyrefactor-1.0.7 → pyrefactor-1.0.8}/README.md

@@ -15,7 +15,7 @@ A Python refactoring and optimization linter that uses AST analysis to identify
 ## Detectors
 
 - **Complexity**: High cyclomatic complexity functions
-- **Performance**: String concatenation in loops, uncached calls, inefficient operations
+- **Performance**: String concatenation in loops (thresholded), repeated uncached calls in loops, inefficient operations
 - **Boolean Logic**: Overcomplicated boolean expressions
 - **Loops**: Nested loops, invariant code, comprehension opportunities
 - **Duplication**: Duplicate code blocks
@@ -90,7 +90,13 @@ Configure via TOML file (e.g., `pyproject.toml`):
 exclude_patterns = ["__pycache__", ".venv", "build", "dist"]
 
 [tool.pyrefactor.complexity]
-max_complexity = 10
+enabled = true
+max_cyclomatic_complexity = 10
+max_branches = 10
+max_nesting_depth = 3
+max_function_lines = 50
+max_arguments = 5
+max_local_variables = 15
 
 [tool.pyrefactor.performance]
 enabled = true
@@ -99,16 +105,15 @@ min_duplicate_calls = 3
 
 [tool.pyrefactor.boolean_logic]
 enabled = true
-min_depth = 3
+max_boolean_operators = 3
 
 [tool.pyrefactor.loops]
 enabled = true
-max_nesting = 3
 
 [tool.pyrefactor.duplication]
 enabled = true
-min_lines = 5
-similarity_threshold = 0.8
+min_duplicate_lines = 5
+similarity_threshold = 0.85
 
 [tool.pyrefactor.context_manager]
 enabled = true
@@ -125,6 +130,8 @@ enabled = true
 
 Configuration is searched in: `--config` → `pyproject.toml` → `pyrefactor.ini` → defaults
 
+**Note:** The PyPI package version (`pyproject.toml`) may differ from GitHub release build numbers used for standalone executables.
+
 ## CI/CD Integration
 
 ### Pre-commit Hook

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

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyrefactor"
-version = "1.0.7"
+version = "1.0.8"
 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"}]
 readme = "README.md"
-license = {text = "Commercial Restricted License (CRL)"}
+license = { text = "Commercial Restricted License (CRL)" }
 requires-python = ">=3.12"
 keywords = [
     "refactoring",

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

@@ -138,7 +138,10 @@ def _load_config(args: Args) -> Optional[Config]:
         logger.info("Loaded configuration: %s", config)
         return config
     except Exception as e:
-        logger.error("Error loading configuration: %s", e)
+        if args.verbose:
+            logger.error("Error loading configuration: %s", e, exc_info=True)
+        else:
+            logger.error("Error loading configuration: %s", e)
         return None
 
 
@@ -154,14 +157,17 @@ def _validate_paths(args: Args) -> Optional[list[Path]]:
 
 
 def _analyze_files_safely(
-    analyzer: Analyzer, paths: list[Path], max_workers: int
+    analyzer: Analyzer, paths: list[Path], max_workers: int, *, verbose: bool = False
 ) -> Optional[AnalysisResult]:
     """Analyze files and handle errors. Returns result or None on error."""
     try:
         logger.info("Analyzing %d path(s)...", len(paths))
         return analyzer.analyze_files(paths, max_workers=max_workers)
     except Exception as e:
-        logger.error("Error during analysis: %s", e)
+        if verbose:
+            logger.error("Error during analysis: %s", e, exc_info=True)
+        else:
+            logger.error("Error during analysis: %s", e)
         return None
 
 
@@ -216,7 +222,7 @@ def main() -> int:
     # Create analyzer and analyze files
     max_workers = max(1, args.jobs)
     analyzer = Analyzer(config)
-    result = _analyze_files_safely(analyzer, paths, max_workers)
+    result = _analyze_files_safely(analyzer, paths, max_workers, verbose=args.verbose)
     if result is None:
         return 2
 

{pyrefactor-1.0.7 → pyrefactor-1.0.8}/src/pyrefactor/_version.py

@@ -1,5 +1,6 @@
 """Package version resolution."""
 
+import sys
 from functools import lru_cache
 from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
@@ -8,7 +9,13 @@ _PACKAGE_NAME = "pyrefactor"
 
 
 def _pyproject_path() -> Path:
-    """Return the repository pyproject.toml path."""
+    """Return the pyproject.toml path for version fallback."""
+    if getattr(sys, "frozen", False):
+        meipass = getattr(sys, "_MEIPASS", None)
+        if meipass:
+            bundled = Path(meipass) / "pyproject.toml"
+            if bundled.is_file():
+                return bundled
     return Path(__file__).resolve().parent.parent.parent / "pyproject.toml"
 
 

{pyrefactor-1.0.7 → pyrefactor-1.0.8}/src/pyrefactor/analyzer.py

@@ -40,7 +40,8 @@ class Analyzer:
         """Create all enabled detectors for a file."""
         detectors: list[BaseDetector] = []
 
-        detectors.append(ComplexityDetector(self.config, file_path, source_lines))
+        if self.config.complexity.enabled:
+            detectors.append(ComplexityDetector(self.config, file_path, source_lines))
 
         detector_configs = [
             (self.config.performance.enabled, PerformanceDetector),

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

@@ -11,6 +11,7 @@ from typing import Any, Mapping, Optional, Union
 class ComplexityConfig:
     """Configuration for complexity detector."""
 
+    enabled: bool = True
     max_branches: int = 10
     max_nesting_depth: int = 3
     max_function_lines: int = 50
@@ -24,6 +25,8 @@ class PerformanceConfig:
     """Configuration for performance detector."""
 
     enabled: bool = True
+    min_concatenations: int = 3
+    min_duplicate_calls: int = 3
 
 
 @dataclass
@@ -94,10 +97,14 @@ class Config:
     exclude_patterns: list[str] = field(default_factory=list)
 
     @staticmethod
-    def _parse_complexity_config(config: configparser.ConfigParser) -> dict[str, int]:
+    def _parse_complexity_config(
+        config: configparser.ConfigParser,
+    ) -> dict[str, Union[int, bool]]:
         """Extract complexity configuration from config parser."""
-        complexity_dict: dict[str, int] = {}
+        complexity_dict: dict[str, Union[int, bool]] = {}
         if config.has_section("complexity"):
+            if config.has_option("complexity", "enabled"):
+                complexity_dict["enabled"] = config.getboolean("complexity", "enabled")
             for key in [
                 "max_branches",
                 "max_nesting_depth",
@@ -110,6 +117,27 @@ class Config:
                     complexity_dict[key] = config.getint("complexity", key)
         return complexity_dict
 
+    @staticmethod
+    def _parse_performance_config(
+        config: configparser.ConfigParser,
+    ) -> dict[str, Union[int, bool]]:
+        """Extract performance configuration from config parser."""
+        performance_dict: dict[str, Union[int, bool]] = {}
+        if config.has_section("performance"):
+            if config.has_option("performance", "enabled"):
+                performance_dict["enabled"] = config.getboolean(
+                    "performance", "enabled"
+                )
+            if config.has_option("performance", "min_concatenations"):
+                performance_dict["min_concatenations"] = config.getint(
+                    "performance", "min_concatenations"
+                )
+            if config.has_option("performance", "min_duplicate_calls"):
+                performance_dict["min_duplicate_calls"] = config.getint(
+                    "performance", "min_duplicate_calls"
+                )
+        return performance_dict
+
     @staticmethod
     def _parse_duplication_config(
         config: configparser.ConfigParser,
@@ -207,6 +235,7 @@ class Config:
             raise ValueError("Invalid [tool.pyrefactor] section in configuration")
 
         complexity_fields = {
+            "enabled": bool,
             "max_branches": int,
             "max_nesting_depth": int,
             "max_function_lines": int,
@@ -214,6 +243,11 @@ class Config:
             "max_local_variables": int,
             "max_cyclomatic_complexity": int,
         }
+        performance_fields = {
+            "enabled": bool,
+            "min_concatenations": int,
+            "min_duplicate_calls": int,
+        }
         duplication_fields = {
             "enabled": bool,
             "min_duplicate_lines": int,
@@ -232,9 +266,7 @@ class Config:
             exclude_patterns = [str(pattern) for pattern in raw_exclude]
         elif isinstance(raw_exclude, str):
             exclude_patterns = [
-                pattern.strip()
-                for pattern in raw_exclude.split(",")
-                if pattern.strip()
+                pattern.strip() for pattern in raw_exclude.split(",") if pattern.strip()
             ]
 
         return cls(
@@ -246,15 +278,21 @@ class Config:
             ),
             performance=PerformanceConfig(
                 **cls._coerce_section(
-                    pyrefactor.get("performance", {})
-                    if isinstance(pyrefactor.get("performance"), dict)
-                    else {},
-                    enabled_only,
+                    (
+                        pyrefactor.get("performance", {})
+                        if isinstance(pyrefactor.get("performance"), dict)
+                        else {}
+                    ),
+                    performance_fields,
                 )
             ),
             duplication=DuplicationConfig(
                 **cls._coerce_section(
-                    duplication_section if isinstance(duplication_section, dict) else {},
+                    (
+                        duplication_section
+                        if isinstance(duplication_section, dict)
+                        else {}
+                    ),
                     duplication_fields,
                 )
             ),
@@ -266,41 +304,51 @@ class Config:
             ),
             loops=LoopsConfig(
                 **cls._coerce_section(
-                    pyrefactor.get("loops", {})
-                    if isinstance(pyrefactor.get("loops"), dict)
-                    else {},
+                    (
+                        pyrefactor.get("loops", {})
+                        if isinstance(pyrefactor.get("loops"), dict)
+                        else {}
+                    ),
                     enabled_only,
                 )
             ),
             context_manager=ContextManagerConfig(
                 **cls._coerce_section(
-                    pyrefactor.get("context_manager", {})
-                    if isinstance(pyrefactor.get("context_manager"), dict)
-                    else {},
+                    (
+                        pyrefactor.get("context_manager", {})
+                        if isinstance(pyrefactor.get("context_manager"), dict)
+                        else {}
+                    ),
                     enabled_only,
                 )
             ),
             control_flow=ControlFlowConfig(
                 **cls._coerce_section(
-                    pyrefactor.get("control_flow", {})
-                    if isinstance(pyrefactor.get("control_flow"), dict)
-                    else {},
+                    (
+                        pyrefactor.get("control_flow", {})
+                        if isinstance(pyrefactor.get("control_flow"), dict)
+                        else {}
+                    ),
                     enabled_only,
                 )
             ),
             dict_operations=DictOperationsConfig(
                 **cls._coerce_section(
-                    pyrefactor.get("dict_operations", {})
-                    if isinstance(pyrefactor.get("dict_operations"), dict)
-                    else {},
+                    (
+                        pyrefactor.get("dict_operations", {})
+                        if isinstance(pyrefactor.get("dict_operations"), dict)
+                        else {}
+                    ),
                     enabled_only,
                 )
             ),
             comparisons=ComparisonsConfig(
                 **cls._coerce_section(
-                    pyrefactor.get("comparisons", {})
-                    if isinstance(pyrefactor.get("comparisons"), dict)
-                    else {},
+                    (
+                        pyrefactor.get("comparisons", {})
+                        if isinstance(pyrefactor.get("comparisons"), dict)
+                        else {}
+                    ),
                     enabled_only,
                 )
             ),
@@ -328,10 +376,8 @@ class Config:
             parser.read(config_path, encoding="utf-8")
 
             return cls(
-                complexity=ComplexityConfig(**cls._parse_complexity_config(parser)),
-                performance=PerformanceConfig(
-                    **cls._parse_enabled_flag(parser, "performance")
-                ),
+                complexity=ComplexityConfig(**cls._parse_complexity_config(parser)),  # type: ignore[arg-type]
+                performance=PerformanceConfig(**cls._parse_performance_config(parser)),  # type: ignore[arg-type]
                 duplication=DuplicationConfig(**cls._parse_duplication_config(parser)),  # type: ignore[arg-type]
                 boolean_logic=BooleanLogicConfig(**cls._parse_boolean_logic_config(parser)),  # type: ignore[arg-type]
                 loops=LoopsConfig(**cls._parse_enabled_flag(parser, "loops")),

{pyrefactor-1.0.7 → pyrefactor-1.0.8}/src/pyrefactor/detectors/boolean_logic.py

@@ -45,24 +45,29 @@ class BooleanLogicDetector(BaseDetector):
             self.generic_visit(node)
             return
 
+        self._check_boolean_singleton_comparison(node)
+        self.generic_visit(node)
+
+    def _check_boolean_singleton_comparison(self, node: ast.Compare) -> None:
+        """Report use of ``is`` when comparing to boolean constants."""
         for comparator in node.comparators:
-            if isinstance(comparator, ast.Constant) and isinstance(
-                comparator.value, bool
+            if not (
+                isinstance(comparator, ast.Constant)
+                and isinstance(comparator.value, bool)
             ):
-                for op in node.ops:
-                    if isinstance(op, ast.Is):
-                        self.report_issue(
-                            node,
-                            severity=Severity.MEDIUM,
-                            rule_id="B004",
-                            message="Using 'is' for boolean comparison",
-                            suggestion=(
-                                "Use '==' for value comparison or use the boolean directly"
-                            ),
-                        )
-                        break
-
-        self.generic_visit(node)
+                continue
+            if not any(isinstance(op, ast.Is) for op in node.ops):
+                continue
+            self.report_issue(
+                node,
+                severity=Severity.MEDIUM,
+                rule_id="B004",
+                message="Using 'is' for boolean comparison",
+                suggestion=(
+                    "Use '==' for value comparison or use the boolean directly"
+                ),
+            )
+            return
 
     def visit_FunctionDef(
         self, node: Union[ast.FunctionDef, ast.AsyncFunctionDef]

{pyrefactor-1.0.7 → pyrefactor-1.0.8}/src/pyrefactor/detectors/duplication.py

@@ -185,7 +185,9 @@ class DuplicationDetector(BaseDetector):
                     continue
 
                 # Hash the normalized code
-                code_hash = hashlib.md5(normalized.encode()).hexdigest()
+                code_hash = hashlib.md5(
+                    normalized.encode(), usedforsecurity=False
+                ).hexdigest()
 
                 if code_hash not in self.code_blocks:
                     self.code_blocks[code_hash] = []

{pyrefactor-1.0.7 → pyrefactor-1.0.8}/src/pyrefactor/detectors/performance.py

@@ -1,6 +1,8 @@
 """Performance anti-pattern detector for PyRefactor."""
 
 import ast
+from collections import Counter
+from collections.abc import Callable
 from typing import Optional
 
 from ..ast_visitor import BaseDetector, build_parent_map
@@ -8,6 +10,87 @@ from ..config import Config
 from ..models import Issue, Severity
 
 
+class _LoopBodyCallCounter(ast.NodeVisitor):
+    """Count identical call expressions in a loop body."""
+
+    def __init__(self, suppressed: set[ast.AST]) -> None:
+        self.suppressed = suppressed
+        self.call_counts: Counter[str] = Counter()
+        self.call_nodes: dict[str, ast.Call] = {}
+        self._nested_function_depth = 0
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        """Skip counting calls inside nested function definitions."""
+        self._nested_function_depth += 1
+        self.generic_visit(node)
+        self._nested_function_depth -= 1
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        """Skip counting calls inside nested async function definitions."""
+        self._nested_function_depth += 1
+        self.generic_visit(node)
+        self._nested_function_depth -= 1
+
+    def visit_Lambda(self, node: ast.Lambda) -> None:
+        """Skip counting calls inside lambda expressions."""
+        self._nested_function_depth += 1
+        self.generic_visit(node)
+        self._nested_function_depth -= 1
+
+    def visit_Call(self, node: ast.Call) -> None:
+        """Record call expressions at the loop body scope."""
+        if self._nested_function_depth == 0 and node not in self.suppressed:
+            signature = ast.dump(node, annotate_fields=False)
+            self.call_counts[signature] += 1
+            self.call_nodes.setdefault(signature, node)
+        self.generic_visit(node)
+
+
+class _LoopBodyConcatCounter(ast.NodeVisitor):
+    """Count string += operations in a loop body."""
+
+    def __init__(
+        self,
+        suppressed: set[ast.AST],
+        matches_string: Callable[[ast.AST, str], bool],
+    ) -> None:
+        self.suppressed = suppressed
+        self.matches_string = matches_string
+        self.count = 0
+        self.last_node: Optional[ast.AugAssign] = None
+        self._nested_function_depth = 0
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        """Skip counting concatenations inside nested function definitions."""
+        self._nested_function_depth += 1
+        self.generic_visit(node)
+        self._nested_function_depth -= 1
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        """Skip counting concatenations inside nested async functions."""
+        self._nested_function_depth += 1
+        self.generic_visit(node)
+        self._nested_function_depth -= 1
+
+    def visit_Lambda(self, node: ast.Lambda) -> None:
+        """Skip counting concatenations inside lambda expressions."""
+        self._nested_function_depth += 1
+        self.generic_visit(node)
+        self._nested_function_depth -= 1
+
+    def visit_AugAssign(self, node: ast.AugAssign) -> None:
+        """Count string += operations at the loop body scope."""
+        if (
+            self._nested_function_depth == 0
+            and node not in self.suppressed
+            and isinstance(node.op, ast.Add)
+            and self.matches_string(node.target, "string")
+        ):
+            self.count += 1
+            self.last_node = node
+        self.generic_visit(node)
+
+
 class PerformanceDetector(BaseDetector):
     """Detects performance anti-patterns in code."""
 
@@ -23,6 +106,7 @@ class PerformanceDetector(BaseDetector):
         self.in_loop = False
         self.loop_stack: list[ast.AST] = []
         self.parent_map: dict[ast.AST, ast.AST] = {}
+        self.suppressed_nodes: set[ast.AST] = set()
 
     def get_detector_name(self) -> str:
         """Return the name of this detector."""
@@ -31,14 +115,24 @@ class PerformanceDetector(BaseDetector):
     def analyze(self, tree: ast.AST) -> list[Issue]:
         """Run the detector on an AST and return issues found."""
         self.parent_map = build_parent_map(tree)
+        self.suppressed_nodes = self._collect_suppressed_nodes(tree)
         self.visit(tree)
         return self.issues
 
+    def _collect_suppressed_nodes(self, tree: ast.AST) -> set[ast.AST]:
+        """Collect AST nodes that have suppression comments."""
+        suppressed: set[ast.AST] = set()
+        for node in ast.walk(tree):
+            if self.is_suppressed(node):
+                suppressed.add(node)
+        return suppressed
+
     def _visit_loop(self, node: ast.For | ast.While) -> None:
-        """Consolidated method to track loop entry and exit."""
+        """Track loop entry, analyze body, then exit."""
         self.loop_stack.append(node)
         self.in_loop = True
         self.generic_visit(node)
+        self._check_loop_performance(node)
         self.loop_stack.pop()
         self.in_loop = bool(self.loop_stack)
 
@@ -50,6 +144,55 @@ class PerformanceDetector(BaseDetector):
         """Track when we're inside a while loop."""
         self._visit_loop(node)
 
+    def _check_loop_performance(self, loop_node: ast.For | ast.While) -> None:
+        """Check loop body for concatenation and duplicate call patterns."""
+        self._check_string_concatenations(loop_node)
+        self._check_duplicate_calls(loop_node)
+
+    def _check_string_concatenations(self, loop_node: ast.For | ast.While) -> None:
+        """Report P001 when string += count meets threshold."""
+        counter = _LoopBodyConcatCounter(
+            self.suppressed_nodes,
+            self._matches_type_hint,
+        )
+        counter.visit(loop_node)
+        min_concat = self.config.performance.min_concatenations
+        if counter.count >= min_concat and counter.last_node is not None:
+            self.report_issue(
+                counter.last_node,
+                severity=Severity.MEDIUM,
+                rule_id="P001",
+                message=(
+                    f"String concatenation in loop using += "
+                    f"({counter.count} times) is inefficient"
+                ),
+                suggestion=(
+                    "Use str.join() with a list or io.StringIO for better performance"
+                ),
+            )
+
+    def _check_duplicate_calls(self, loop_node: ast.For | ast.While) -> None:
+        """Report P007 when identical calls repeat within a loop body."""
+        counter = _LoopBodyCallCounter(self.suppressed_nodes)
+        counter.visit(loop_node)
+        min_calls = self.config.performance.min_duplicate_calls
+        for signature, count in counter.call_counts.items():
+            if count >= min_calls:
+                call_node = counter.call_nodes[signature]
+                self.report_issue(
+                    call_node,
+                    severity=Severity.MEDIUM,
+                    rule_id="P007",
+                    message=(
+                        f"Repeated identical call in loop ({count} times); "
+                        "consider caching the result"
+                    ),
+                    suggestion=(
+                        "Assign the call result to a variable before the loop "
+                        "or cache it on first use inside the loop"
+                    ),
+                )
+
     def visit_AugAssign(self, node: ast.AugAssign) -> None:
         """Check for inefficient augmented assignments in loops."""
         if not self.in_loop or self.is_suppressed(node):
@@ -60,15 +203,7 @@ class PerformanceDetector(BaseDetector):
             self.generic_visit(node)
             return
 
-        if self._matches_type_hint(node.target, "string"):
-            self.report_issue(
-                node,
-                severity=Severity.MEDIUM,
-                rule_id="P001",
-                message="String concatenation in loop using += is inefficient",
-                suggestion="Use str.join() with a list or io.StringIO for better performance",
-            )
-        elif self._matches_type_hint(node.target, "list"):
+        if self._matches_type_hint(node.target, "list"):
             self.report_issue(
                 node,
                 severity=Severity.LOW,

{pyrefactor-1.0.7 → pyrefactor-1.0.8}/src/pyrefactor/reporter.py

@@ -46,7 +46,7 @@ class ConsoleReporter:
             try:
                 # Reconfigure stdout to use UTF-8 encoding
                 if hasattr(sys.stdout, "reconfigure"):
-                    # Python 3.7+ TextIOWrapper.reconfigure method
+                    # TextIOWrapper.reconfigure (Python 3.7+; PyRefactor requires 3.12+)
                     sys.stdout.reconfigure(encoding="utf-8")
                     self.output = sys.stdout
                     self.use_unicode = True