runtime-deps 0.1.0__py3-none-any.whl

auto_req/analyzer.py

@@ -0,0 +1,47 @@
+import ast
+import sys
+from pathlib import Path
+from typing import Set
+
+
+class CodeAnalyzer:
+    """Analyzes Python code to extract top-level third-party imported modules."""
+
+    def __init__(self):
+        # Retrieve all standard library modules for the current Python runtime
+        self.stdlib_modules: Set[str] = set(sys.stdlib_module_names)
+
+    def extract_imports_from_file(self, file_path: Path) -> Set[str]:
+        """Parses a single .py file and returns non-stdlib top-level import names."""
+        if not file_path.is_file() or file_path.suffix != ".py":
+            return set()
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                tree = ast.parse(f.read(), filename=str(file_path))
+        except (SyntaxError, UnicodeDecodeError):
+            return set()
+
+        modules = set()
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    # Capture top-level package (e.g., 'os.path' -> 'os')
+                    modules.add(alias.name.split(".")[0])
+            elif isinstance(node, ast.ImportFrom):
+                # Ensure it's an absolute import (level == 0)
+                if node.module and node.level == 0:
+                    modules.add(node.module.split(".")[0])
+
+        # Exclude standard library modules
+        return modules - self.stdlib_modules
+
+    def scan_directory(self, target_dir: Path) -> Set[str]:
+        """Recursively scans a directory for Python files and aggregates imports."""
+        all_imports = set()
+        for py_file in target_dir.rglob("*.py"):
+            # Ignore virtual environment directories
+            if any(part.startswith((".", "venv", "env")) for part in py_file.parts):
+                continue
+            all_imports.update(self.extract_imports_from_file(py_file))
+        return all_imports

auto_req/cli.py

@@ -0,0 +1,134 @@
+# import argparse
+# import subprocess
+# import sys
+# from pathlib import Path
+# from auto_req.analyzer import CodeAnalyzer
+# from auto_req.installer import PackageInstaller
+
+
+# def main():
+#     parser = argparse.ArgumentParser(
+#         description="TraceReq: Auto-detect and install missing Python requirements by analyzing code."
+#     )
+#     parser.add_argument(
+#         "target",
+#         nargs="?",
+#         default=".",
+#         help="Target directory or Python file to analyze (default: current directory)",
+#     )
+#     args = parser.parse_args()
+
+#     target_path = Path(args.target).resolve()
+#     analyzer = CodeAnalyzer()
+
+#     if target_path.is_file():
+#         required_imports = analyzer.extract_imports_from_file(target_path)
+#     elif target_path.is_dir():
+#         required_imports = analyzer.scan_directory(target_path)
+#     else:
+#         print(f"Error: Target path '{target_path}' does not exist.")
+#         sys.exit(1)
+
+#     installer = PackageInstaller(project_root=target_path.parent if target_path.is_file() else target_path)
+#     missing = installer.resolve_missing(required_imports)
+
+#     if not missing:
+#         print("[TraceReq] All required dependencies are already installed.")
+#     else:
+#         success = installer.install_packages(missing)
+#         if not success:
+#             sys.exit(1)
+
+#     # Automatically execute the file if target is a single Python script
+#     if target_path.is_file():
+#         python_exec = installer.get_target_python()
+#         print(f"[TraceReq] Running {target_path.name} using {python_exec.name}...\n")
+        
+#         try:
+#             subprocess.run([str(python_exec), str(target_path)], check=True)
+#         except subprocess.CalledProcessError as e:
+#             print(f"\n[TraceReq] Execution failed with exit code {e.returncode}")
+#             sys.exit(e.returncode)
+
+
+# if __name__ == "__main__":
+#     main()
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+from auto_req.analyzer import CodeAnalyzer
+from auto_req.installer import PackageInstaller
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="TraceReq: Auto-detect and install missing Python requirements by analyzing code."
+    )
+    parser.add_argument(
+        "target",
+        nargs="?",
+        default=".",
+        help="Target directory or Python file to analyze (default: current directory)",
+    )
+    args = parser.parse_args()
+
+    target_path = Path(args.target).resolve()
+    analyzer = CodeAnalyzer()
+
+    if target_path.is_file():
+        required_imports = analyzer.extract_imports_from_file(target_path)
+    elif target_path.is_dir():
+        required_imports = analyzer.scan_directory(target_path)
+    else:
+        print(f"Error: Target path '{target_path}' does not exist.")
+        sys.exit(1)
+
+    installer = PackageInstaller(
+        project_root=target_path.parent if target_path.is_file() else target_path
+    )
+    missing = installer.resolve_missing(required_imports)
+
+    if not missing:
+        print("[TraceReq] All required dependencies are already installed.")
+    else:
+        success = installer.install_packages(missing)
+        if not success:
+            sys.exit(1)
+
+    # Automatically execute the file if target is a single Python script
+    if target_path.is_file():
+        python_exec = installer.get_target_python()
+        print(f"[TraceReq] Running {target_path.name} using {python_exec.name}...\n")
+
+        # Step 1: Run execution and capture output to intercept runtime errors
+        process = subprocess.run(
+            [str(python_exec), str(target_path)],
+            capture_output=True,
+            text=True,
+        )
+
+        # Print standard output cleanly
+        if process.stdout:
+            print(process.stdout, end="")
+
+        # Step 2: Intercept execution failures & trigger auto-remediation
+        if process.returncode != 0:
+            error_output = (process.stderr or "") + (process.stdout or "")
+            if process.stderr:
+                print(process.stderr, file=sys.stderr, end="")
+
+            # Attempt self-healing repair via post-execution error rules
+            remediated = installer.attempt_error_remediation(error_output)
+
+            if remediated:
+                print(f"[TraceReq] Retrying execution for {target_path.name}...\n")
+                retry_process = subprocess.run([str(python_exec), str(target_path)])
+                sys.exit(retry_process.returncode)
+            else:
+                print(f"\n[TraceReq] Execution failed with exit code {process.returncode}")
+                sys.exit(process.returncode)
+
+
+if __name__ == "__main__":
+    main()

