py-drift-check 0.1.0__tar.gz

py_drift_check-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+.venv/
+__pycache__/
+*.pyc
+report.json
+dist/
+build/
+*.egg-info/

py_drift_check-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: py-drift-check
+Version: 0.1.0
+Summary: Detect API drift between codebase and installed dependencies.
+Requires-Python: >=3.9
+Requires-Dist: rich>=13.7.0
+Requires-Dist: typer>=0.12.0
+Description-Content-Type: text/markdown
+
+```markdown
+# drift-check 🔎
+
+**drift-check** is an experimental CLI tool that detects API signature mismatches between your Python codebase and your installed dependencies. 
+
+If you've ever upgraded a package (like OpenAI, FastAPI, or Pydantic) only to have your app crash at runtime because a parameter was renamed or removed, `drift-check` is built to catch that *before* you run your code.
+
+## How It Works
+Instead of executing your application, `drift-check` uses an AST (Abstract Syntax Tree) to read your function calls, spins up a secure subprocess inside your project's `.venv`, and dynamically validates your arguments against the actual signatures of your installed packages.
+
+## Installation
+
+Install globally via `uv` (recommended):
+```bash
+uv tool install drift-check
+
+```
+
+Or via pip:
+
+```bash
+pip install drift-check
+
+```
+
+## Quickstart
+
+Navigate to any Python project and run:
+
+```bash
+drift-check run .
+
+```
+
+## Example Output
+
+```text
+┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃ Status     ┃ Location           ┃ Package  ┃ Message                                             ┃
+┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+│ ❌ ERROR   │ main.py:19         │ openai   │ Unknown parameter passed: 'model_name'              │
+│ ⚠ WARN     │ database.py:42     │ asyncpg  │ Unable to verify forwarded keyword argument         │
+│ ✓ OK       │ router.py:12       │ httpx    │ All parameters valid.                               │
+└────────────┴────────────────────┴──────────┴─────────────────────────────────────────────────────┘
+
+```
+
+## Features & Current Limitations (v0.1.0)
+
+This tool is in active development. Please report edge cases!
+
+**Supported:**
+
+* ✅ Dynamic runtime signature inspection
+* ✅ Automatic `.venv` detection
+* ✅ Unpacking modern `TypedDict` type-hints (e.g., OpenAI SDK)
+* ✅ Standard library filtering
+
+**Known Limitations (v0.1.0):**
+
+* ⚠️ **Instantiated Variables:** Currently struggles to trace methods called on class instances (e.g., `app.post` in FastAPI).
+* ⚠️ **Dynamic Kwargs:** Cannot statically verify parameters passed dynamically via `**kwargs` at the call site.
+
+## License
+
+MIT
+
+```
+
+```

py_drift_check-0.1.0/README.md

@@ -0,0 +1,70 @@
+```markdown
+# drift-check 🔎
+
+**drift-check** is an experimental CLI tool that detects API signature mismatches between your Python codebase and your installed dependencies. 
+
+If you've ever upgraded a package (like OpenAI, FastAPI, or Pydantic) only to have your app crash at runtime because a parameter was renamed or removed, `drift-check` is built to catch that *before* you run your code.
+
+## How It Works
+Instead of executing your application, `drift-check` uses an AST (Abstract Syntax Tree) to read your function calls, spins up a secure subprocess inside your project's `.venv`, and dynamically validates your arguments against the actual signatures of your installed packages.
+
+## Installation
+
+Install globally via `uv` (recommended):
+```bash
+uv tool install drift-check
+
+```
+
+Or via pip:
+
+```bash
+pip install drift-check
+
+```
+
+## Quickstart
+
+Navigate to any Python project and run:
+
+```bash
+drift-check run .
+
+```
+
+## Example Output
+
+```text
+┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃ Status     ┃ Location           ┃ Package  ┃ Message                                             ┃
+┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+│ ❌ ERROR   │ main.py:19         │ openai   │ Unknown parameter passed: 'model_name'              │
+│ ⚠ WARN     │ database.py:42     │ asyncpg  │ Unable to verify forwarded keyword argument         │
+│ ✓ OK       │ router.py:12       │ httpx    │ All parameters valid.                               │
+└────────────┴────────────────────┴──────────┴─────────────────────────────────────────────────────┘
+
+```
+
+## Features & Current Limitations (v0.1.0)
+
+This tool is in active development. Please report edge cases!
+
+**Supported:**
+
+* ✅ Dynamic runtime signature inspection
+* ✅ Automatic `.venv` detection
+* ✅ Unpacking modern `TypedDict` type-hints (e.g., OpenAI SDK)
+* ✅ Standard library filtering
+
+**Known Limitations (v0.1.0):**
+
+* ⚠️ **Instantiated Variables:** Currently struggles to trace methods called on class instances (e.g., `app.post` in FastAPI).
+* ⚠️ **Dynamic Kwargs:** Cannot statically verify parameters passed dynamically via `**kwargs` at the call site.
+
+## License
+
+MIT
+
+```
+
+```

