pyrefactor 1.0.6__tar.gz → 1.0.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrefactor
-Version: 1.0.6
+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
@@ -20,11 +20,9 @@ Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development
@@ -35,17 +33,31 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Classifier: Environment :: Console
 Classifier: Natural Language :: English
-Requires-Python: >=3.9
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: colorama
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: autopep8; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: types-colorama; extra == "dev"
+Requires-Dist: bandit; extra == "dev"
+Requires-Dist: safety; extra == "dev"
 Dynamic: license-file
 
 # PyRefactor
 
 A Python refactoring and optimization linter that uses AST analysis to identify performance issues, complexity problems, and code improvements.
 
-[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
 
 ## Features
 
@@ -58,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
@@ -87,7 +99,7 @@ cd PyRefactor
 pip install -e .
 ```
 
-**Requirements**: Python 3.9+
+**Requirements**: Python 3.12+
 
 ## Usage
 
@@ -133,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
@@ -142,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
@@ -168,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
@@ -197,7 +216,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v4
         with:
-          python-version: '3.9'
+          python-version: '3.12'
       - run: pip install pyrefactor
       - run: pyrefactor --min-severity medium src/
 ```
@@ -206,8 +225,35 @@ jobs:
 
 Contributions are welcome! This project is under a Commercial Restricted License (CRL). For commercial use, contact the copyright holder.
 
+### Development
+
+Install the package with development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+Alternatively:
+
+```bash
+pip install -e .
+pip install -r requirements-dev.txt
+```
+
+Run the local verification script (formatting, type checks, lint, security scan, tests):
+
+```bash
+py scripts/verify.py
+```
+
+Run tests directly:
+
+```bash
+pytest
+```
+
 1. Follow existing code style (Black, isort)
-2. Add tests for new features (>95% coverage)
+2. Add tests for new features (>90% coverage)
 3. Run type checking and linting
 
 ## License

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

@@ -2,7 +2,7 @@
 
 A Python refactoring and optimization linter that uses AST analysis to identify performance issues, complexity problems, and code improvements.
 
-[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
 
 ## Features
 
@@ -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
@@ -44,7 +44,7 @@ cd PyRefactor
 pip install -e .
 ```
 
-**Requirements**: Python 3.9+
+**Requirements**: Python 3.12+
 
 ## Usage
 
@@ -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
@@ -154,7 +161,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v4
         with:
-          python-version: '3.9'
+          python-version: '3.12'
       - run: pip install pyrefactor
       - run: pyrefactor --min-severity medium src/
 ```
@@ -163,8 +170,35 @@ jobs:
 
 Contributions are welcome! This project is under a Commercial Restricted License (CRL). For commercial use, contact the copyright holder.
 
+### Development
+
+Install the package with development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+Alternatively:
+
+```bash
+pip install -e .
+pip install -r requirements-dev.txt
+```
+
+Run the local verification script (formatting, type checks, lint, security scan, tests):
+
+```bash
+py scripts/verify.py
+```
+
+Run tests directly:
+
+```bash
+pytest
+```
+
 1. Follow existing code style (Black, isort)
-2. Add tests for new features (>95% coverage)
+2. Add tests for new features (>90% coverage)
 3. Run type checking and linting
 
 ## License

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

@@ -1,16 +1,16 @@
 [build-system]
-requires = ["setuptools>=61.0", "wheel"]
+requires = ["setuptools>=77.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyrefactor"
-dynamic = ["version"]
+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)"}
-requires-python = ">=3.9"
+license = { text = "Commercial Restricted License (CRL)" }
+requires-python = ">=3.12"
 keywords = [
     "refactoring",
     "linter",
@@ -38,11 +38,9 @@ classifiers = [
     "Operating System :: MacOS",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Programming Language :: Python :: 3 :: Only",
     "Programming Language :: Python :: Implementation :: CPython",
     "Topic :: Software Development",
@@ -58,6 +56,23 @@ dependencies = [
     "colorama",
 ]
 
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-timeout",
+    "pytest-xdist",
+    "pytest-mock",
+    "pytest-cov",
+    "pylint",
+    "mypy",
+    "autopep8",
+    "black",
+    "isort",
+    "types-colorama",
+    "bandit",
+    "safety",
+]
+
 [project.urls]
 Homepage = "https://github.com/tboy1337/PyRefactor"
 Repository = "https://github.com/tboy1337/PyRefactor"
@@ -68,15 +83,20 @@ Documentation = "https://github.com/tboy1337/PyRefactor#readme"
 [project.scripts]
 pyrefactor = "pyrefactor.__main__:main"
 
-[tool.setuptools.dynamic]
-version = {attr = "pyrefactor.__version__"}
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["pyrefactor*"]
+exclude = ["tests*"]
 
 [tool.setuptools.package-data]
 pyrefactor = ["py.typed"]
 
 [tool.black]
 line-length = 88
-target-version = ['py39', 'py310', 'py311', 'py312', 'py313', 'py314']
+target-version = ['py312']
 
 [tool.isort]
 profile = "black"
@@ -86,3 +106,4 @@ include_trailing_comma = true
 force_grid_wrap = 0
 use_parentheses = true
 ensure_newline_before_comments = true
+known_first_party = ["pyrefactor"]

pyrefactor-1.0.8/src/pyrefactor/__init__.py

@@ -0,0 +1,5 @@
+"""PyRefactor - A Python refactoring and optimization linter."""
+
+from pyrefactor._version import get_version
+
+__version__ = get_version()

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

@@ -65,7 +65,11 @@ def _add_parser_arguments(parser: argparse.ArgumentParser) -> None:
         help="Minimum severity level to report (default: info)",
     )
     parser.add_argument(
-        "-j", "--jobs", type=int, default=4, help="Number of parallel jobs (default: 4)"
+        "-j",
+        "--jobs",
+        type=int,
+        default=4,
+        help="Number of parallel jobs (default: 4, minimum 1)",
     )
     parser.add_argument(
         "-v", "--verbose", action="store_true", help="Enable verbose logging"
@@ -102,13 +106,13 @@ def parse_arguments() -> Args:
     # Convert to our typed class
     # Note: argparse returns Any type for namespace attributes
     return Args(
-        paths=namespace.paths,  # type: ignore[misc]
-        config=namespace.config,  # type: ignore[misc]
-        group_by=namespace.group_by,  # type: ignore[misc]
-        min_severity=namespace.min_severity,  # type: ignore[misc]
-        jobs=namespace.jobs,  # type: ignore[misc]
-        verbose=namespace.verbose,  # type: ignore[misc]
-        version=namespace.version,  # type: ignore[misc]
+        paths=namespace.paths,
+        config=namespace.config,
+        group_by=namespace.group_by,
+        min_severity=namespace.min_severity,
+        jobs=namespace.jobs,
+        verbose=namespace.verbose,
+        version=namespace.version,
     )
 
 
@@ -134,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
 
 
@@ -150,14 +157,17 @@ def _validate_paths(args: Args) -> Optional[list[Path]]:
 
 
 def _analyze_files_safely(
-    analyzer: Analyzer, paths: list[Path]
+    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)
+        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
 
 
@@ -210,8 +220,9 @@ def main() -> int:
         return 2
 
     # Create analyzer and analyze files
+    max_workers = max(1, args.jobs)
     analyzer = Analyzer(config)
-    result = _analyze_files_safely(analyzer, paths)
+    result = _analyze_files_safely(analyzer, paths, max_workers, verbose=args.verbose)
     if result is None:
         return 2
 

pyrefactor-1.0.8/src/pyrefactor/_version.py

@@ -0,0 +1,40 @@
+"""Package version resolution."""
+
+import sys
+from functools import lru_cache
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+_PACKAGE_NAME = "pyrefactor"
+
+
+def _pyproject_path() -> 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"
+
+
+@lru_cache(maxsize=1)
+def _fallback_version() -> str:
+    """Read version from pyproject.toml when the package is not installed."""
+    pyproject = _pyproject_path()
+    if not pyproject.is_file():
+        return "unknown"
+    for line in pyproject.read_text(encoding="utf-8").splitlines():
+        stripped = line.strip()
+        if stripped.startswith("version = "):
+            return stripped.split("=", 1)[1].strip().strip('"').strip("'")
+    return "unknown"
+
+
+def get_version() -> str:
+    """Return the installed package version, falling back to pyproject.toml."""
+    try:
+        return version(_PACKAGE_NAME)
+    except PackageNotFoundError:
+        return _fallback_version()

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

@@ -2,8 +2,9 @@
 
 import ast
 import concurrent.futures
+import fnmatch
 import logging
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 
 from .ast_visitor import BaseDetector
 from .config import Config
@@ -22,6 +23,9 @@ from .models import AnalysisResult, FileAnalysis
 
 logger = logging.getLogger(__name__)
 
+# Maximum file size to read for analysis (10 MB)
+MAX_FILE_BYTES = 10 * 1024 * 1024
+
 
 class Analyzer:
     """Main analyzer that orchestrates all detectors."""
@@ -33,16 +37,12 @@ class Analyzer:
     def _create_detectors(
         self, file_path: str, source_lines: list[str]
     ) -> list[BaseDetector]:
-        """Create all enabled detectors for a file.
-
-        Factory method to consolidate detector initialization and reduce duplication.
-        """
+        """Create all enabled detectors for a file."""
         detectors: list[BaseDetector] = []
 
-        # Complexity detector (always enabled)
-        detectors.append(ComplexityDetector(self.config, file_path, source_lines))
+        if self.config.complexity.enabled:
+            detectors.append(ComplexityDetector(self.config, file_path, source_lines))
 
-        # Conditionally enabled detectors
         detector_configs = [
             (self.config.performance.enabled, PerformanceDetector),
             (self.config.boolean_logic.enabled, BooleanLogicDetector),
@@ -60,24 +60,42 @@ class Analyzer:
 
         return detectors
 
+    def _read_source(self, file_path: Path) -> tuple[str, list[str]] | str:
+        """Read source from a file, returning an error message on failure."""
+        try:
+            file_size = file_path.stat().st_size
+            if file_size > MAX_FILE_BYTES:
+                return (
+                    f"File exceeds maximum size of {MAX_FILE_BYTES} bytes "
+                    f"({file_size} bytes)"
+                )
+
+            source_code = file_path.read_text(encoding="utf-8")
+            return source_code, source_code.splitlines()
+        except UnicodeDecodeError:
+            return "File is not valid UTF-8 text"
+        except OSError as e:
+            return f"Error reading file: {e}"
+
     def analyze_file(self, file_path: Path) -> FileAnalysis:
         """Analyze a single Python file."""
         analysis = FileAnalysis(file_path=str(file_path))
 
         try:
-            # Read the file
-            source_code = file_path.read_text(encoding="utf-8")
-            source_lines = source_code.splitlines()
+            read_result = self._read_source(file_path)
+            if isinstance(read_result, str):
+                analysis.parse_error = read_result
+                return analysis
+
+            source_code, source_lines = read_result
             analysis.lines_of_code = len(source_lines)
 
-            # Parse the AST
             try:
                 tree = ast.parse(source_code, filename=str(file_path))
             except SyntaxError as e:
                 analysis.parse_error = f"Syntax error: {e}"
                 return analysis
 
-            # Create and run all enabled detectors
             detectors = self._create_detectors(str(file_path), source_lines)
             self._run_detectors(detectors, tree, analysis, file_path)
 
@@ -114,18 +132,54 @@ class Analyzer:
         """Analyze all Python files in a directory."""
         result = AnalysisResult()
 
-        # Find all Python files
         python_files = list(directory.rglob("*.py"))
-
-        # Filter excluded patterns
         python_files = self._filter_excluded_files(python_files)
 
         if not python_files:
             logger.warning("No Python files found in %s", directory)
             return result
 
-        # Analyze files in parallel
-        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+        return self._analyze_paths_parallel(python_files, max_workers, result)
+
+    def analyze_files(
+        self, file_paths: list[Path], max_workers: int = 4
+    ) -> AnalysisResult:
+        """Analyze a list of Python files and directories."""
+        result = AnalysisResult()
+        paths_to_analyze: list[Path] = []
+
+        for file_path in file_paths:
+            if file_path.is_file():
+                if file_path.suffix == ".py" and not self._is_excluded(file_path):
+                    paths_to_analyze.append(file_path)
+            elif file_path.is_dir():
+                python_files = [
+                    path
+                    for path in file_path.rglob("*.py")
+                    if not self._is_excluded(path)
+                ]
+                paths_to_analyze.extend(python_files)
+
+        if not paths_to_analyze:
+            return result
+
+        return self._analyze_paths_parallel(paths_to_analyze, max_workers, result)
+
+    def _analyze_paths_parallel(
+        self,
+        python_files: list[Path],
+        max_workers: int,
+        result: AnalysisResult,
+    ) -> AnalysisResult:
+        """Analyze multiple Python files in parallel."""
+        workers = max(1, max_workers)
+
+        if workers == 1 or len(python_files) == 1:
+            for file_path in python_files:
+                result.add_file_analysis(self.analyze_file(file_path))
+            return result
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
             future_to_file = {
                 executor.submit(self.analyze_file, file_path): file_path
                 for file_path in python_files
@@ -147,39 +201,22 @@ class Analyzer:
 
         return result
 
-    def analyze_files(self, file_paths: list[Path]) -> AnalysisResult:
-        """Analyze a list of Python files."""
-        result = AnalysisResult()
-
-        for file_path in file_paths:
-            self._process_path(file_path, result)
-
-        return result
-
-    def _process_path(self, file_path: Path, result: AnalysisResult) -> None:
-        """Process a single file or directory path.
-
-        Args:
-            file_path: Path to file or directory
-            result: AnalysisResult to add analyses to
-        """
-        if file_path.is_file():
-            analysis = self.analyze_file(file_path)
-            result.add_file_analysis(analysis)
-        elif file_path.is_dir():
-            dir_result = self.analyze_directory(file_path)
-            for analysis in dir_result.file_analyses:
-                result.add_file_analysis(analysis)
+    def _is_excluded(self, file_path: Path) -> bool:
+        """Check if a file matches any exclusion pattern."""
+        if not self.config.exclude_patterns:
+            return False
+
+        posix_path = PurePosixPath(file_path.as_posix())
+        for pattern in self.config.exclude_patterns:
+            normalized = pattern.replace("\\", "/")
+            if posix_path.match(normalized):
+                return True
+            if fnmatch.fnmatch(posix_path.as_posix(), normalized):
+                return True
+            if fnmatch.fnmatch(file_path.name, normalized):
+                return True
+        return False
 
     def _filter_excluded_files(self, files: list[Path]) -> list[Path]:
         """Filter out files matching exclusion patterns."""
-        if not self.config.exclude_patterns:
-            return files
-
-        return [
-            file_path
-            for file_path in files
-            if not any(
-                pattern in str(file_path) for pattern in self.config.exclude_patterns
-            )
-        ]
+        return [file_path for file_path in files if not self._is_excluded(file_path)]