@venv_required(path, requirements=None)

from angreal.integrations.venv import venv_required

@venv_required("/path/to/venv", requirements=["requests", "pandas"])
def process_data():
    # These imports work because the venv is activated
    import requests
    import pandas as pd

    # Your code here - runs in the activated virtual environment
    df = pd.DataFrame({'data': [1, 2, 3]})
    response = requests.get('https://api.example.com')

# After the function completes, the original environment is restored

from angreal.integrations.venv import VirtualEnv

venv = VirtualEnv(path="/path/to/venv")

VirtualEnv(path, python=None, requirements=None, now=True)

@property
def exists(self) -> bool

@property
def python_executable(self) -> Path

def install_requirements(self) -> None

def install(self, packages: Union[str, List[str], Path]) -> None

# Install single package
venv.install("requests")

# Install multiple packages
venv.install(["pandas", "numpy", "matplotlib"])

# Install from requirements file
venv.install("requirements.txt")

def activate(self) -> None

venv = VirtualEnv("myenv", now=True)
venv.install("requests")

# Before activation, requests might not be importable
venv.activate()

# Now requests can be imported
import requests
response = requests.get("https://api.github.com")

# Remember to deactivate when done
venv.deactivate()

def deactivate(self) -> None

venv = VirtualEnv("myenv", now=True)
venv.activate()
# Use the virtual environment
venv.deactivate()  # Restore original environment

with VirtualEnv("myenv", now=True) as venv:
    venv.install("numpy")

    # Virtual environment is activated here
    import numpy as np
    array = np.array([1, 2, 3])

# Virtual environment is automatically deactivated here

@staticmethod
def discover_available_pythons() -> List[tuple[str, str]]

pythons = VirtualEnv.discover_available_pythons()
for version, path in pythons:
    print(f"Python {version}: {path}")

@staticmethod
def ensure_python(version: str) -> str

python_path = VirtualEnv.ensure_python("3.11")
print(f"Python 3.11 available at: {python_path}")

@staticmethod
def version() -> str

from angreal.integrations.venv import VirtualEnv

# Create virtual environment with Python 3.11
venv = VirtualEnv("/path/to/myenv", python="3.11")

# Check if it exists
if venv.exists:
    print("Virtual environment is ready")
    print(f"Python executable: {venv.python_executable}")

from angreal.integrations.venv import VirtualEnv

# Create venv with a list of packages
venv = VirtualEnv(
    "/path/to/myenv",
    python="3.11",
    requirements=["django", "pillow", "requests"]
)
venv.install_requirements()

# Or with a requirements file
venv = VirtualEnv(
    "/path/to/myenv",
    requirements="requirements.txt"
)
venv.install_requirements()

from angreal.integrations.venv import venv_required
import angreal

@angreal.command(name="analyze", about="Analyze data with pandas")
@venv_required(".venv", requirements=["pandas", "numpy"])
def analyze_command():
    """This command runs in an isolated virtual environment."""
    import pandas as pd
    import numpy as np

    # Your analysis code here
    data = pd.DataFrame(np.random.rand(100, 4))
    print(data.describe())

from angreal.integrations.venv import VirtualEnv

# Discover available Python versions
pythons = VirtualEnv.discover_available_pythons()
print("Available Python installations:")
for version, path in pythons:
    print(f"  {version}: {path}")

# Ensure Python 3.12 is available
python_path = VirtualEnv.ensure_python("3.12")
print(f"Python 3.12 ready at: {python_path}")

# Create environment with specific Python version
venv = VirtualEnv("myproject-venv", python="3.12")

from angreal.integrations.venv import VirtualEnv

# Create but don't activate immediately
venv = VirtualEnv("/path/to/env", now=False)

# Check and create if needed manually
if not venv.exists:
    venv._create()

# Install specific packages
venv.install(["flask", "sqlalchemy", "pytest"])

# Install from requirements file
venv.install("requirements.txt")

from angreal.integrations.venv import VirtualEnv
import sys

# Create and set up environment
venv = VirtualEnv("data-science-env", now=True)
venv.install(["numpy", "pandas", "matplotlib"])

print(f"Before activation - sys.prefix: {sys.prefix}")

# Activate the environment
venv.activate()
print(f"After activation - sys.prefix: {sys.prefix}")

# Now we can import the installed packages
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Do some work with the packages
data = pd.DataFrame(np.random.randn(100, 4), columns=['A', 'B', 'C', 'D'])
data.plot()

# Deactivate when done
venv.deactivate()
print(f"After deactivation - sys.prefix: {sys.prefix}")

# Using context manager for automatic cleanup
with VirtualEnv("analysis-env", now=True) as venv:
    venv.install("scikit-learn")

    # This import works because we're in the activated environment
    from sklearn.datasets import load_iris
    iris = load_iris()
    print(f"Loaded {len(iris.data)} samples")

# Environment is automatically deactivated here

from angreal.integrations.venv import VirtualEnv
import time

# Check UV version
print(f"Using UV version: {VirtualEnv.version()}")

# Time environment creation (typically <1 second)
start = time.time()
venv = VirtualEnv("fast-env", requirements=["requests"])
end = time.time()
print(f"Environment created in {end - start:.2f} seconds")

RuntimeError: UV installation failed

RuntimeError: Python 3.11 installed but not found

RuntimeError: Failed to install packages: network timeout

# Traditional approach
import subprocess
import sys

subprocess.run([sys.executable, "-m", "venv", "myenv"])
subprocess.run(["myenv/bin/pip", "install", "requests"])

# Angreal UV approach (much faster)
from angreal.integrations.venv import VirtualEnv

venv = VirtualEnv("myenv", requirements=["requests"])  # Done!

# Traditional virtualenv
import virtualenv

virtualenv.create_environment("myenv")

# Angreal UV approach
from angreal.integrations.venv import VirtualEnv

venv = VirtualEnv("myenv", python="3.11")

# This is handled automatically - shown for reference
from angreal import ensure_uv_installed, uv_version

# Ensure UV is available
ensure_uv_installed()

# Check version
version = uv_version()
print(f"UV version: {version}")