py_drift_check-0.1.0/ast_demo.py

@@ -0,0 +1,17 @@
+import ast
+
+# A tiny fake codebase
+code = """
+from openai import OpenAI
+client = OpenAI()
+client.chat.completions.create(
+    model="gpt-4",
+    temperature=0.2
+)
+"""
+
+# Parse the code into an AST
+tree = ast.parse(code)
+
+# Print the tree nicely formatted
+print(ast.dump(tree, indent=2))

py_drift_check-0.1.0/drift_check/analyzer.py

@@ -0,0 +1,105 @@
+#analyzer.py
+import ast
+from pathlib import Path
+from typing import List, Dict, Any
+from drift_check.models import CallSite
+
+class CallSiteVisitor(ast.NodeVisitor):
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        self.call_sites: List[CallSite] = []
+        
+        # Tracks: {"OpenAI": "openai"}
+        self.imports: Dict[str, str] = {}
+        # Tracks: {"client": "OpenAI"}
+        self.assignments: Dict[str, str] = {}
+
+    def visit_Import(self, node: ast.Import):
+            for alias in node.names:
+                # Handles 'import requests' and 'import requests as req'
+                local_name = alias.asname or alias.name
+                self.imports[local_name] = alias.name.split('.')[0]
+            self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom):
+        if node.module:
+            for alias in node.names:
+                local_name = alias.asname or alias.name
+                self.imports[local_name] = node.module.split('.')[0]
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom):
+        if node.module:
+            for alias in node.names:
+                # Maps the imported class/function to its base package
+                local_name = alias.asname or alias.name
+                self.imports[local_name] = node.module.split('.')[0]
+        self.generic_visit(node)
+
+    def visit_Assign(self, node: ast.Assign):
+        # Very basic tracking for: client = OpenAI()
+        if isinstance(node.value, ast.Call) and isinstance(node.value.func, ast.Name):
+            class_name = node.value.func.id
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    self.assignments[target.id] = class_name
+        self.generic_visit(node)
+
+    def visit_Call(self, node: ast.Call):
+        if isinstance(node.func, ast.Attribute):
+            parts = self._resolve_attribute_chain(node.func)
+            if parts:
+                base_var = parts[0]
+                method_chain = ".".join(parts[1:])
+                
+                # Resolve base_var -> Class -> Package
+                class_name = self.assignments.get(base_var, base_var)
+                package_name = self.imports.get(class_name)
+                
+                if package_name:
+                    kwargs = []
+                    has_dynamic = False
+                    for kw in node.keywords:
+                        if kw.arg is None:
+                            has_dynamic = True # **kwargs was used
+                        else:
+                            kwargs.append(kw.arg)
+                            
+                    self.call_sites.append(CallSite(
+                        file_path=self.file_path,
+                        line_number=node.lineno,
+                        package_name=package_name,
+                        method_name=method_chain,
+                        kwargs_passed=kwargs,
+                        has_dynamic_kwargs=has_dynamic
+                    ))
+        self.generic_visit(node)
+
+    def _resolve_attribute_chain(self, node: ast.expr) -> List[str]:
+        """Unpacks Attribute(Attribute(Name('client'), 'chat'), 'create') -> ['client', 'chat', 'create']"""
+        parts = []
+        current = node
+        while isinstance(current, ast.Attribute):
+            parts.insert(0, current.attr)
+            current = current.value
+        if isinstance(current, ast.Name):
+            parts.insert(0, current.id)
+            return parts
+        return []
+
+class ASTAnalyzer:
+    def __init__(self, python_files: List[Path]):
+        self.python_files = python_files
+
+    def analyze(self) -> List[CallSite]:
+        all_calls = []
+        for file_path in self.python_files:
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    tree = ast.parse(f.read(), filename=str(file_path))
+                visitor = CallSiteVisitor(str(file_path))
+                visitor.visit(tree)
+                all_calls.extend(visitor.call_sites)
+            except Exception as e:
+                pass # Ignore syntax errors in V1
+        return all_calls