auto_req/installer.py

@@ -0,0 +1,548 @@
+# import importlib.metadata
+# import os
+# import subprocess
+# import sys
+# from pathlib import Path
+# from typing import List, Optional, Set
+# from auto_req.mapper import PyPIMapper
+
+
+# class PackageInstaller:
+#     """Detects missing dependencies and installs them into a project's local virtual environment."""
+
+#     COMMON_VENV_NAMES = [".venv", "venv", "env", ".env", "virtualenv"]
+
+#     def __init__(self, project_root: Optional[Path] = None):
+#         self.mapper = PyPIMapper()
+#         self.stdlib_modules = set(sys.stdlib_module_names)
+#         self.project_root = Path(project_root or Path.cwd()).resolve()
+#         self.venv_path = self._detect_virtual_env()
+
+#     def _detect_virtual_env(self) -> Optional[Path]:
+#         """Dynamically locates any virtual environment directory inside or around the project root."""
+#         # 1. Check if VIRTUAL_ENV variable is set in the environment
+#         if "VIRTUAL_ENV" in os.environ:
+#             active_env = Path(os.environ["VIRTUAL_ENV"])
+#             if self._is_valid_venv(active_env):
+#                 return active_env
+
+#         # 2. Check if the currently running Python runtime itself is a venv
+#         if sys.prefix != sys.base_prefix:
+#             active_sys_venv = Path(sys.prefix)
+#             if self._is_valid_venv(active_sys_venv):
+#                 return active_sys_venv
+
+#         # 3. Check common venv folder names inside project_root
+#         for name in self.COMMON_VENV_NAMES:
+#             candidate = self.project_root / name
+#             if self._is_valid_venv(candidate):
+#                 return candidate
+
+#         # 4. Check parent directory if project_root is inside a nested package
+#         for name in self.COMMON_VENV_NAMES:
+#             candidate = self.project_root.parent / name
+#             if self._is_valid_venv(candidate):
+#                 return candidate
+
+#         # 5. Fallback: Scan root directory for any subfolder containing a valid python executable
+#         try:
+#             for item in self.project_root.iterdir():
+#                 if item.is_dir() and item.name not in self.COMMON_VENV_NAMES:
+#                     if self._is_valid_venv(item):
+#                         return item
+#         except PermissionError:
+#             pass
+
+#         return None
+
+#     def _is_valid_venv(self, path: Path) -> bool:
+#         """Checks if a directory contains a valid virtual environment Python binary."""
+#         if os.name == "nt":  # Windows
+#             py_exec = path / "Scripts" / "python.exe"
+#         else:  # macOS / Linux
+#             py_exec = path / "bin" / "python"
+#         return py_exec.exists()
+
+#     def get_target_python(self) -> Path:
+#         """Returns the Python binary path of the detected venv, or system Python fallback."""
+#         if self.venv_path:
+#             if os.name == "nt":
+#                 py_exec = self.venv_path / "Scripts" / "python.exe"
+#             else:
+#                 py_exec = self.venv_path / "bin" / "python"
+
+#             if py_exec.exists():
+#                 return py_exec
+
+#         return Path(sys.executable)
+
+#     def get_installed_packages(self) -> Set[str]:
+#         """Returns normalized names of installed packages in the target venv/environment."""
+#         search_paths = []
+
+#         if self.venv_path:
+#             if os.name == "nt":
+#                 venv_site = self.venv_path / "Lib" / "site-packages"
+#             else:
+#                 venv_site = (
+#                     self.venv_path
+#                     / "lib"
+#                     / f"python{sys.version_info.major}.{sys.version_info.minor}"
+#                     / "site-packages"
+#                 )
+#             if venv_site.exists():
+#                 search_paths = [str(venv_site)]
+
+#         installed = set()
+
+#         # Query site-packages of the target venv directly if present
+#         dists = (
+#             importlib.metadata.distributions(path=search_paths)
+#             if search_paths
+#             else importlib.metadata.distributions()
+#         )
+
+#         for dist in dists:
+#             name = dist.metadata.get("Name")
+#             if name:
+#                 installed.add(name.lower().replace("_", "-"))
+#         return installed
+
+#     def resolve_missing(self, required_imports: Set[str]) -> List[str]:
+#         """Identifies imports that are not installed in the target environment."""
+#         installed = self.get_installed_packages()
+#         missing_pypi_packages = []
+
+#         # Strip standard library imports first
+#         third_party_imports = required_imports - self.stdlib_modules
+
+#         for imp in third_party_imports:
+#             pypi_name = self.mapper.map_import_to_pypi(imp)
+#             normalized_pypi = pypi_name.lower().replace("_", "-")
+
+#             if normalized_pypi not in installed:
+#                 missing_pypi_packages.append(pypi_name)
+
+#         return missing_pypi_packages
+
+#     def install_packages(self, packages: List[str]) -> bool:
+#         """Executes pip install targeting the detected virtual environment."""
+#         if not packages:
+#             return True
+
+#         python_exec = self.get_target_python()
+
+#         if self.venv_path:
+#             print(f"\n[TraceReq] Target Virtual Environment Found: {self.venv_path.name}")
+#         else:
+#             print("\n[TraceReq] No local venv found. Target: Global Environment")
+
+#         print(f"[TraceReq] Target Python: {python_exec}")
+#         print(f"[TraceReq] Installing dependencies: {', '.join(packages)}...")
+
+#         cmd = [str(python_exec), "-m", "pip", "install", *packages]
+#         result = subprocess.run(cmd)
+
+#         if result.returncode == 0:
+#             print("[TraceReq] Installation completed successfully!\n")
+#             return True
+
+#         print("[TraceReq] Error occurred during pip installation.\n")
+#         return False
+
+# import importlib.metadata
+# import os
+# import subprocess
+# import sys
+# from pathlib import Path
+# from typing import List, Optional, Set
+# from auto_req.mapper import PyPIMapper
+
+
+# class PackageInstaller:
+#     """Detects missing dependencies and installs them into a project's local virtual environment."""
+
+#     COMMON_VENV_NAMES = [".venv", "venv", "env", ".env", "virtualenv"]
+
+#     # Special packages that require additional setup commands after pip install
+#     POST_INSTALL_HOOKS = {
+#         "playwright": ["-m", "playwright", "install"]
+#     }
+
+#     def __init__(self, project_root: Optional[Path] = None):
+#         self.mapper = PyPIMapper()
+#         self.stdlib_modules = set(sys.stdlib_module_names)
+#         self.project_root = Path(project_root or Path.cwd()).resolve()
+#         self.venv_path = self._detect_virtual_env()
+
+#     def _detect_virtual_env(self) -> Optional[Path]:
+#         """Dynamically locates any virtual environment directory inside or around the project root."""
+#         if "VIRTUAL_ENV" in os.environ:
+#             active_env = Path(os.environ["VIRTUAL_ENV"])
+#             if self._is_valid_venv(active_env):
+#                 return active_env
+
+#         if sys.prefix != sys.base_prefix:
+#             active_sys_venv = Path(sys.prefix)
+#             if self._is_valid_venv(active_sys_venv):
+#                 return active_sys_venv
+
+#         for name in self.COMMON_VENV_NAMES:
+#             candidate = self.project_root / name
+#             if self._is_valid_venv(candidate):
+#                 return candidate
+
+#         for name in self.COMMON_VENV_NAMES:
+#             candidate = self.project_root.parent / name
+#             if self._is_valid_venv(candidate):
+#                 return candidate
+
+#         try:
+#             for item in self.project_root.iterdir():
+#                 if item.is_dir() and item.name not in self.COMMON_VENV_NAMES:
+#                     if self._is_valid_venv(item):
+#                         return item
+#         except PermissionError:
+#             pass
+
+#         return None
+
+#     def _is_valid_venv(self, path: Path) -> bool:
+#         """Checks if a directory contains a valid virtual environment Python binary."""
+#         if os.name == "nt":
+#             py_exec = path / "Scripts" / "python.exe"
+#         else:
+#             py_exec = path / "bin" / "python"
+#         return py_exec.exists()
+
+#     def get_target_python(self) -> Path:
+#         """Returns the Python binary path of the detected venv, or system Python fallback."""
+#         if self.venv_path:
+#             if os.name == "nt":
+#                 py_exec = self.venv_path / "Scripts" / "python.exe"
+#             else:
+#                 py_exec = self.venv_path / "bin" / "python"
+
+#             if py_exec.exists():
+#                 return py_exec
+
+#         return Path(sys.executable)
+
+#     def get_installed_packages(self) -> Set[str]:
+#         """Returns normalized names of installed packages in the target venv/environment."""
+#         search_paths = []
+
+#         if self.venv_path:
+#             if os.name == "nt":
+#                 venv_site = self.venv_path / "Lib" / "site-packages"
+#             else:
+#                 venv_site = (
+#                     self.venv_path
+#                     / "lib"
+#                     / f"python{sys.version_info.major}.{sys.version_info.minor}"
+#                     / "site-packages"
+#                 )
+#             if venv_site.exists():
+#                 search_paths = [str(venv_site)]
+
+#         installed = set()
+#         dists = (
+#             importlib.metadata.distributions(path=search_paths)
+#             if search_paths
+#             else importlib.metadata.distributions()
+#         )
+
+#         for dist in dists:
+#             name = dist.metadata.get("Name")
+#             if name:
+#                 installed.add(name.lower().replace("_", "-"))
+#         return installed
+
+#     def resolve_missing(self, required_imports: Set[str]) -> List[str]:
+#         """Identifies imports that are not installed in the target environment."""
+#         installed = self.get_installed_packages()
+#         missing_pypi_packages = []
+
+#         third_party_imports = required_imports - self.stdlib_modules
+
+#         for imp in third_party_imports:
+#             pypi_name = self.mapper.map_import_to_pypi(imp)
+#             normalized_pypi = pypi_name.lower().replace("_", "-")
+
+#             if normalized_pypi not in installed:
+#                 missing_pypi_packages.append(pypi_name)
+
+#         return missing_pypi_packages
+
+#     def run_post_install_hooks(self, installed_packages: List[str], python_exec: Path):
+#         """Runs additional commands required by specific packages after pip install."""
+#         for pkg in installed_packages:
+#             normalized_pkg = pkg.lower().replace("_", "-")
+#             if normalized_pkg in self.POST_INSTALL_HOOKS:
+#                 hook_args = self.POST_INSTALL_HOOKS[normalized_pkg]
+#                 cmd = [str(python_exec), *hook_args]
+#                 print(f"[TraceReq] Running post-installation setup for '{pkg}': {' '.join(cmd)}")
+#                 subprocess.run(cmd, check=False)
+
+#     def install_packages(self, packages: List[str]) -> bool:
+#         """Executes pip install targeting the detected virtual environment and triggers post-install hooks."""
+#         if not packages:
+#             return True
+
+#         python_exec = self.get_target_python()
+
+#         if self.venv_path:
+#             print(f"\n[TraceReq] Target Virtual Environment Found: {self.venv_path.name}")
+#         else:
+#             print("\n[TraceReq] No local venv found. Target: Global Environment")
+
+#         print(f"[TraceReq] Target Python: {python_exec}")
+#         print(f"[TraceReq] Installing dependencies: {', '.join(packages)}...")
+
+#         cmd = [str(python_exec), "-m", "pip", "install", *packages]
+#         result = subprocess.run(cmd)
+
+#         if result.returncode == 0:
+#             print("[TraceReq] Installation completed successfully!")
+#             # Run post-install hooks (e.g., downloading Playwright browser binaries)
+#             self.run_post_install_hooks(packages, python_exec)
+#             print()
+#             return True
+
+#         print("[TraceReq] Error occurred during pip installation.\n")
+#         return False
+
+import importlib.metadata
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Optional, Set
+from auto_req.mapper import PyPIMapper
+
+
+class PackageInstaller:
+    """Detects missing dependencies and installs them into a project's local virtual environment."""
+
+    COMMON_VENV_NAMES = [".venv", "venv", "env", ".env", "virtualenv"]
+
+    # Special packages requiring additional commands after initial pip install
+    POST_INSTALL_HOOKS = {
+        "playwright": ["-m", "playwright", "install","chromium"]
+    }
+
+    # Regex patterns mapped to repair actions when execution fails
+    ERROR_REMEDIATION_RULES = [
+        {
+            "pattern": r"Executable doesn't exist at .*ms-playwright",
+            "description": "Missing Playwright browser binaries",
+            "args": ["-m", "playwright", "install"],
+        },
+        {
+            "pattern": r"playwright install",
+            "description": "Playwright post-install requirement detected",
+            "args": ["-m", "playwright", "install"],
+        },
+        {
+            "pattern": r"spacy\.util\.load_model.*Can't find model",
+            "description": "Missing spaCy language model",
+            "args": ["-m", "spacy", "download", "en_core_web_sm"],
+        },
+        {
+            "pattern": r"Resource .* not found\. Please use the NLTK Downloader",
+            "description": "Missing NLTK data package",
+            "args": ["-c", "import nltk; nltk.download('all')"],
+        },
+    ]
+
+    def __init__(self, project_root: Optional[Path] = None):
+        self.mapper = PyPIMapper()
+        self.stdlib_modules = set(sys.stdlib_module_names)
+        self.project_root = Path(project_root or Path.cwd()).resolve()
+        self.venv_path = self._detect_virtual_env()
+
+    def _detect_virtual_env(self) -> Optional[Path]:
+        """Dynamically locates any virtual environment directory inside or around the project root."""
+        if "VIRTUAL_ENV" in os.environ:
+            active_env = Path(os.environ["VIRTUAL_ENV"])
+            if self._is_valid_venv(active_env):
+                return active_env
+
+        if sys.prefix != sys.base_prefix:
+            active_sys_venv = Path(sys.prefix)
+            if self._is_valid_venv(active_sys_venv):
+                return active_sys_venv
+
+        for name in self.COMMON_VENV_NAMES:
+            candidate = self.project_root / name
+            if self._is_valid_venv(candidate):
+                return candidate
+
+        for name in self.COMMON_VENV_NAMES:
+            candidate = self.project_root.parent / name
+            if self._is_valid_venv(candidate):
+                return candidate
+
+        try:
+            for item in self.project_root.iterdir():
+                if item.is_dir() and item.name not in self.COMMON_VENV_NAMES:
+                    if self._is_valid_venv(item):
+                        return item
+        except PermissionError:
+            pass
+
+        return None
+
+    def _is_valid_venv(self, path: Path) -> bool:
+        """Checks if a directory contains a valid virtual environment Python binary."""
+        if os.name == "nt":  # Windows
+            py_exec = path / "Scripts" / "python.exe"
+        else:  # macOS / Linux
+            py_exec = path / "bin" / "python"
+        return py_exec.exists()
+
+    def get_target_python(self) -> Path:
+        """Returns the Python binary path of the detected venv, or system Python fallback."""
+        if self.venv_path:
+            if os.name == "nt":
+                py_exec = self.venv_path / "Scripts" / "python.exe"
+            else:
+                py_exec = self.venv_path / "bin" / "python"
+
+            if py_exec.exists():
+                return py_exec
+
+        return Path(sys.executable)
+
+    def get_installed_packages(self) -> Set[str]:
+        """Returns normalized names of installed packages in the target venv/environment."""
+        search_paths = []
+
+        if self.venv_path:
+            if os.name == "nt":
+                venv_site = self.venv_path / "Lib" / "site-packages"
+            else:
+                venv_site = (
+                    self.venv_path
+                    / "lib"
+                    / f"python{sys.version_info.major}.{sys.version_info.minor}"
+                    / "site-packages"
+                )
+            if venv_site.exists():
+                search_paths = [str(venv_site)]
+
+        installed = set()
+        dists = (
+            importlib.metadata.distributions(path=search_paths)
+            if search_paths
+            else importlib.metadata.distributions()
+        )
+
+        for dist in dists:
+            name = dist.metadata.get("Name")
+            if name:
+                installed.add(name.lower().replace("_", "-"))
+        return installed
+
+    # def resolve_missing(self, required_imports: Set[str]) -> List[str]:
+    #     """Identifies imports that are not installed in the target environment."""
+    #     installed = self.get_installed_packages()
+    #     missing_pypi_packages = []
+
+    #     third_party_imports = required_imports - self.stdlib_modules
+
+    #     for imp in third_party_imports:
+    #         pypi_name = self.mapper.map_import_to_pypi(imp)
+    #         normalized_pypi = pypi_name.lower().replace("_", "-")
+
+    #         if normalized_pypi not in installed:
+    #             missing_pypi_packages.append(pypi_name)
+
+    #     return missing_pypi_packages
+    def resolve_missing(self, required_imports: Set[str]) -> List[str]:
+        """Identifies imports that are not installed in the target environment."""
+        installed = self.get_installed_packages()
+        missing_pypi_packages = []
+
+        # 1. Ignore Python built-in standard library modules (os, sys, math, etc.)
+        third_party_imports = required_imports - self.stdlib_modules
+
+        # 2. Ignore Local Project Modules/Folders (e.g., auto_req, utils, tests)
+        external_imports = set()
+        for imp in third_party_imports:
+            local_folder = self.project_root / imp
+            local_file = self.project_root / f"{imp}.py"
+            
+            # If the folder or file exists locally in your project, skip it!
+            if local_folder.exists() or local_file.exists():
+                continue
+                
+            external_imports.add(imp)
+
+        # 3. Only attempt to download actual third-party packages from PyPI
+        for imp in external_imports:
+            pypi_name = self.mapper.map_import_to_pypi(imp)
+            normalized_pypi = pypi_name.lower().replace("_", "-")
+
+            if normalized_pypi not in installed:
+                missing_pypi_packages.append(pypi_name)
+
+        return missing_pypi_packages
+
+    def run_post_install_hooks(self, installed_packages: List[str], python_exec: Path):
+        """Runs additional setup commands required by specific packages after pip install."""
+        for pkg in installed_packages:
+            normalized_pkg = pkg.lower().replace("_", "-")
+            if normalized_pkg in self.POST_INSTALL_HOOKS:
+                hook_args = self.POST_INSTALL_HOOKS[normalized_pkg]
+                cmd = [str(python_exec), *hook_args]
+                print(f"[TraceReq] Running post-installation setup for '{pkg}': {' '.join(cmd)}")
+                subprocess.run(cmd, check=False)
+
+    def install_packages(self, packages: List[str]) -> bool:
+        """Executes pip install targeting the detected virtual environment and triggers post-install hooks."""
+        if not packages:
+            return True
+
+        python_exec = self.get_target_python()
+
+        if self.venv_path:
+            print(f"\n[TraceReq] Target Virtual Environment Found: {self.venv_path.name}")
+        else:
+            print("\n[TraceReq] No local venv found. Target: Global Environment")
+
+        print(f"[TraceReq] Target Python: {python_exec}")
+        print(f"[TraceReq] Installing dependencies: {', '.join(packages)}...")
+
+        cmd = [str(python_exec), "-m", "pip", "install", *packages]
+        result = subprocess.run(cmd)
+
+        if result.returncode == 0:
+            print("[TraceReq] Installation completed successfully!")
+            self.run_post_install_hooks(packages, python_exec)
+            print()
+            return True
+
+        print("[TraceReq] Error occurred during pip installation.\n")
+        return False
+
+    def attempt_error_remediation(self, error_output: str) -> bool:
+        """Parses stdout/stderr tracebacks for known dependency errors and attempts repair."""
+        python_exec = self.get_target_python()
+
+        for rule in self.ERROR_REMEDIATION_RULES:
+            if re.search(rule["pattern"], error_output, re.IGNORECASE):
+                print(f"\n[TraceReq] Detected execution error: {rule['description']}")
+                cmd = [str(python_exec), *rule["args"]]
+                print(f"[TraceReq] Auto-remediating: {' '.join(cmd)}")
+
+                result = subprocess.run(cmd)
+                if result.returncode == 0:
+                    print("[TraceReq] Auto-remediation succeeded!\n")
+                    return True
+
+                print("[TraceReq] Auto-remediation failed.\n")
+                return False
+
+        return False

