pyrefactor 1.0.7__tar.gz → 1.0.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrefactor
-Version: 1.0.7
+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
@@ -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.9}/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.9}/pyproject.toml

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

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.7 → 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,8 +138,11 @@ def _load_config(args: Args) -> Optional[Config]:
         config = Config.load(args.config)
         logger.info("Loaded configuration: %s", config)
         return config
-    except Exception as e:
-        logger.error("Error loading configuration: %s", e)
+    except (ValueError, OSError, tomllib.TOMLDecodeError) as 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 +158,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)
+    except (OSError, RuntimeError) as 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 +223,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.9}/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.9}/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.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.7 → pyrefactor-1.0.9}/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,47 +304,66 @@ 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,
                 )
             ),
             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."""
@@ -328,10 +385,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")),
@@ -367,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.7 → pyrefactor-1.0.9}/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]