py_drift_check-0.1.0/drift_check/cli.py

@@ -0,0 +1,84 @@
+import sys # NEW
+import typer
+from typing import Optional
+from rich.console import Console
+from drift_check.scanner import ProjectScanner
+from drift_check.dependencies import DependencyResolver
+from drift_check.analyzer import ASTAnalyzer
+from drift_check.signatures import SignatureResolver
+from drift_check.rules import RuleEngine
+from drift_check.reporter import Reporter
+from drift_check.env import EnvironmentDetector
+
+app = typer.Typer()
+console = Console()
+
+@app.callback()
+def main():
+    """Drift Check: Detect API signature drift."""
+    pass
+
+@app.command()
+def run(
+    target_dir: str = typer.Argument(".", help="Directory to scan"),
+    package: Optional[str] = typer.Option(None, "--package", help="Filter analysis to a specific package"),
+    to_version: Optional[str] = typer.Option(None, "--to", help="Target version to check against"),
+    include_stdlib: bool = typer.Option(False, "--include-stdlib", help="Include standard library packages in analysis") # NEW
+):
+    console.print("[bold blue]Starting Drift Check...[/bold blue]")
+    
+    if to_version and not package:
+        console.print("[red]❌ Error: You must specify a --package when using --to[/red]")
+        raise typer.Exit(code=1)
+    
+    # 1. Environment Discovery
+    env_detector = EnvironmentDetector(target_dir)
+    project_python = env_detector.find_python_executable()
+    console.print(f"[dim]Target Environment: {project_python}[/dim]")
+    
+    scanner = ProjectScanner(target_dir)
+    py_files, req_files = scanner.scan()
+    
+    analyzer = ASTAnalyzer(py_files)
+    call_sites = analyzer.analyze()
+    
+    console.print("\n[bold]Resolving Signatures...[/bold]")
+    if to_version:
+        console.print(f"[dim]Building isolated sandbox for {package}=={to_version}...[/dim]")
+        
+    # Inject the discovered project interpreter into the SignatureResolver
+    sig_resolver = SignatureResolver(
+        project_python_exec=project_python,
+        target_version=to_version, 
+        package_to_sandbox=package
+    )
+    
+    rule_engine = RuleEngine()
+    all_findings = []
+    
+    # Determine the stdlib names (fallback for older Python versions just in case)
+    stdlib_names = sys.stdlib_module_names if hasattr(sys, 'stdlib_module_names') else set()
+    
+    for call in call_sites:
+        # Skip self-references
+        if call.package_name == "drift_check":
+            continue
+            
+        # Filter by package if the user requested it
+        if package and call.package_name != package:
+            continue
+            
+        # NEW: Stdlib filtering
+        if not include_stdlib and call.package_name in stdlib_names:
+            continue
+            
+        sig = sig_resolver.resolve(call.package_name, call.method_name)
+        findings = rule_engine.evaluate(call, sig)
+        all_findings.extend(findings)
+        
+    reporter = Reporter()
+    reporter.generate_console_report(all_findings)
+    reporter.generate_json_report(all_findings)
+
+if __name__ == "__main__":
+    app()

py_drift_check-0.1.0/drift_check/dependencies.py