auto_req/mapper.py

@@ -0,0 +1,166 @@
+# import json
+# import urllib.request
+# import urllib.error
+# from pathlib import Path
+# from typing import Dict
+
+
+# class PyPIMapper:
+#     """Maps import names to PyPI package names with static overrides and PyPI API fallback."""
+
+#     # Well-known import-to-PyPI mismatches
+#     KNOWN_MAPPINGS: Dict[str, str] = {
+#         "bs4": "beautifulsoup4",
+#         "PIL": "Pillow",
+#         "cv2": "opencv-python",
+#         "yaml": "PyYAML",
+#         "sklearn": "scikit-learn",
+#         "fitz": "PyMuPDF",
+#         "docx": "python-docx",
+#         "pptx": "python-pptx",
+#         "google/protobuf": "protobuf",
+#         "crypto": "pycryptodome",
+#         "serial": "pyserial",
+#         "jose": "python-jose",
+#     }
+
+#     def __init__(self, cache_file: Path = Path(".auto_req_cache.json")):
+#         self.cache_file = cache_file
+#         self.cache: Dict[str, str] = self._load_cache()
+
+#     def _load_cache(self) -> Dict[str, str]:
+#         if self.cache_file.exists():
+#             try:
+#                 with open(self.cache_file, "r", encoding="utf-8") as f:
+#                     return json.load(f)
+#             except Exception:
+#                 return {}
+#         return {}
+
+#     def _save_cache(self):
+#         try:
+#             with open(self.cache_file, "w", encoding="utf-8") as f:
+#                 json.dump(self.cache, f, indent=2)
+#         except Exception:
+#             pass
+
+#     def map_import_to_pypi(self, import_name: str) -> str:
+#         """Resolves an import name to a PyPI package name."""
+#         # 1. Check known mappings override
+#         if import_name in self.KNOWN_MAPPINGS:
+#             return self.KNOWN_MAPPINGS[import_name]
+
+#         # 2. Check local disk cache
+#         if import_name in self.cache:
+#             return self.cache[import_name]
+
+#         # 3. Query PyPI JSON API to confirm package existence
+#         pypi_name = import_name
+#         url = f"https://pypi.org/pypi/{import_name}/json"
+#         try:
+#             req = urllib.request.Request(url, headers={"User-Agent": "auto-req"})
+#             with urllib.request.urlopen(req, timeout=2):
+#                 pypi_name = import_name
+#         except urllib.error.HTTPError as e:
+#             if e.code == 404:
+#                 # Common fallback heuristic: underscore to dash
+#                 pypi_name = import_name.replace("_", "-")
+
+#         # Update cache
+#         self.cache[import_name] = pypi_name
+#         self._save_cache()
+#         return pypi_name
+
+
+import json
+import urllib.request
+import urllib.error
+from pathlib import Path
+from typing import Dict, Optional
+
+
+class PyPIMapper:
+    """Dynamically resolves import names to PyPI package names using heuristics,
+
+    well-known mappings, and PyPI API checks.
+    """
+
+    # Primary overrides where import name and PyPI package name completely diverge
+    KNOWN_MAPPINGS: Dict[str, str] = {
+        "allure": "allure-pytest",
+        "bs4": "beautifulsoup4",
+        "PIL": "Pillow",
+        "cv2": "opencv-python",
+        "yaml": "PyYAML",
+        "sklearn": "scikit-learn",
+        "fitz": "PyMuPDF",
+        "docx": "python-docx",
+        "pptx": "python-pptx",
+        "google/protobuf": "protobuf",
+        "crypto": "pycryptodome",
+        "serial": "pyserial",
+        "jose": "python-jose",
+    }
+
+    def __init__(self, cache_file: Path = Path(".auto_req_cache.json")):
+        self.cache_file = cache_file
+        self.cache: Dict[str, str] = self._load_cache()
+
+    def _load_cache(self) -> Dict[str, str]:
+        if self.cache_file.exists():
+            try:
+                with open(self.cache_file, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except Exception:
+                return {}
+        return {}
+
+    def _save_cache(self):
+        try:
+            with open(self.cache_file, "w", encoding="utf-8") as f:
+                json.dump(self.cache, f, indent=2)
+        except Exception:
+            pass
+
+    def _verify_pypi_package(self, package_name: str) -> bool:
+        """Queries PyPI JSON API to check if a package name exists."""
+        url = f"https://pypi.org/pypi/{package_name}/json"
+        try:
+            req = urllib.request.Request(url, headers={"User-Agent": "TraceReq"})
+            with urllib.request.urlopen(req, timeout=3):
+                return True
+        except (urllib.error.HTTPError, urllib.error.URLError, Exception):
+            return False
+
+    def map_import_to_pypi(self, import_name: str) -> str:
+        """Resolves an import name to a PyPI package name dynamically."""
+        clean_import = import_name.lower().strip()
+
+        # 1. Check known static overrides
+        if clean_import in self.KNOWN_MAPPINGS:
+            return self.KNOWN_MAPPINGS[clean_import]
+
+        # 2. Check local disk cache
+        if clean_import in self.cache:
+            return self.cache[clean_import]
+
+        # 3. Dynamic candidate resolution heuristics
+        candidates = [
+            clean_import,                           # Exact match (e.g., requests -> requests)
+            clean_import.replace("_", "-"),         # Underscore to dash (e.g., pytest_cov -> pytest-cov)
+            f"pytest-{clean_import}",               # Pytest plugin naming convention
+            f"python-{clean_import.replace('_', '-')}",  # Common prefix (e.g., python-dotenv)
+            f"{clean_import.replace('_', '-')}-python",  # Common suffix
+        ]
+
+        # 4. Probe candidates against PyPI API
+        resolved_pypi_name = clean_import
+        for candidate in candidates:
+            if self._verify_pypi_package(candidate):
+                resolved_pypi_name = candidate
+                break
+
+        # 5. Persist resolved candidate to cache
+        self.cache[clean_import] = resolved_pypi_name
+        self._save_cache()
+        return resolved_pypi_name

auto_req/pytest_plugin.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+from auto_req.analyzer import CodeAnalyzer
+from auto_req.installer import PackageInstaller
+
+
+def pytest_addoption(parser):
+    """Add CLI flags to PyTest."""
+    group = parser.getgroup("auto-req")
+    group.addoption(
+        "--no-auto-req",
+        action="store_true",
+        default=False,
+        help="Disable automatic requirement analysis and installation.",
+    )
+
+
+def pytest_configure(config):
+    """PyTest hook that runs early during test session setup."""
+    if config.getoption("--no-auto-req", default=False):
+        return
+
+    root_dir = Path(config.rootdir)
+    
+    # 1. Scan codebase and test files
+    analyzer = CodeAnalyzer()
+    required_imports = analyzer.scan_directory(root_dir)
+
+    # 2. Resolve missing and auto-install
+    installer = PackageInstaller()
+    missing = installer.resolve_missing(required_imports)
+
+    if missing:
+        installer.install_packages(missing)

runtime_deps-0.1.0.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: runtime-deps
+Version: 0.1.0
+Summary: AST-driven dynamic dependency resolution and runtime provisioning engine.
+Author: Pavan Kumar Korrapati
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+TraceReq source project
+        │
+        │ python -m build
+        ▼
+dist/
+ ├── auto_req-0.1.0-py3-none-any.whl   ← reusable package
+ └── auto_req-0.1.0.tar.gz
+        │
+        │ pip install
+        ▼
+Any Python project
+ ├── .venv/
+ ├── tests/
+ ├── src/
+ └── ...
+        │
+        └── auto-req command

runtime_deps-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+auto_req/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_req/analyzer.py,sha256=CnBbg2W2N0_7nyiW4C2s871IcHgWi3T2KJ2pcujzYPU,1935
+auto_req/cli.py,sha256=HgOeuBa8mZcnLrWpClIrxx36XhIDKFd-2FvXhrscQ7E,4807
+auto_req/installer.py,sha256=dc_kUp0iLzh72J_qHrjfuNly3okXUHOTc0jaFSAsAhs,21963
+auto_req/mapper.py,sha256=YH2MCQNWPOFS5aw7Cc8R5fr47up83msuT0msBkYaMQM,6012
+auto_req/pytest_plugin.py,sha256=DPsDWx90oZO7aPlVntqUJI20bwRsI_ttabwbAwElHQE,964
+runtime_deps-0.1.0.dist-info/METADATA,sha256=D2siJMr3WG-XJoiJKmpzetDBBqCrs5Tgn_Rw6LNlFA4,621
+runtime_deps-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+runtime_deps-0.1.0.dist-info/entry_points.txt,sha256=RHxwHRvoF8xI3InFkshRJahmexqTFYUoxsdgxK0G7qY,78
+runtime_deps-0.1.0.dist-info/top_level.txt,sha256=iBvflo4ZDdfGy5z7EsrRAwD8wg_pyDIKZ2acAQvsKKI,9
+runtime_deps-0.1.0.dist-info/RECORD,,

runtime_deps-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

runtime_deps-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+rtdeps = auto_req.cli:main
+runtime-deps = auto_req.cli:main

runtime_deps-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+auto_req