pdd-cli 0.0.43__py3-none-any.whl → 0.0.45__py3-none-any.whl

pdd/pytest_output.py

@@ -3,9 +3,11 @@ import json
 import io
 import sys
 import pytest
+import subprocess
 from rich.console import Console
 from rich.pretty import pprint
 import os
+from .python_env_detector import detect_host_python_executable
 
 console = Console()
 
@@ -80,27 +82,77 @@ def run_pytest_and_capture_output(test_file: str) -> dict:
         )
         return {}
 
-    collector = TestResultCollector()
+    # Use environment-aware Python executable for pytest execution
+    python_executable = detect_host_python_executable()
+    
     try:
-        collector.capture_logs()
-        result = pytest.main([test_file], plugins=[collector])
-    finally:
-        stdout, stderr = collector.get_logs()
-
-    return {
-        "test_file": test_file,
-        "test_results": [
-            {
-                "standard_output": stdout,
-                "standard_error": stderr,
-                "return_code": int(result),
-                "warnings": collector.warnings,
-                "errors": collector.errors,
-                "failures": collector.failures,
-                "passed": collector.passed,
-            }
-        ],
-    }
+        # Run pytest using subprocess with the detected Python executable
+        result = subprocess.run(
+            [python_executable, "-m", "pytest", test_file, "-v"],
+            capture_output=True,
+            text=True,
+            timeout=300
+        )
+        
+        stdout = result.stdout
+        stderr = result.stderr
+        return_code = result.returncode
+        
+        # Parse the output to extract test results
+        # Count passed, failed, and skipped tests from the output
+        passed = stdout.count(" PASSED")
+        failures = stdout.count(" FAILED") + stdout.count(" ERROR")
+        errors = 0  # Will be included in failures for subprocess execution
+        warnings = stdout.count("warning")
+        
+        # If return code is 2, it indicates a pytest error
+        if return_code == 2:
+            errors = 1
+        
+        return {
+            "test_file": test_file,
+            "test_results": [
+                {
+                    "standard_output": stdout,
+                    "standard_error": stderr,
+                    "return_code": return_code,
+                    "warnings": warnings,
+                    "errors": errors,
+                    "failures": failures,
+                    "passed": passed,
+                }
+            ],
+        }
+    except subprocess.TimeoutExpired:
+        return {
+            "test_file": test_file,
+            "test_results": [
+                {
+                    "standard_output": "",
+                    "standard_error": "Test execution timed out",
+                    "return_code": -1,
+                    "warnings": 0,
+                    "errors": 1,
+                    "failures": 0,
+                    "passed": 0,
+                }
+            ],
+        }
+    except Exception as e:
+        return {
+            "test_file": test_file,
+            "test_results": [
+                {
+                    "standard_output": "",
+                    "standard_error": f"Error running pytest: {str(e)}",
+                    "return_code": -1,
+                    "warnings": 0,
+                    "errors": 1,
+                    "failures": 0,
+                    "passed": 0,
+                }
+            ],
+        }
 
 def save_output_to_json(output: dict, output_file: str = "pytest.json"):
     """

pdd/python_env_detector.py

@@ -0,0 +1,151 @@
+"""
+Python Environment Detector
+
+Detects the host shell's Python environment (conda, venv, poetry, pipenv, etc.)
+and returns the appropriate Python executable for subprocess calls.
+
+This ensures that PDD operations use the same Python environment as the shell
+that launched PDD, rather than the uv tools environment where PDD is installed.
+"""
+
+import os
+import sys
+import shutil
+from pathlib import Path
+from typing import Optional
+
+
+def detect_host_python_executable() -> str:
+    """
+    Detect the host shell's Python executable.
+    
+    This function checks for various virtual environment indicators
+    and returns the appropriate Python executable path.
+    
+    Returns:
+        str: Path to the Python executable that should be used for subprocess calls.
+             Falls back to sys.executable if no host environment is detected.
+    
+    Detection order:
+    1. VIRTUAL_ENV (works for venv, virtualenv, poetry, pipenv)
+    2. CONDA_PREFIX (conda-specific)
+    3. PATH resolution with shutil.which('python')
+    4. sys.executable (fallback)
+    """
+    
+    # Check for virtual environment (venv, virtualenv, poetry, pipenv)
+    virtual_env = os.environ.get('VIRTUAL_ENV')
+    if virtual_env:
+        # Try common Python executable locations within the virtual environment
+        for python_name in ['python', 'python3']:
+            # Unix-like systems
+            venv_python = Path(virtual_env) / 'bin' / python_name
+            if venv_python.is_file():
+                return str(venv_python)
+            
+            # Windows
+            venv_python = Path(virtual_env) / 'Scripts' / f'{python_name}.exe'
+            if venv_python.is_file():
+                return str(venv_python)
+    
+    # Check for conda environment
+    conda_prefix = os.environ.get('CONDA_PREFIX')
+    if conda_prefix:
+        # Try common Python executable locations within conda environment
+        for python_name in ['python', 'python3']:
+            # Unix-like systems
+            conda_python = Path(conda_prefix) / 'bin' / python_name
+            if conda_python.is_file():
+                return str(conda_python)
+            
+            # Windows
+            conda_python = Path(conda_prefix) / f'{python_name}.exe'
+            if conda_python.is_file():
+                return str(conda_python)
+    
+    # Use PATH resolution as fallback (respects shell's PATH modifications)
+    which_python = shutil.which('python')
+    if which_python and Path(which_python).resolve() != Path(sys.executable).resolve():
+        # Only use if it's different from the current sys.executable
+        # This helps detect when we're in a different environment
+        return which_python
+    
+    # Try python3 as well
+    which_python3 = shutil.which('python3')
+    if which_python3 and Path(which_python3).resolve() != Path(sys.executable).resolve():
+        return which_python3
+    
+    # Final fallback to current executable
+    return sys.executable
+
+
+def get_environment_info() -> dict:
+    """
+    Get detailed information about the current Python environment.
+    
+    Returns:
+        dict: Dictionary containing environment information for debugging
+    """
+    return {
+        'sys_executable': sys.executable,
+        'detected_executable': detect_host_python_executable(),
+        'virtual_env': os.environ.get('VIRTUAL_ENV'),
+        'conda_prefix': os.environ.get('CONDA_PREFIX'), 
+        'conda_default_env': os.environ.get('CONDA_DEFAULT_ENV'),
+        'poetry_active': os.environ.get('POETRY_ACTIVE'),
+        'pipenv_active': os.environ.get('PIPENV_ACTIVE'),
+        'which_python': shutil.which('python'),
+        'which_python3': shutil.which('python3'),
+        'path': os.environ.get('PATH', '').split(os.pathsep)[:3],  # First 3 PATH entries
+    }
+
+
+def is_in_virtual_environment() -> bool:
+    """
+    Check if we're currently running in any kind of virtual environment.
+    
+    Returns:
+        bool: True if in a virtual environment, False otherwise
+    """
+    return bool(
+        os.environ.get('VIRTUAL_ENV') or 
+        os.environ.get('CONDA_PREFIX') or
+        os.environ.get('POETRY_ACTIVE') or
+        os.environ.get('PIPENV_ACTIVE')
+    )
+
+
+def get_environment_type() -> str:
+    """
+    Determine the type of virtual environment we're in.
+    
+    Returns:
+        str: Type of environment ('conda', 'venv', 'poetry', 'pipenv', 'system', 'unknown')
+    """
+    if os.environ.get('CONDA_PREFIX'):
+        return 'conda'
+    elif os.environ.get('POETRY_ACTIVE'):
+        return 'poetry'
+    elif os.environ.get('PIPENV_ACTIVE'):
+        return 'pipenv'
+    elif os.environ.get('VIRTUAL_ENV'):
+        return 'venv'
+    elif is_in_virtual_environment():
+        return 'unknown'
+    else:
+        return 'system'
+
+
+if __name__ == '__main__':
+    # Demo/test functionality
+    print("Python Environment Detection")
+    print("=" * 40)
+    
+    env_info = get_environment_info()
+    for key, value in env_info.items():
+        print(f"{key}: {value}")
+    
+    print()
+    print(f"Environment type: {get_environment_type()}")
+    print(f"In virtual environment: {is_in_virtual_environment()}")
+    print(f"Detected Python executable: {detect_host_python_executable()}")

pdd/summarize_directory.py

@@ -1,5 +1,11 @@
 from typing import Optional, Tuple
-from datetime import datetime, UTC
+from datetime import datetime
+try:
+    from datetime import UTC
+except ImportError:
+    # Python < 3.11 compatibility
+    from datetime import timezone
+    UTC = timezone.utc
 from io import StringIO
 import os
 import glob