@@ -0,0 +1,41 @@
+import re
+from pathlib import Path
+from typing import List
+from drift_check.models import Dependency
+
+class DependencyResolver:
+    def __init__(self, dependency_files: List[Path]):
+        self.dependency_files = dependency_files
+
+    def resolve(self) -> List[Dependency]:
+        dependencies = []
+        
+        for file_path in self.dependency_files:
+            if file_path.name == "requirements.txt":
+                dependencies.extend(self._parse_requirements_txt(file_path))
+                
+        return dependencies
+
+    def _parse_requirements_txt(self, file_path: Path) -> List[Dependency]:
+        deps = []
+        pattern = re.compile(r"^([a-zA-Z0-9_\-]+)(.*)$")
+        
+        with open(file_path, "r", encoding="utf-8-sig") as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                    
+                match = pattern.match(line)
+                if match:
+                    name = match.group(1).strip()
+                    specifier = match.group(2).strip()
+                    is_pinned = "==" in specifier
+                    
+                    deps.append(Dependency(
+                        name=name,
+                        installed_version=None,
+                        is_pinned=is_pinned,
+                        specifier=specifier
+                    ))
+        return deps

py_drift_check-0.1.0/drift_check/env.py

@@ -0,0 +1,40 @@
+import os
+import sys
+from pathlib import Path
+
+class EnvironmentDetector:
+    def __init__(self, target_dir: str):
+        self.target_dir = Path(target_dir).resolve()
+
+    def find_python_executable(self) -> str:
+        """
+        Finds the most appropriate Python interpreter for the target project.
+        Search order: VIRTUAL_ENV variable -> .venv/ -> venv/ -> env/ -> sys.executable
+        """
+        
+        # 1. Check for an actively sourced virtual environment
+        active_venv = os.environ.get("VIRTUAL_ENV")
+        if active_venv:
+            if os.name == 'nt':
+                exec_path = Path(active_venv) / "Scripts" / "python.exe"
+            else:
+                exec_path = Path(active_venv) / "bin" / "python"
+                
+            if exec_path.exists():
+                return str(exec_path)
+
+        # 2. Check for standard local environment folders
+        venv_names = [".venv", "venv", "env"]
+        for venv_name in venv_names:
+            venv_path = self.target_dir / venv_name
+            if venv_path.is_dir():
+                if os.name == 'nt':
+                    exec_path = venv_path / "Scripts" / "python.exe"
+                else:
+                    exec_path = venv_path / "bin" / "python"
+                    
+                if exec_path.exists():
+                    return str(exec_path)
+        
+        # 3. Fallback to the active interpreter running the CLI
+        return sys.executable

py_drift_check-0.1.0/drift_check/models.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+from typing import Optional, List
+
+@dataclass
+class Dependency:
+    name: str
+    installed_version: Optional[str]
+    is_pinned: bool
+    specifier: str
+
+@dataclass
+class CallSite:
+    file_path: str
+    line_number: int
+    package_name: str
+    method_name: str
+    kwargs_passed: List[str]
+    has_dynamic_kwargs: bool
+
+@dataclass
+class SignatureDefinition:
+    package_name: str
+    method_name: str
+    valid_parameters: List[str]
+    is_unknown: bool = False
+    accepts_kwargs: bool = False
+    error_code: str = "SUCCESS"  
+    
+@dataclass
+class Finding:
+    severity: str
+    file_path: str
+    line_number: int
+    package_name: str
+    method_name: str
+    message: str

py_drift_check-0.1.0/drift_check/reporter.py

@@ -0,0 +1,58 @@
+import json
+from typing import List
+from rich.console import Console
+from rich.table import Table
+from drift_check.models import Finding
+
+class Reporter:
+    def __init__(self):
+        self.console = Console()
+
+    def generate_console_report(self, findings: List[Finding]):
+        if not findings:
+            self.console.print("[green]No findings to report![/green]")
+            return
+
+        self.console.print("\n[bold]Drift Check Results:[/bold]")
+        
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Status", width=10)
+        table.add_column("Location")
+        table.add_column("Package")
+        table.add_column("Message")
+
+        for finding in findings:
+            if finding.severity == "ERROR":
+                status = "[bold red]❌ ERROR[/bold red]"
+            elif finding.severity == "WARNING":
+                status = "[bold yellow]⚠ WARN[/bold yellow]"
+            else:
+                status = "[bold green]✓ OK[/bold green]"
+            
+            # We only want to show the file name, not the massive absolute path
+            short_path = finding.file_path.split("\\")[-1].split("/")[-1]
+            
+            table.add_row(
+                status,
+                f"{short_path}:{finding.line_number}",
+                finding.package_name,
+                finding.message
+            )
+        
+        self.console.print(table)
+
+    def generate_json_report(self, findings: List[Finding], output_path: str = "report.json"):
+        data = [
+            {
+                "severity": f.severity,
+                "file_path": f.file_path,
+                "line_number": f.line_number,
+                "package_name": f.package_name,
+                "method_name": f.method_name,
+                "message": f.message
+            }
+            for f in findings
+        ]
+        with open(output_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+        self.console.print(f"\n[dim]Report successfully saved to {output_path}[/dim]")

py_drift_check-0.1.0/drift_check/rules.py

@@ -0,0 +1,75 @@
+from drift_check.models import CallSite, SignatureDefinition, Finding
+
+class RuleEngine:
+    def evaluate(self, call: CallSite, sig: SignatureDefinition) -> list[Finding]:
+        findings = []
+
+        # Rule 1: Unknown Signatures (Diagnostic Messages)
+        if sig.is_unknown:
+            if sig.error_code == "PACKAGE_NOT_INSTALLED":
+                msg = f"Package '{sig.package_name}' not installed in target environment."
+            elif sig.error_code == "METHOD_NOT_FOUND":
+                msg = f"Method '{sig.method_name}' not found on '{sig.package_name}'."
+            elif sig.error_code == "SIGNATURE_UNAVAILABLE":
+                msg = f"Signature unavailable (likely C-extension). Cannot verify."
+            else:
+                msg = "Unsupported callable or unknown resolution error."
+                
+            findings.append(Finding(
+                severity="WARNING",
+                file_path=call.file_path,
+                line_number=call.line_number,
+                package_name=call.package_name,
+                method_name=call.method_name,
+                message=msg
+            ))
+            return findings
+
+        # Rule 2: Dynamic kwargs at the call site (e.g., func(**my_dict))
+        if call.has_dynamic_kwargs:
+            findings.append(Finding(
+                severity="WARNING",
+                file_path=call.file_path,
+                line_number=call.line_number,
+                package_name=call.package_name,
+                method_name=call.method_name,
+                message="Dynamic **kwargs detected. Cannot statically verify all parameters."
+            ))
+
+        # Rule 3: Parameter Matching & Forwarding
+        passed_ok = True
+        for kwarg in call.kwargs_passed:
+            if kwarg not in sig.valid_parameters:
+                passed_ok = False
+                
+                # Apply strict forwarding constraint
+                if sig.accepts_kwargs:
+                    findings.append(Finding(
+                        severity="WARNING",
+                        file_path=call.file_path,
+                        line_number=call.line_number,
+                        package_name=call.package_name,
+                        method_name=call.method_name,
+                        message=f"Unable to verify forwarded keyword argument: '{kwarg}'"
+                    ))
+                else:
+                    findings.append(Finding(
+                        severity="ERROR",
+                        file_path=call.file_path,
+                        line_number=call.line_number,
+                        package_name=call.package_name,
+                        method_name=call.method_name,
+                        message=f"Unknown parameter passed: '{kwarg}'"
+                    ))
+        
+        if passed_ok and not call.has_dynamic_kwargs:
+             findings.append(Finding(
+                severity="OK",
+                file_path=call.file_path,
+                line_number=call.line_number,
+                package_name=call.package_name,
+                method_name=call.method_name,
+                message="All parameters valid."
+            ))
+
+        return findings

py_drift_check-0.1.0/drift_check/scanner.py

@@ -0,0 +1,37 @@
+import os
+from pathlib import Path
+from typing import Tuple, List
+
+class ProjectScanner:
+    def __init__(self, target_dir: str):
+        self.target_dir = Path(target_dir).resolve()
+        self.ignore_dirs = {
+            ".git", ".venv", "venv", "__pycache__", 
+            "build", "dist", "node_modules"
+        }
+        self.dependency_filenames = {"requirements.txt", "pyproject.toml", "uv.lock"}
+
+    def scan(self) -> Tuple[List[Path], List[Path]]:
+        """
+        Walks the directory and returns a tuple of (python_files, dependency_files).
+        """
+        python_files = []
+        dependency_files = []
+
+        if not self.target_dir.exists() or not self.target_dir.is_dir():
+            return python_files, dependency_files
+
+        for root, dirs, files in os.walk(self.target_dir):
+            # TODO: Parse .gitignore here to dynamically add to ignore_dirs
+            # Mutate the dirs list in-place to skip ignored directories
+            dirs[:] = [d for d in dirs if d not in self.ignore_dirs]
+
+            root_path = Path(root)
+
+            for file in files:
+                if file.endswith(".py"):
+                    python_files.append(root_path / file)
+                elif file in self.dependency_filenames:
+                    dependency_files.append(root_path / file)
+
+        return python_files, dependency_files

py_drift_check-0.1.0/drift_check/signatures.py

@@ -0,0 +1,179 @@
+import importlib
+import importlib.util
+import inspect
+import subprocess
+import tempfile
+import json
+import os
+import ast
+import typing
+from typing import List, Optional
+from drift_check.models import SignatureDefinition
+
+# The inline worker now handles both standard signatures and TypedDicts securely in the target environment
+INLINE_WORKER = """
+import sys, json, importlib, inspect, typing
+sys.path.insert(0, os.getcwd())
+
+SDK_REGISTRY = {
+    "openai.chat.completions.create": ("openai.resources.chat.completions", "Completions.create")
+}
+
+def main():
+    package_name, method_name = sys.argv[1], sys.argv[2]
+    full_call = f"{package_name}.{method_name}"
+    
+    try:
+        # 1. Resolve physical path via Registry or standard traversal
+        if full_call in SDK_REGISTRY:
+            mod_path, class_path = SDK_REGISTRY[full_call]
+            current_obj = importlib.import_module(mod_path)
+            for part in class_path.split('.'):
+                current_obj = getattr(current_obj, part)
+        else:
+            current_obj = importlib.import_module(package_name)
+            for part in method_name.split('.'):
+                current_obj = getattr(current_obj, part)
+                
+        # 2. Standard Runtime Inspection
+        sig = inspect.signature(current_obj)
+        params = list(sig.parameters.keys())
+        has_varkw = False
+        
+        # 3. Targeted TypedDict Extraction
+        for param in sig.parameters.values():
+            if param.kind == inspect.Parameter.VAR_KEYWORD:
+                has_varkw = True
+                
+                # Check if kwargs is annotated with Unpack[TypedDict]
+                ann = param.annotation
+                if ann != inspect.Parameter.empty:
+                    type_args = getattr(ann, '__args__', None)
+                    target_type = type_args[0] if type_args else ann
+                    
+                    if hasattr(target_type, '__annotations__'):
+                        # Found the TypedDict! Append its keys to our valid parameters
+                        params.extend(target_type.__annotations__.keys())
+                        # Since we successfully unpacked it, it is no longer an unknown wildcard
+                        has_varkw = False 
+        
+        print(json.dumps({
+            "status": "SUCCESS",
+            "valid_parameters": list(set(params)),
+            "accepts_kwargs": has_varkw
+        }))
+        
+    except ModuleNotFoundError:
+        print(json.dumps({"status": "PACKAGE_NOT_INSTALLED"}))
+    except AttributeError:
+        print(json.dumps({"status": "METHOD_NOT_FOUND"}))
+    except ValueError:
+        print(json.dumps({"status": "SIGNATURE_UNAVAILABLE"}))
+    except Exception:
+        print(json.dumps({"status": "UNSUPPORTED_CALLABLE"}))
+
+if __name__ == '__main__':
+    main()
+"""
+
+class RuntimeProvider:
+    """Executes signature inspection securely within the target environment."""
+    def resolve(self, python_exec: str, package_name: str, method_name: str) -> dict:
+        result = subprocess.run(
+            [python_exec, "-c", INLINE_WORKER, package_name, method_name],
+            capture_output=True, text=True
+        )
+        try:
+            return json.loads(result.stdout.strip())
+        except json.JSONDecodeError:
+            return {"status": "UNSUPPORTED_CALLABLE"}
+
+class StubProvider:
+    """V2: Parses .pyi files (or typed .py files) using AST to extract signatures."""
+    def resolve(self, package_name: str, method_name: str) -> Optional[List[str]]:
+        try:
+            spec = importlib.util.find_spec(package_name)
+            if not spec or not spec.origin:
+                return None
+                
+            base_path = spec.origin
+            
+            if base_path.endswith('.py'):
+                pyi_path = base_path + 'i'
+                target_path = pyi_path if os.path.exists(pyi_path) else base_path
+            else:
+                return None 
+                
+            if not os.path.exists(target_path):
+                return None
+
+            with open(target_path, 'r', encoding='utf-8') as f:
+                tree = ast.parse(f.read())
+                
+            target_func = method_name.split('.')[-1]
+            
+            for node in ast.walk(tree):
+                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    if node.name == target_func:
+                        args = [arg.arg for arg in node.args.args if arg.arg != 'self']
+                        args.extend([arg.arg for arg in node.args.kwonlyargs])
+                        return args
+                        
+        except Exception:
+            pass
+        return None
+
+class SignatureResolver:
+    def __init__(self, project_python_exec: str, target_version: Optional[str] = None, package_to_sandbox: Optional[str] = None):
+        self.project_python_exec = project_python_exec
+        self.target_version = target_version
+        self.package_to_sandbox = package_to_sandbox
+        self.sandbox_dir = None
+        self.sandbox_python_exec = None
+        
+        self.runtime_provider = RuntimeProvider()
+        self.stub_provider = StubProvider()
+        
+        if self.target_version and self.package_to_sandbox:
+            self._setup_sandbox()
+
+    def _setup_sandbox(self):
+        self.sandbox_dir = tempfile.TemporaryDirectory()
+        path = self.sandbox_dir.name
+        
+        # 1. Create the virtual environment
+        subprocess.run(["uv", "venv"], cwd=path, check=True, capture_output=True)
+        
+        self.sandbox_python_exec = os.path.join(path, ".venv", "Scripts", "python.exe") if os.name == 'nt' else os.path.join(path, ".venv", "bin", "python")
+            
+        # 2. Install the package explicitly using the sandbox's python executable
+        # This strictly binds the installation to the sandbox, ignoring host environments
+        subprocess.run(
+            ["uv", "pip", "install", "--python", self.sandbox_python_exec, f"{self.package_to_sandbox}=={self.target_version}"],
+            cwd=path, check=True, capture_output=True
+        )
+
+    def resolve(self, package_name: str, method_name: str) -> SignatureDefinition:
+        target_exec = self.sandbox_python_exec if (self.sandbox_dir and package_name == self.package_to_sandbox) else self.project_python_exec
+        
+        # 1. Run dynamic worker in the target environment
+        data = self.runtime_provider.resolve(target_exec, package_name, method_name)
+        status = data.get("status", "UNSUPPORTED_CALLABLE")
+        
+        if status == "SUCCESS":
+            return SignatureDefinition(
+                package_name=package_name,
+                method_name=method_name,
+                valid_parameters=data.get("valid_parameters", []),
+                is_unknown=False,
+                accepts_kwargs=data.get("accepts_kwargs", False),
+                error_code="SUCCESS"
+            )
+            
+        # 2. Fallback to static .pyi stubs
+        params = self.stub_provider.resolve(package_name, method_name)
+        if params is not None:
+            return SignatureDefinition(package_name, method_name, params, is_unknown=False, error_code="SUCCESS")
+
+        # 3. Unresolvable error
+        return SignatureDefinition(package_name, method_name, [], is_unknown=True, error_code=status)

py_drift_check-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "py-drift-check" 
+version = "0.1.0"
+description = "Detect API drift between codebase and installed dependencies."
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "typer>=0.12.0",
+    "rich>=13.7.0"
+]
+
+[project.scripts]
+drift-check = "drift_check.cli:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["drift_check"]

py_drift_check-0.1.0/requirements.txt

@@ -0,0 +1,3 @@
+openai==1.50.0
+requests>=2.31
+stripe

py_drift_check-0.1.0/test_api.py

@@ -0,0 +1,19 @@
+import requests
+from openai import OpenAI
+import datetime
+
+# V1 failed this because it's a C-extension. V2 will parse the .pyi stub!
+now = datetime.datetime.now(tz=None)
+
+requests.post(url="https://api.example.com", json={"key": "value"})
+# The runtime provider handles this flawlessly
+requests.post(
+    url="https://api.example.com/data",
+    json={"key": "value"},
+    timeout=10,
+    fake_parameter=True # This should trigger an error!
+)
+
+# The runtime provider safely defers this to V2
+client = OpenAI()
+client.chat.completions.create(model="gpt-4")