aws-bootstrap-g4dn 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

aws_bootstrap/cli.py

@@ -113,6 +113,12 @@ def main():
 @click.option("--no-setup", is_flag=True, default=False, help="Skip running the remote setup script.")
 @click.option("--dry-run", is_flag=True, default=False, help="Show what would be done without executing.")
 @click.option("--profile", default=None, help="AWS profile override (defaults to AWS_PROFILE env var).")
+@click.option(
+    "--python-version",
+    default=None,
+    help="Python version for the remote venv (e.g. 3.13, 3.14.2). Passed to uv during setup.",
+)
+@click.option("--ssh-port", default=22, show_default=True, type=int, help="SSH port on the remote instance.")
 def launch(
     instance_type,
     ami_filter,
@@ -125,6 +131,8 @@ def launch(
     no_setup,
     dry_run,
     profile,
+    python_version,
+    ssh_port,
 ):
     """Launch a GPU-accelerated EC2 instance."""
     config = LaunchConfig(
@@ -137,6 +145,8 @@ def launch(
         volume_size=volume_size,
         run_setup=not no_setup,
         dry_run=dry_run,
+        ssh_port=ssh_port,
+        python_version=python_version,
     )
     if ami_filter:
         config.ami_filter = ami_filter
@@ -163,7 +173,7 @@ def launch(
 
     # Step 3: Security group
     step(3, 6, "Ensuring security group...")
-    sg_id = ensure_security_group(ec2, config.security_group, config.tag_value)
+    sg_id = ensure_security_group(ec2, config.security_group, config.tag_value, ssh_port=config.ssh_port)
 
     pricing = "spot" if config.spot else "on-demand"
 
@@ -178,6 +188,10 @@ def launch(
         val("Volume", f"{config.volume_size} GB gp3")
         val("Region", config.region)
         val("Remote setup", "yes" if config.run_setup else "no")
+        if config.ssh_port != 22:
+            val("SSH port", str(config.ssh_port))
+        if config.python_version:
+            val("Python version", config.python_version)
         click.echo()
         click.secho("No resources launched (dry-run mode).", fg="yellow")
         return
@@ -202,9 +216,13 @@ def launch(
     # Step 6: SSH and remote setup
     step(6, 6, "Waiting for SSH access...")
     private_key = private_key_path(config.key_path)
-    if not wait_for_ssh(public_ip, config.ssh_user, config.key_path):
+    if not wait_for_ssh(public_ip, config.ssh_user, config.key_path, port=config.ssh_port):
         warn("SSH did not become available within the timeout.")
-        info(f"Instance is running — try connecting manually: ssh -i {private_key} {config.ssh_user}@{public_ip}")
+        port_flag = f" -p {config.ssh_port}" if config.ssh_port != 22 else ""
+        info(
+            f"Instance is running — try connecting manually:"
+            f" ssh -i {private_key}{port_flag} {config.ssh_user}@{public_ip}"
+        )
         return
 
     if config.run_setup:
@@ -212,7 +230,9 @@ def launch(
             warn(f"Setup script not found at {SETUP_SCRIPT}, skipping.")
         else:
             info("Running remote setup...")
-            if run_remote_setup(public_ip, config.ssh_user, config.key_path, SETUP_SCRIPT):
+            if run_remote_setup(
+                public_ip, config.ssh_user, config.key_path, SETUP_SCRIPT, config.python_version, port=config.ssh_port
+            ):
                 success("Remote setup completed successfully.")
             else:
                 warn("Remote setup failed. Instance is still running.")
@@ -224,6 +244,7 @@ def launch(
         user=config.ssh_user,
         key_path=config.key_path,
         alias_prefix=config.alias_prefix,
+        port=config.ssh_port,
     )
     success(f"Added SSH config alias: {alias}")
 
@@ -239,18 +260,27 @@ def launch(
     val("Pricing", pricing)
     val("SSH alias", alias)
 
+    port_flag = f" -p {config.ssh_port}" if config.ssh_port != 22 else ""
+
     click.echo()
     click.secho("  SSH:", fg="cyan")
-    click.secho(f"    ssh {alias}", bold=True)
-    info(f"or: ssh -i {private_key} {config.ssh_user}@{public_ip}")
+    click.secho(f"    ssh{port_flag} {alias}", bold=True)
+    info(f"or: ssh -i {private_key}{port_flag} {config.ssh_user}@{public_ip}")
 
     click.echo()
     click.secho("  Jupyter (via SSH tunnel):", fg="cyan")
-    click.secho(f"    ssh -NL 8888:localhost:8888 {alias}", bold=True)
-    info(f"or: ssh -i {private_key} -NL 8888:localhost:8888 {config.ssh_user}@{public_ip}")
+    click.secho(f"    ssh -NL 8888:localhost:8888{port_flag} {alias}", bold=True)
+    info(f"or: ssh -i {private_key} -NL 8888:localhost:8888{port_flag} {config.ssh_user}@{public_ip}")
     info("Then open: http://localhost:8888")
     info("Notebook: ~/gpu_smoke_test.ipynb (GPU smoke test)")
 
+    click.echo()
+    click.secho("  VSCode Remote SSH:", fg="cyan")
+    click.secho(
+        f"    code --folder-uri vscode-remote://ssh-remote+{alias}/home/{config.ssh_user}",
+        bold=True,
+    )
+
     click.echo()
     click.secho("  GPU Benchmark:", fg="cyan")
     click.secho(f"    ssh {alias} 'python ~/gpu_benchmark.py'", bold=True)
@@ -266,7 +296,14 @@ def launch(
 @click.option("--region", default="us-west-2", show_default=True, help="AWS region.")
 @click.option("--profile", default=None, help="AWS profile override.")
 @click.option("--gpu", is_flag=True, default=False, help="Query GPU info (CUDA, driver) via SSH.")
-def status(region, profile, gpu):
+@click.option(
+    "--instructions/--no-instructions",
+    "-I",
+    default=True,
+    show_default=True,
+    help="Show connection commands (SSH, Jupyter, VSCode) for each running instance.",
+)
+def status(region, profile, gpu, instructions):
     """Show running instances created by aws-bootstrap."""
     session = boto3.Session(profile_name=profile, region_name=region)
     ec2 = session.client("ec2")
@@ -305,11 +342,15 @@ def status(region, profile, gpu):
         if inst["PublicIp"]:
             val("    IP", inst["PublicIp"])
 
+        # Look up SSH config details once (used by --gpu and --with-instructions)
+        details = None
+        if (gpu or instructions) and state == "running" and inst["PublicIp"]:
+            details = get_ssh_host_details(inst["InstanceId"])
+
         # GPU info (opt-in, only for running instances with a public IP)
         if gpu and state == "running" and inst["PublicIp"]:
-            details = get_ssh_host_details(inst["InstanceId"])
             if details:
-                gpu_info = query_gpu_info(details.hostname, details.user, details.identity_file)
+                gpu_info = query_gpu_info(details.hostname, details.user, details.identity_file, port=details.port)
             else:
                 gpu_info = query_gpu_info(
                     inst["PublicIp"],
@@ -353,6 +394,29 @@ def status(region, profile, gpu):
                 val("    Est. cost", f"~${est_cost:.4f}")
 
         val("    Launched", str(inst["LaunchTime"]))
+
+        # Connection instructions (opt-in, only for running instances with a public IP and alias)
+        if instructions and state == "running" and inst["PublicIp"] and alias:
+            user = details.user if details else "ubuntu"
+            port = details.port if details else 22
+            port_flag = f" -p {port}" if port != 22 else ""
+
+            click.echo()
+            click.secho("    SSH:", fg="cyan")
+            click.secho(f"      ssh{port_flag} {alias}", bold=True)
+
+            click.secho("    Jupyter (via SSH tunnel):", fg="cyan")
+            click.secho(f"      ssh -NL 8888:localhost:8888{port_flag} {alias}", bold=True)
+
+            click.secho("    VSCode Remote SSH:", fg="cyan")
+            click.secho(
+                f"      code --folder-uri vscode-remote://ssh-remote+{alias}/home/{user}",
+                bold=True,
+            )
+
+            click.secho("    GPU Benchmark:", fg="cyan")
+            click.secho(f"      ssh {alias} 'python ~/gpu_benchmark.py'", bold=True)
+
     click.echo()
     first_id = instances[0]["InstanceId"]
     click.echo("  To terminate:  " + click.style(f"aws-bootstrap terminate {first_id}", bold=True))

aws_bootstrap/config.py

@@ -22,3 +22,5 @@ class LaunchConfig:
     ssh_user: str = "ubuntu"
     tag_value: str = "aws-bootstrap-g4dn"
     alias_prefix: str = "aws-gpu"
+    ssh_port: int = 22
+    python_version: str | None = None

aws_bootstrap/ec2.py

@@ -59,7 +59,7 @@ def get_latest_ami(ec2_client, ami_filter: str) -> dict:
     return images[0]
 
 
-def ensure_security_group(ec2_client, name: str, tag_value: str) -> str:
+def ensure_security_group(ec2_client, name: str, tag_value: str, ssh_port: int = 22) -> str:
     """Find or create a security group with SSH ingress in the default VPC."""
     # Find default VPC
     vpcs = ec2_client.describe_vpcs(Filters=[{"Name": "isDefault", "Values": ["true"]}])
@@ -103,8 +103,8 @@ def ensure_security_group(ec2_client, name: str, tag_value: str) -> str:
         IpPermissions=[
             {
                 "IpProtocol": "tcp",
-                "FromPort": 22,
-                "ToPort": 22,
+                "FromPort": ssh_port,
+                "ToPort": ssh_port,
                 "IpRanges": [{"CidrIp": "0.0.0.0/0", "Description": "SSH access"}],
             }
         ],

aws_bootstrap/gpu.py

@@ -0,0 +1,27 @@
+"""GPU architecture mapping and GPU info dataclass."""
+
+from __future__ import annotations
+from dataclasses import dataclass
+
+
+_GPU_ARCHITECTURES: dict[str, str] = {
+    "7.0": "Volta",
+    "7.5": "Turing",
+    "8.0": "Ampere",
+    "8.6": "Ampere",
+    "8.7": "Ampere",
+    "8.9": "Ada Lovelace",
+    "9.0": "Hopper",
+}
+
+
+@dataclass
+class GpuInfo:
+    """GPU information retrieved via nvidia-smi and nvcc."""
+
+    driver_version: str
+    cuda_driver_version: str  # max CUDA version supported by driver (from nvidia-smi)
+    cuda_toolkit_version: str | None  # actual CUDA toolkit installed (from nvcc), None if unavailable
+    gpu_name: str
+    compute_capability: str
+    architecture: str

aws_bootstrap/resources/remote_setup.sh

@@ -34,7 +34,13 @@ if ! command -v uv &>/dev/null; then
 fi
 export PATH="$HOME/.local/bin:$PATH"
 
-uv venv ~/venv
+if [ -n "${PYTHON_VERSION:-}" ]; then
+    echo "  Installing Python ${PYTHON_VERSION}..."
+    uv python install "$PYTHON_VERSION"
+    uv venv --python "$PYTHON_VERSION" ~/venv
+else
+    uv venv ~/venv
+fi
 
 # --- CUDA-aware PyTorch installation ---
 # Known PyTorch CUDA wheel tags (ascending order).

aws_bootstrap/ssh.py

@@ -12,6 +12,8 @@ from pathlib import Path
 
 import click
 
+from .gpu import _GPU_ARCHITECTURES, GpuInfo
+
 
 # ---------------------------------------------------------------------------
 # SSH config markers
@@ -72,17 +74,18 @@ def import_key_pair(ec2_client, key_name: str, key_path: Path) -> str:
     return key_name
 
 
-def wait_for_ssh(host: str, user: str, key_path: Path, retries: int = 30, delay: int = 10) -> bool:
+def wait_for_ssh(host: str, user: str, key_path: Path, retries: int = 30, delay: int = 10, port: int = 22) -> bool:
     """Wait for SSH to become available on the instance.
 
-    Tries a TCP connection to port 22 first, then an actual SSH command.
+    Tries a TCP connection to the SSH port first, then an actual SSH command.
     """
     base_opts = _ssh_opts(key_path)
+    port_opts = ["-p", str(port)] if port != 22 else []
 
     for attempt in range(1, retries + 1):
-        # First check if port 22 is open
+        # First check if the SSH port is open
         try:
-            sock = socket.create_connection((host, 22), timeout=5)
+            sock = socket.create_connection((host, port), timeout=5)
             sock.close()
         except (TimeoutError, ConnectionRefusedError, OSError):
             click.echo("  SSH not ready " + click.style(f"(attempt {attempt}/{retries})", dim=True) + ", waiting...")
@@ -90,11 +93,18 @@ def wait_for_ssh(host: str, user: str, key_path: Path, retries: int = 30, delay:
             continue
 
         # Port is open, try actual SSH
-        result = subprocess.run(
-            ["ssh", *base_opts, "-o", "ConnectTimeout=10", "-o", "BatchMode=yes", f"{user}@{host}", "echo ok"],
-            capture_output=True,
-            text=True,
-        )
+        cmd = [
+            "ssh",
+            *base_opts,
+            *port_opts,
+            "-o",
+            "ConnectTimeout=10",
+            "-o",
+            "BatchMode=yes",
+            f"{user}@{host}",
+            "echo ok",
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
         if result.returncode == 0:
             click.secho("  SSH connection established.", fg="green")
             return True
@@ -105,15 +115,19 @@ def wait_for_ssh(host: str, user: str, key_path: Path, retries: int = 30, delay:
     return False
 
 
-def run_remote_setup(host: str, user: str, key_path: Path, script_path: Path) -> bool:
+def run_remote_setup(
+    host: str, user: str, key_path: Path, script_path: Path, python_version: str | None = None, port: int = 22
+) -> bool:
     """SCP the setup script and requirements.txt to the instance and execute."""
     ssh_opts = _ssh_opts(key_path)
+    scp_port_opts = ["-P", str(port)] if port != 22 else []
+    ssh_port_opts = ["-p", str(port)] if port != 22 else []
     requirements_path = script_path.parent / "requirements.txt"
 
     # SCP the requirements file
     click.echo("  Uploading requirements.txt...")
     req_result = subprocess.run(
-        ["scp", *ssh_opts, str(requirements_path), f"{user}@{host}:/tmp/requirements.txt"],
+        ["scp", *ssh_opts, *scp_port_opts, str(requirements_path), f"{user}@{host}:/tmp/requirements.txt"],
         capture_output=True,
         text=True,
     )
@@ -125,7 +139,7 @@ def run_remote_setup(host: str, user: str, key_path: Path, script_path: Path) ->
     benchmark_path = script_path.parent / "gpu_benchmark.py"
     click.echo("  Uploading gpu_benchmark.py...")
     bench_result = subprocess.run(
-        ["scp", *ssh_opts, str(benchmark_path), f"{user}@{host}:/tmp/gpu_benchmark.py"],
+        ["scp", *ssh_opts, *scp_port_opts, str(benchmark_path), f"{user}@{host}:/tmp/gpu_benchmark.py"],
         capture_output=True,
         text=True,
     )
@@ -137,7 +151,7 @@ def run_remote_setup(host: str, user: str, key_path: Path, script_path: Path) ->
     notebook_path = script_path.parent / "gpu_smoke_test.ipynb"
     click.echo("  Uploading gpu_smoke_test.ipynb...")
     nb_result = subprocess.run(
-        ["scp", *ssh_opts, str(notebook_path), f"{user}@{host}:/tmp/gpu_smoke_test.ipynb"],
+        ["scp", *ssh_opts, *scp_port_opts, str(notebook_path), f"{user}@{host}:/tmp/gpu_smoke_test.ipynb"],
         capture_output=True,
         text=True,
     )
@@ -148,7 +162,7 @@ def run_remote_setup(host: str, user: str, key_path: Path, script_path: Path) ->
     # SCP the script
     click.echo("  Uploading remote_setup.sh...")
     scp_result = subprocess.run(
-        ["scp", *ssh_opts, str(script_path), f"{user}@{host}:/tmp/remote_setup.sh"],
+        ["scp", *ssh_opts, *scp_port_opts, str(script_path), f"{user}@{host}:/tmp/remote_setup.sh"],
         capture_output=True,
         text=True,
     )
@@ -156,10 +170,14 @@ def run_remote_setup(host: str, user: str, key_path: Path, script_path: Path) ->
         click.secho(f"  SCP failed: {scp_result.stderr}", fg="red", err=True)
         return False
 
-    # Execute the script
+    # Execute the script, passing PYTHON_VERSION as an inline env var if specified
     click.echo("  Running remote_setup.sh on instance...")
+    remote_cmd = "chmod +x /tmp/remote_setup.sh && "
+    if python_version:
+        remote_cmd += f"PYTHON_VERSION={python_version} "
+    remote_cmd += "/tmp/remote_setup.sh"
     ssh_result = subprocess.run(
-        ["ssh", *ssh_opts, f"{user}@{host}", "chmod +x /tmp/remote_setup.sh && /tmp/remote_setup.sh"],
+        ["ssh", *ssh_opts, *ssh_port_opts, f"{user}@{host}", remote_cmd],
         capture_output=False,
     )
     return ssh_result.returncode == 0
@@ -222,15 +240,17 @@ def _next_alias(content: str, prefix: str = "aws-gpu") -> str:
     return f"{prefix}{max_n + 1}"
 
 
-def _build_stanza(instance_id: str, alias: str, hostname: str, user: str, key_path: Path) -> str:
+def _build_stanza(instance_id: str, alias: str, hostname: str, user: str, key_path: Path, port: int = 22) -> str:
     """Build a complete SSH config stanza with markers."""
     priv_key = private_key_path(key_path)
+    port_line = f"    Port {port}\n" if port != 22 else ""
     return (
         f"{_BEGIN_MARKER.format(instance_id=instance_id)}\n"
         f"Host {alias}\n"
         f"    HostName {hostname}\n"
         f"    User {user}\n"
         f"    IdentityFile {priv_key}\n"
+        f"{port_line}"
         f"    StrictHostKeyChecking no\n"
         f"    UserKnownHostsFile /dev/null\n"
         f"{_END_MARKER.format(instance_id=instance_id)}\n"
@@ -244,6 +264,7 @@ def add_ssh_host(
     key_path: Path,
     config_path: Path | None = None,
     alias_prefix: str = "aws-gpu",
+    port: int = 22,
 ) -> str:
     """Add (or update) an SSH host stanza for *instance_id*.
 
@@ -257,7 +278,7 @@ def add_ssh_host(
     content = _remove_block(content, instance_id)
 
     alias = existing_alias or _next_alias(content, alias_prefix)
-    stanza = _build_stanza(instance_id, alias, hostname, user, key_path)
+    stanza = _build_stanza(instance_id, alias, hostname, user, key_path, port=port)
 
     # Ensure a blank line before our block if file has content
     if content and not content.endswith("\n\n") and not content.endswith("\n"):
@@ -317,21 +338,6 @@ def list_ssh_hosts(config_path: Path | None = None) -> dict[str, str]:
     return result
 
 
-# ---------------------------------------------------------------------------
-# GPU info via SSH
-# ---------------------------------------------------------------------------
-
-_GPU_ARCHITECTURES: dict[str, str] = {
-    "7.0": "Volta",
-    "7.5": "Turing",
-    "8.0": "Ampere",
-    "8.6": "Ampere",
-    "8.7": "Ampere",
-    "8.9": "Ada Lovelace",
-    "9.0": "Hopper",
-}
-
-
 @dataclass
 class SSHHostDetails:
     """Connection details parsed from an SSH config stanza."""
@@ -339,18 +345,7 @@ class SSHHostDetails:
     hostname: str
     user: str
     identity_file: Path
-
-
-@dataclass
-class GpuInfo:
-    """GPU information retrieved via nvidia-smi and nvcc."""
-
-    driver_version: str
-    cuda_driver_version: str  # max CUDA version supported by driver (from nvidia-smi)
-    cuda_toolkit_version: str | None  # actual CUDA toolkit installed (from nvcc), None if unavailable
-    gpu_name: str
-    compute_capability: str
-    architecture: str
+    port: int = 22
 
 
 def get_ssh_host_details(instance_id: str, config_path: Path | None = None) -> SSHHostDetails | None:
@@ -371,6 +366,7 @@ def get_ssh_host_details(instance_id: str, config_path: Path | None = None) -> S
     hostname: str | None = None
     user: str | None = None
     identity_file: str | None = None
+    port: int = 22
 
     for line in content.splitlines():
         if line == begin_marker:
@@ -378,7 +374,7 @@ def get_ssh_host_details(instance_id: str, config_path: Path | None = None) -> S
             continue
         if line == end_marker and in_block:
             if hostname and user and identity_file:
-                return SSHHostDetails(hostname=hostname, user=user, identity_file=Path(identity_file))
+                return SSHHostDetails(hostname=hostname, user=user, identity_file=Path(identity_file), port=port)
             return None
         if in_block:
             stripped = line.strip()
@@ -388,17 +384,20 @@ def get_ssh_host_details(instance_id: str, config_path: Path | None = None) -> S
                 user = stripped.removeprefix("User ").strip()
             elif stripped.startswith("IdentityFile "):
                 identity_file = stripped.removeprefix("IdentityFile ").strip()
+            elif stripped.startswith("Port "):
+                port = int(stripped.removeprefix("Port ").strip())
 
     return None
 
 
-def query_gpu_info(host: str, user: str, key_path: Path, timeout: int = 10) -> GpuInfo | None:
+def query_gpu_info(host: str, user: str, key_path: Path, timeout: int = 10, port: int = 22) -> GpuInfo | None:
     """SSH into a host and query GPU info via ``nvidia-smi``.
 
     Returns ``GpuInfo`` on success, or ``None`` if the SSH connection fails,
     ``nvidia-smi`` is unavailable, or the output is malformed.
     """
     ssh_opts = _ssh_opts(key_path)
+    port_opts = ["-p", str(port)] if port != 22 else []
     remote_cmd = (
         "nvidia-smi --query-gpu=driver_version,name,compute_cap --format=csv,noheader,nounits"
         " && nvidia-smi | grep -oP 'CUDA Version: \\K[\\d.]+'"
@@ -407,6 +406,7 @@ def query_gpu_info(host: str, user: str, key_path: Path, timeout: int = 10) -> G
     cmd = [
         "ssh",
         *ssh_opts,
+        *port_opts,
         "-o",
         f"ConnectTimeout={timeout}",
         "-o",

aws_bootstrap/tests/test_cli.py

@@ -9,7 +9,8 @@ import botocore.exceptions
 from click.testing import CliRunner
 
 from aws_bootstrap.cli import main
-from aws_bootstrap.ssh import GpuInfo, SSHHostDetails
+from aws_bootstrap.gpu import GpuInfo
+from aws_bootstrap.ssh import SSHHostDetails
 
 
 def test_help():
@@ -73,11 +74,12 @@ def test_status_no_instances(mock_find, mock_session):
     assert "No active" in result.output
 
 
+@patch("aws_bootstrap.cli.get_ssh_host_details", return_value=None)
 @patch("aws_bootstrap.cli.list_ssh_hosts", return_value={})
 @patch("aws_bootstrap.cli.boto3.Session")
 @patch("aws_bootstrap.cli.get_spot_price")
 @patch("aws_bootstrap.cli.find_tagged_instances")
-def test_status_shows_instances(mock_find, mock_spot_price, mock_session, mock_ssh_hosts):
+def test_status_shows_instances(mock_find, mock_spot_price, mock_session, mock_ssh_hosts, mock_details):
     mock_find.return_value = [
         {
             "InstanceId": "i-abc123",
@@ -101,11 +103,12 @@ def test_status_shows_instances(mock_find, mock_spot_price, mock_session, mock_s
     assert "Est. cost" in result.output
 
 
+@patch("aws_bootstrap.cli.get_ssh_host_details", return_value=None)
 @patch("aws_bootstrap.cli.list_ssh_hosts", return_value={})
 @patch("aws_bootstrap.cli.boto3.Session")
 @patch("aws_bootstrap.cli.get_spot_price")
 @patch("aws_bootstrap.cli.find_tagged_instances")
-def test_status_on_demand_no_cost(mock_find, mock_spot_price, mock_session, mock_ssh_hosts):
+def test_status_on_demand_no_cost(mock_find, mock_spot_price, mock_session, mock_ssh_hosts, mock_details):
     mock_find.return_value = [
         {
             "InstanceId": "i-ondemand",
@@ -351,11 +354,12 @@ def test_terminate_removes_ssh_config(mock_terminate, mock_find, mock_session, m
     mock_remove_ssh.assert_called_once_with("i-abc123")
 
 
+@patch("aws_bootstrap.cli.get_ssh_host_details", return_value=None)
 @patch("aws_bootstrap.cli.list_ssh_hosts")
 @patch("aws_bootstrap.cli.boto3.Session")
 @patch("aws_bootstrap.cli.get_spot_price")
 @patch("aws_bootstrap.cli.find_tagged_instances")
-def test_status_shows_alias(mock_find, mock_spot_price, mock_session, mock_ssh_hosts):
+def test_status_shows_alias(mock_find, mock_spot_price, mock_session, mock_ssh_hosts, mock_details):
     mock_find.return_value = [
         {
             "InstanceId": "i-abc123",
@@ -376,11 +380,12 @@ def test_status_shows_alias(mock_find, mock_spot_price, mock_session, mock_ssh_h
     assert "aws-gpu1" in result.output
 
 
+@patch("aws_bootstrap.cli.get_ssh_host_details", return_value=None)
 @patch("aws_bootstrap.cli.list_ssh_hosts", return_value={})
 @patch("aws_bootstrap.cli.boto3.Session")
 @patch("aws_bootstrap.cli.get_spot_price")
 @patch("aws_bootstrap.cli.find_tagged_instances")
-def test_status_no_alias_graceful(mock_find, mock_spot_price, mock_session, mock_ssh_hosts):
+def test_status_no_alias_graceful(mock_find, mock_spot_price, mock_session, mock_ssh_hosts, mock_details):
     mock_find.return_value = [
         {
             "InstanceId": "i-old999",
@@ -520,13 +525,98 @@ def test_status_gpu_skips_non_running(mock_find, mock_session, mock_ssh_hosts, m
 @patch("aws_bootstrap.cli.boto3.Session")
 @patch("aws_bootstrap.cli.get_spot_price", return_value=0.15)
 @patch("aws_bootstrap.cli.find_tagged_instances")
-def test_status_without_gpu_flag_no_ssh(mock_find, mock_spot, mock_session, mock_ssh_hosts, mock_details, mock_gpu):
+def test_status_without_gpu_flag_no_gpu_query(
+    mock_find, mock_spot, mock_session, mock_ssh_hosts, mock_details, mock_gpu
+):
     mock_find.return_value = [_RUNNING_INSTANCE]
     runner = CliRunner()
     result = runner.invoke(main, ["status"])
     assert result.exit_code == 0
     mock_gpu.assert_not_called()
-    mock_details.assert_not_called()
+
+
+# ---------------------------------------------------------------------------
+# --instructions / --no-instructions / -I flag tests
+# ---------------------------------------------------------------------------
+
+
+def test_status_help_shows_instructions_flag():
+    runner = CliRunner()
+    result = runner.invoke(main, ["status", "--help"])
+    assert result.exit_code == 0
+    assert "--instructions" in result.output
+    assert "--no-instructions" in result.output
+    assert "-I" in result.output
+
+
+@patch("aws_bootstrap.cli.get_ssh_host_details")
+@patch("aws_bootstrap.cli.list_ssh_hosts", return_value={"i-abc123": "aws-gpu1"})
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_spot_price", return_value=0.15)
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_status_instructions_shown_by_default(mock_find, mock_spot, mock_session, mock_ssh_hosts, mock_details):
+    """Instructions are shown by default (no flag needed)."""
+    mock_find.return_value = [_RUNNING_INSTANCE]
+    mock_details.return_value = SSHHostDetails(
+        hostname="1.2.3.4", user="ubuntu", identity_file=Path("/home/user/.ssh/id_ed25519")
+    )
+    runner = CliRunner()
+    result = runner.invoke(main, ["status"])
+    assert result.exit_code == 0
+    assert "ssh aws-gpu1" in result.output
+    assert "ssh -NL 8888:localhost:8888 aws-gpu1" in result.output
+    assert "vscode-remote://ssh-remote+aws-gpu1/home/ubuntu" in result.output
+    assert "python ~/gpu_benchmark.py" in result.output
+
+
+@patch("aws_bootstrap.cli.get_ssh_host_details")
+@patch("aws_bootstrap.cli.list_ssh_hosts", return_value={"i-abc123": "aws-gpu1"})
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_spot_price", return_value=0.15)
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_status_no_instructions_suppresses_commands(mock_find, mock_spot, mock_session, mock_ssh_hosts, mock_details):
+    """--no-instructions suppresses connection commands."""
+    mock_find.return_value = [_RUNNING_INSTANCE]
+    mock_details.return_value = SSHHostDetails(
+        hostname="1.2.3.4", user="ubuntu", identity_file=Path("/home/user/.ssh/id_ed25519")
+    )
+    runner = CliRunner()
+    result = runner.invoke(main, ["status", "--no-instructions"])
+    assert result.exit_code == 0
+    assert "vscode-remote" not in result.output
+    assert "Jupyter" not in result.output
+
+
+@patch("aws_bootstrap.cli.get_ssh_host_details")
+@patch("aws_bootstrap.cli.list_ssh_hosts", return_value={})
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_spot_price", return_value=0.15)
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_status_instructions_no_alias_skips(mock_find, mock_spot, mock_session, mock_ssh_hosts, mock_details):
+    """Instances without an SSH alias don't get connection instructions."""
+    mock_find.return_value = [_RUNNING_INSTANCE]
+    runner = CliRunner()
+    result = runner.invoke(main, ["status"])
+    assert result.exit_code == 0
+    assert "ssh aws-gpu" not in result.output
+    assert "vscode-remote" not in result.output
+
+
+@patch("aws_bootstrap.cli.get_ssh_host_details")
+@patch("aws_bootstrap.cli.list_ssh_hosts", return_value={"i-abc123": "aws-gpu1"})
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_spot_price", return_value=0.15)
+@patch("aws_bootstrap.cli.find_tagged_instances")
+def test_status_instructions_non_default_port(mock_find, mock_spot, mock_session, mock_ssh_hosts, mock_details):
+    mock_find.return_value = [_RUNNING_INSTANCE]
+    mock_details.return_value = SSHHostDetails(
+        hostname="1.2.3.4", user="ubuntu", identity_file=Path("/home/user/.ssh/id_ed25519"), port=2222
+    )
+    runner = CliRunner()
+    result = runner.invoke(main, ["status"])
+    assert result.exit_code == 0
+    assert "ssh -p 2222 aws-gpu1" in result.output
+    assert "ssh -NL 8888:localhost:8888 -p 2222 aws-gpu1" in result.output
 
 
 # ---------------------------------------------------------------------------
@@ -636,3 +726,111 @@ def test_no_credentials_caught_on_list(mock_session, mock_list):
     result = runner.invoke(main, ["list", "instance-types"])
     assert result.exit_code != 0
     assert "Unable to locate AWS credentials" in result.output
+
+
+# ---------------------------------------------------------------------------
+# --python-version tests
+# ---------------------------------------------------------------------------
+
+
+@patch("aws_bootstrap.cli.add_ssh_host", return_value="aws-gpu1")
+@patch("aws_bootstrap.cli.run_remote_setup", return_value=True)
+@patch("aws_bootstrap.cli.wait_for_ssh", return_value=True)
+@patch("aws_bootstrap.cli.wait_instance_ready")
+@patch("aws_bootstrap.cli.launch_instance")
+@patch("aws_bootstrap.cli.ensure_security_group", return_value="sg-123")
+@patch("aws_bootstrap.cli.import_key_pair", return_value="aws-bootstrap-key")
+@patch("aws_bootstrap.cli.get_latest_ami")
+@patch("aws_bootstrap.cli.boto3.Session")
+def test_launch_python_version_passed_to_setup(
+    mock_session, mock_ami, mock_import, mock_sg, mock_launch, mock_wait, mock_ssh, mock_setup, mock_add_ssh, tmp_path
+):
+    mock_ami.return_value = {"ImageId": "ami-123", "Name": "TestAMI"}
+    mock_launch.return_value = {"InstanceId": "i-test123"}
+    mock_wait.return_value = {"PublicIpAddress": "1.2.3.4"}
+
+    key_path = tmp_path / "id_ed25519.pub"
+    key_path.write_text("ssh-ed25519 AAAA test@host")
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["launch", "--key-path", str(key_path), "--python-version", "3.13"])
+    assert result.exit_code == 0
+    mock_setup.assert_called_once()
+    assert mock_setup.call_args[0][4] == "3.13"
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_latest_ami")
+@patch("aws_bootstrap.cli.import_key_pair", return_value="aws-bootstrap-key")
+@patch("aws_bootstrap.cli.ensure_security_group", return_value="sg-123")
+def test_launch_dry_run_shows_python_version(mock_sg, mock_import, mock_ami, mock_session, tmp_path):
+    mock_ami.return_value = {"ImageId": "ami-123", "Name": "TestAMI"}
+
+    key_path = tmp_path / "id_ed25519.pub"
+    key_path.write_text("ssh-ed25519 AAAA test@host")
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["launch", "--key-path", str(key_path), "--dry-run", "--python-version", "3.14.2"])
+    assert result.exit_code == 0
+    assert "3.14.2" in result.output
+    assert "Python version" in result.output
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_latest_ami")
+@patch("aws_bootstrap.cli.import_key_pair", return_value="aws-bootstrap-key")
+@patch("aws_bootstrap.cli.ensure_security_group", return_value="sg-123")
+def test_launch_dry_run_omits_python_version_when_unset(mock_sg, mock_import, mock_ami, mock_session, tmp_path):
+    mock_ami.return_value = {"ImageId": "ami-123", "Name": "TestAMI"}
+
+    key_path = tmp_path / "id_ed25519.pub"
+    key_path.write_text("ssh-ed25519 AAAA test@host")
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["launch", "--key-path", str(key_path), "--dry-run"])
+    assert result.exit_code == 0
+    assert "Python version" not in result.output
+
+
+# ---------------------------------------------------------------------------
+# --ssh-port tests
+# ---------------------------------------------------------------------------
+
+
+def test_launch_help_shows_ssh_port():
+    runner = CliRunner()
+    result = runner.invoke(main, ["launch", "--help"])
+    assert result.exit_code == 0
+    assert "--ssh-port" in result.output
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_latest_ami")
+@patch("aws_bootstrap.cli.import_key_pair", return_value="aws-bootstrap-key")
+@patch("aws_bootstrap.cli.ensure_security_group", return_value="sg-123")
+def test_launch_dry_run_shows_ssh_port_when_non_default(mock_sg, mock_import, mock_ami, mock_session, tmp_path):
+    mock_ami.return_value = {"ImageId": "ami-123", "Name": "TestAMI"}
+
+    key_path = tmp_path / "id_ed25519.pub"
+    key_path.write_text("ssh-ed25519 AAAA test@host")
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["launch", "--key-path", str(key_path), "--dry-run", "--ssh-port", "2222"])
+    assert result.exit_code == 0
+    assert "2222" in result.output
+
+
+@patch("aws_bootstrap.cli.boto3.Session")
+@patch("aws_bootstrap.cli.get_latest_ami")
+@patch("aws_bootstrap.cli.import_key_pair", return_value="aws-bootstrap-key")
+@patch("aws_bootstrap.cli.ensure_security_group", return_value="sg-123")
+def test_launch_dry_run_omits_ssh_port_when_default(mock_sg, mock_import, mock_ami, mock_session, tmp_path):
+    mock_ami.return_value = {"ImageId": "ami-123", "Name": "TestAMI"}
+
+    key_path = tmp_path / "id_ed25519.pub"
+    key_path.write_text("ssh-ed25519 AAAA test@host")
+
+    runner = CliRunner()
+    result = runner.invoke(main, ["launch", "--key-path", str(key_path), "--dry-run"])
+    assert result.exit_code == 0
+    assert "SSH port" not in result.output

aws_bootstrap/tests/test_gpu.py

@@ -0,0 +1,98 @@
+"""Tests for GPU info queries via SSH (query_gpu_info, GPU architecture mapping)."""
+
+from __future__ import annotations
+import subprocess
+from pathlib import Path
+from unittest.mock import patch
+
+from aws_bootstrap.gpu import _GPU_ARCHITECTURES, GpuInfo
+from aws_bootstrap.ssh import query_gpu_info
+
+
+# ---------------------------------------------------------------------------
+# query_gpu_info
+# ---------------------------------------------------------------------------
+
+NVIDIA_SMI_OUTPUT = "560.35.03, Tesla T4, 7.5\n12.8\n12.6\n"
+
+
+@patch("aws_bootstrap.ssh.subprocess.run")
+def test_query_gpu_info_success(mock_run):
+    """Successful nvidia-smi + nvcc output returns a valid GpuInfo."""
+    mock_run.return_value = subprocess.CompletedProcess(args=[], returncode=0, stdout=NVIDIA_SMI_OUTPUT, stderr="")
+
+    info = query_gpu_info("1.2.3.4", "ubuntu", Path("/home/user/.ssh/id_ed25519"))
+    assert info is not None
+    assert isinstance(info, GpuInfo)
+    assert info.driver_version == "560.35.03"
+    assert info.cuda_driver_version == "12.8"
+    assert info.cuda_toolkit_version == "12.6"
+    assert info.gpu_name == "Tesla T4"
+    assert info.compute_capability == "7.5"
+    assert info.architecture == "Turing"
+
+
+@patch("aws_bootstrap.ssh.subprocess.run")
+def test_query_gpu_info_no_nvcc(mock_run):
+    """When nvcc is unavailable, cuda_toolkit_version is None."""
+    output = "560.35.03, Tesla T4, 7.5\n12.8\nN/A\n"
+    mock_run.return_value = subprocess.CompletedProcess(args=[], returncode=0, stdout=output, stderr="")
+
+    info = query_gpu_info("1.2.3.4", "ubuntu", Path("/home/user/.ssh/id_ed25519"))
+    assert info is not None
+    assert info.cuda_driver_version == "12.8"
+    assert info.cuda_toolkit_version is None
+
+
+@patch("aws_bootstrap.ssh.subprocess.run")
+def test_query_gpu_info_ssh_failure(mock_run):
+    """Non-zero exit code returns None."""
+    mock_run.return_value = subprocess.CompletedProcess(args=[], returncode=255, stdout="", stderr="Connection refused")
+
+    info = query_gpu_info("1.2.3.4", "ubuntu", Path("/home/user/.ssh/id_ed25519"))
+    assert info is None
+
+
+@patch("aws_bootstrap.ssh.subprocess.run", side_effect=subprocess.TimeoutExpired(cmd="ssh", timeout=15))
+def test_query_gpu_info_timeout(mock_run):
+    """TimeoutExpired returns None."""
+    info = query_gpu_info("1.2.3.4", "ubuntu", Path("/home/user/.ssh/id_ed25519"))
+    assert info is None
+
+
+@patch("aws_bootstrap.ssh.subprocess.run")
+def test_query_gpu_info_malformed_output(mock_run):
+    """Garbage output returns None."""
+    mock_run.return_value = subprocess.CompletedProcess(
+        args=[], returncode=0, stdout="not valid gpu output\n", stderr=""
+    )
+
+    info = query_gpu_info("1.2.3.4", "ubuntu", Path("/home/user/.ssh/id_ed25519"))
+    assert info is None
+
+
+# ---------------------------------------------------------------------------
+# GPU architecture mapping
+# ---------------------------------------------------------------------------
+
+
+def test_gpu_architecture_mapping():
+    """Known compute capabilities map to correct architecture names."""
+    assert _GPU_ARCHITECTURES["7.5"] == "Turing"
+    assert _GPU_ARCHITECTURES["8.0"] == "Ampere"
+    assert _GPU_ARCHITECTURES["8.6"] == "Ampere"
+    assert _GPU_ARCHITECTURES["8.9"] == "Ada Lovelace"
+    assert _GPU_ARCHITECTURES["9.0"] == "Hopper"
+    assert _GPU_ARCHITECTURES["7.0"] == "Volta"
+
+
+@patch("aws_bootstrap.ssh.subprocess.run")
+def test_query_gpu_info_unknown_architecture(mock_run):
+    """Unknown compute capability produces a fallback architecture string."""
+    mock_run.return_value = subprocess.CompletedProcess(
+        args=[], returncode=0, stdout="550.00.00, Future GPU, 10.0\n13.0\n13.0\n", stderr=""
+    )
+
+    info = query_gpu_info("1.2.3.4", "ubuntu", Path("/home/user/.ssh/id_ed25519"))
+    assert info is not None
+    assert info.architecture == "Unknown (10.0)"

aws_bootstrap/tests/test_ssh_config.py

@@ -10,6 +10,7 @@ from aws_bootstrap.ssh import (
     _read_ssh_config,
     add_ssh_host,
     find_ssh_alias,
+    get_ssh_host_details,
     list_ssh_hosts,
     remove_ssh_host,
 )
@@ -295,3 +296,38 @@ def test_list_hosts_nonexistent_file(tmp_path):
 def test_remove_nonexistent_file(tmp_path):
     cfg = tmp_path / "no_such_file"
     assert remove_ssh_host("i-abc123", config_path=cfg) is None
+
+
+# ---------------------------------------------------------------------------
+# Port in stanza / details
+# ---------------------------------------------------------------------------
+
+
+def test_stanza_includes_port_when_non_default(tmp_path):
+    cfg = _config_path(tmp_path)
+    add_ssh_host("i-abc123", "1.2.3.4", "ubuntu", KEY_PATH, config_path=cfg, port=2222)
+    content = cfg.read_text()
+    assert "Port 2222" in content
+
+
+def test_stanza_omits_port_when_default(tmp_path):
+    cfg = _config_path(tmp_path)
+    add_ssh_host("i-abc123", "1.2.3.4", "ubuntu", KEY_PATH, config_path=cfg)
+    content = cfg.read_text()
+    assert "Port" not in content
+
+
+def test_get_ssh_host_details_parses_port(tmp_path):
+    cfg = _config_path(tmp_path)
+    add_ssh_host("i-abc123", "1.2.3.4", "ubuntu", KEY_PATH, config_path=cfg, port=2222)
+    details = get_ssh_host_details("i-abc123", config_path=cfg)
+    assert details is not None
+    assert details.port == 2222
+
+
+def test_get_ssh_host_details_default_port(tmp_path):
+    cfg = _config_path(tmp_path)
+    add_ssh_host("i-abc123", "1.2.3.4", "ubuntu", KEY_PATH, config_path=cfg)
+    details = get_ssh_host_details("i-abc123", config_path=cfg)
+    assert details is not None
+    assert details.port == 22

aws_bootstrap/tests/test_ssh_gpu.py

@@ -1,16 +1,11 @@
-"""Tests for GPU info queries via SSH (get_ssh_host_details, query_gpu_info)."""
+"""Tests for get_ssh_host_details (SSH config parsing)."""
 
 from __future__ import annotations
-import subprocess
 from pathlib import Path
-from unittest.mock import patch
 
 from aws_bootstrap.ssh import (
-    _GPU_ARCHITECTURES,
-    GpuInfo,
     add_ssh_host,
     get_ssh_host_details,
-    query_gpu_info,
 )
 
 
@@ -47,92 +42,3 @@ def test_get_ssh_host_details_nonexistent_file(tmp_path):
     """Returns None when the SSH config file doesn't exist."""
     cfg = tmp_path / "no_such_file"
     assert get_ssh_host_details("i-abc123", config_path=cfg) is None
-
-
-# ---------------------------------------------------------------------------
-# query_gpu_info
-# ---------------------------------------------------------------------------
-
-NVIDIA_SMI_OUTPUT = "560.35.03, Tesla T4, 7.5\n12.8\n12.6\n"
-
-
-@patch("aws_bootstrap.ssh.subprocess.run")
-def test_query_gpu_info_success(mock_run):
-    """Successful nvidia-smi + nvcc output returns a valid GpuInfo."""
-    mock_run.return_value = subprocess.CompletedProcess(args=[], returncode=0, stdout=NVIDIA_SMI_OUTPUT, stderr="")
-
-    info = query_gpu_info("1.2.3.4", "ubuntu", Path("/home/user/.ssh/id_ed25519"))
-    assert info is not None
-    assert isinstance(info, GpuInfo)
-    assert info.driver_version == "560.35.03"
-    assert info.cuda_driver_version == "12.8"
-    assert info.cuda_toolkit_version == "12.6"
-    assert info.gpu_name == "Tesla T4"
-    assert info.compute_capability == "7.5"
-    assert info.architecture == "Turing"
-
-
-@patch("aws_bootstrap.ssh.subprocess.run")
-def test_query_gpu_info_no_nvcc(mock_run):
-    """When nvcc is unavailable, cuda_toolkit_version is None."""
-    output = "560.35.03, Tesla T4, 7.5\n12.8\nN/A\n"
-    mock_run.return_value = subprocess.CompletedProcess(args=[], returncode=0, stdout=output, stderr="")
-
-    info = query_gpu_info("1.2.3.4", "ubuntu", Path("/home/user/.ssh/id_ed25519"))
-    assert info is not None
-    assert info.cuda_driver_version == "12.8"
-    assert info.cuda_toolkit_version is None
-
-
-@patch("aws_bootstrap.ssh.subprocess.run")
-def test_query_gpu_info_ssh_failure(mock_run):
-    """Non-zero exit code returns None."""
-    mock_run.return_value = subprocess.CompletedProcess(args=[], returncode=255, stdout="", stderr="Connection refused")
-
-    info = query_gpu_info("1.2.3.4", "ubuntu", Path("/home/user/.ssh/id_ed25519"))
-    assert info is None
-
-
-@patch("aws_bootstrap.ssh.subprocess.run", side_effect=subprocess.TimeoutExpired(cmd="ssh", timeout=15))
-def test_query_gpu_info_timeout(mock_run):
-    """TimeoutExpired returns None."""
-    info = query_gpu_info("1.2.3.4", "ubuntu", Path("/home/user/.ssh/id_ed25519"))
-    assert info is None
-
-
-@patch("aws_bootstrap.ssh.subprocess.run")
-def test_query_gpu_info_malformed_output(mock_run):
-    """Garbage output returns None."""
-    mock_run.return_value = subprocess.CompletedProcess(
-        args=[], returncode=0, stdout="not valid gpu output\n", stderr=""
-    )
-
-    info = query_gpu_info("1.2.3.4", "ubuntu", Path("/home/user/.ssh/id_ed25519"))
-    assert info is None
-
-
-# ---------------------------------------------------------------------------
-# GPU architecture mapping
-# ---------------------------------------------------------------------------
-
-
-def test_gpu_architecture_mapping():
-    """Known compute capabilities map to correct architecture names."""
-    assert _GPU_ARCHITECTURES["7.5"] == "Turing"
-    assert _GPU_ARCHITECTURES["8.0"] == "Ampere"
-    assert _GPU_ARCHITECTURES["8.6"] == "Ampere"
-    assert _GPU_ARCHITECTURES["8.9"] == "Ada Lovelace"
-    assert _GPU_ARCHITECTURES["9.0"] == "Hopper"
-    assert _GPU_ARCHITECTURES["7.0"] == "Volta"
-
-
-@patch("aws_bootstrap.ssh.subprocess.run")
-def test_query_gpu_info_unknown_architecture(mock_run):
-    """Unknown compute capability produces a fallback architecture string."""
-    mock_run.return_value = subprocess.CompletedProcess(
-        args=[], returncode=0, stdout="550.00.00, Future GPU, 10.0\n13.0\n13.0\n", stderr=""
-    )
-
-    info = query_gpu_info("1.2.3.4", "ubuntu", Path("/home/user/.ssh/id_ed25519"))
-    assert info is not None
-    assert info.architecture == "Unknown (10.0)"

{aws_bootstrap_g4dn-0.2.0.dist-info → aws_bootstrap_g4dn-0.3.0.dist-info}/METADATA

@@ -1,13 +1,16 @@
 Metadata-Version: 2.4
 Name: aws-bootstrap-g4dn
-Version: 0.2.0
+Version: 0.3.0
 Summary: Bootstrap AWS EC2 GPU instances for hybrid local-remote development
 Author: Adam Ever-Hadani
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/promptromp/aws-bootstrap-g4dn
 Project-URL: Issues, https://github.com/promptromp/aws-bootstrap-g4dn/issues
 Keywords: aws,ec2,gpu,cuda,deep-learning,spot-instances,cli
-Requires-Python: >=3.14
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: boto3>=1.35
@@ -55,7 +58,7 @@ ssh aws-gpu1                  # You're in, venv activated, PyTorch works
 
 1. AWS profile configured with relevant permissions (profile name can be passed via `--profile` or read from `AWS_PROFILE` env var)
 2. AWS CLI v2 — see [here](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
-3. Python 3.14+ and [uv](https://github.com/astral-sh/uv)
+3. Python 3.12+ and [uv](https://github.com/astral-sh/uv)
 4. An SSH key pair (see below)
 
 ## Installation
@@ -123,6 +126,12 @@ aws-bootstrap launch --on-demand --instance-type g5.xlarge --region us-east-1
 # Launch without running the remote setup script
 aws-bootstrap launch --no-setup
 
+# Use a specific Python version in the remote venv
+aws-bootstrap launch --python-version 3.13
+
+# Use a non-default SSH port
+aws-bootstrap launch --ssh-port 2222
+
 # Use a specific AWS profile
 aws-bootstrap launch --profile my-aws-profile
 ```
@@ -146,7 +155,7 @@ The setup script runs automatically on the instance after SSH becomes available:
 |------|------|
 | **GPU verify** | Confirms `nvidia-smi` and `nvcc` are working |
 | **Utilities** | Installs `htop`, `tmux`, `tree`, `jq` |
-| **Python venv** | Creates `~/venv` with `uv`, auto-activates in `~/.bashrc` |
+| **Python venv** | Creates `~/venv` with `uv`, auto-activates in `~/.bashrc`. Use `--python-version` to pin a specific Python (e.g. `3.13`) |
 | **CUDA-aware PyTorch** | Detects CUDA toolkit version → installs PyTorch from the matching `cu{TAG}` wheel index |
 | **CUDA smoke test** | Runs `torch.cuda.is_available()` + GPU matmul to verify the stack |
 | **GPU benchmark** | Copies `gpu_benchmark.py` to `~/gpu_benchmark.py` |
@@ -220,6 +229,9 @@ aws-bootstrap status
 # Include GPU info (CUDA toolkit + driver version, GPU name, architecture) via SSH
 aws-bootstrap status --gpu
 
+# Hide connection commands (shown by default for each running instance)
+aws-bootstrap status --no-instructions
+
 # List instances in a specific region
 aws-bootstrap status --region us-east-1
 

aws_bootstrap_g4dn-0.3.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+aws_bootstrap/__init__.py,sha256=kl_jvrunGyIyizdRqAP6ROb5P1BBrXX5PTq5gq1ipU0,82
+aws_bootstrap/cli.py,sha256=H7Lud1PWk0O5zKGf1StARCEahrMErickuHXsWk42j3A,20481
+aws_bootstrap/config.py,sha256=TeCOYDlijT-KD5SFIzc-VvBhOqcq9YCgen9NK63rka8,895
+aws_bootstrap/ec2.py,sha256=LHpzW91ayK45gsWV_B4LanSZIhWggqTsL31qHUceiaA,12274
+aws_bootstrap/gpu.py,sha256=WTnHR0s3mQHDlnzqRgqAC6omWz7nT5YtGpcs0Bf88jk,692
+aws_bootstrap/ssh.py,sha256=RK5Ahiwpol9-4MUvurKyNa1JorQW9VkkNtSSfPzryrU,17851
+aws_bootstrap/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aws_bootstrap/resources/gpu_benchmark.py,sha256=2uoss2bZGhg7c3D7Hg1-EJlOVDtzAH4co1ahSvF_lVU,29080
+aws_bootstrap/resources/gpu_smoke_test.ipynb,sha256=XvAOEIPa5H9ri5mRZqOdknmwOwKNvCME6DzBGuhRYfg,10698
+aws_bootstrap/resources/remote_setup.sh,sha256=n1joNO-6EizLsz2BPOPruFhe90kEQ9Np2SBhYXnOJRs,5648
+aws_bootstrap/resources/requirements.txt,sha256=gpYl1MFCfWXiAhbIUgAjuTHONz3MKci25msIyOkMmUk,75
+aws_bootstrap/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aws_bootstrap/tests/test_cli.py,sha256=vyoVVqSakC7Y2BCEFpyf2ghTUvT-QWBQC9-yvEFz3gw,32554
+aws_bootstrap/tests/test_config.py,sha256=arvET6KNl4Vqsz0zFrSdhciXGU688bfsvCr3dSpziN0,1050
+aws_bootstrap/tests/test_ec2.py,sha256=Jmqsjv973hxXbZWfGgECtm6aa2156Lzji227sYMBuMg,10547
+aws_bootstrap/tests/test_gpu.py,sha256=rbMuda_sIVbaCzkWXoLv9YIfnWztgRoP7NuVL8XHrUY,3871
+aws_bootstrap/tests/test_ssh_config.py,sha256=iQDd3hJ8to-2-QHW26Brtglfl0q0P6sCE6U_itxoNyY,11609
+aws_bootstrap/tests/test_ssh_gpu.py,sha256=dRp86Og-8GqiATSff3rxhu83mBZdGgqI4UOnoC00Ln0,1454
+aws_bootstrap_g4dn-0.3.0.dist-info/licenses/LICENSE,sha256=Hen77Mt8sazSQJ9DgrmZuAvDwo2vc5JAkR_avuFV-CM,1067
+aws_bootstrap_g4dn-0.3.0.dist-info/METADATA,sha256=tfsBYTSqVQf8A46P22qwdFsb_ur-Ge57hQfuDaj0mgE,12417
+aws_bootstrap_g4dn-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+aws_bootstrap_g4dn-0.3.0.dist-info/entry_points.txt,sha256=T8FXfOgmLEvFi8DHaFJ3tCzId9J3_d2Y6qT98OXxCjA,57
+aws_bootstrap_g4dn-0.3.0.dist-info/top_level.txt,sha256=mix9gZRs8JUv0OMSB_rwdGcRnTKzsKgHrE5fyAn5zJw,14
+aws_bootstrap_g4dn-0.3.0.dist-info/RECORD,,

aws_bootstrap_g4dn-0.2.0.dist-info/RECORD

@@ -1,22 +0,0 @@
-aws_bootstrap/__init__.py,sha256=kl_jvrunGyIyizdRqAP6ROb5P1BBrXX5PTq5gq1ipU0,82
-aws_bootstrap/cli.py,sha256=3PWGU4djqCvABNpLvYTk473Nmmmrad3JQ3iQtg5YmnE,17917
-aws_bootstrap/config.py,sha256=bOADtpujEacED0pu9m7D781UFlMhZrmtHQ7eqI6ySjk,834
-aws_bootstrap/ec2.py,sha256=-yEyGMCycY4ccsmbgqHnLK2FRFWX2kr7nLfYWXSKeaY,12242
-aws_bootstrap/ssh.py,sha256=-8F0PAkl7CCY1b9n46ZhWJ6faIMlSvA26BleeIp-rMA,17533
-aws_bootstrap/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aws_bootstrap/resources/gpu_benchmark.py,sha256=2uoss2bZGhg7c3D7Hg1-EJlOVDtzAH4co1ahSvF_lVU,29080
-aws_bootstrap/resources/gpu_smoke_test.ipynb,sha256=XvAOEIPa5H9ri5mRZqOdknmwOwKNvCME6DzBGuhRYfg,10698
-aws_bootstrap/resources/remote_setup.sh,sha256=FzpXEw-LvlXROi-PmO72yEyDWWi-3Tul6D7-vFDubXQ,5460
-aws_bootstrap/resources/requirements.txt,sha256=gpYl1MFCfWXiAhbIUgAjuTHONz3MKci25msIyOkMmUk,75
-aws_bootstrap/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aws_bootstrap/tests/test_cli.py,sha256=xGCC07aPZMc5pExo__qz7X1Tm2v9Z1Xn4K99JocESas,23627
-aws_bootstrap/tests/test_config.py,sha256=arvET6KNl4Vqsz0zFrSdhciXGU688bfsvCr3dSpziN0,1050
-aws_bootstrap/tests/test_ec2.py,sha256=Jmqsjv973hxXbZWfGgECtm6aa2156Lzji227sYMBuMg,10547
-aws_bootstrap/tests/test_ssh_config.py,sha256=Rt3e7B22d8kK0PzFgXB4gwpF4HvIseiqzcpouCwMo5M,10333
-aws_bootstrap/tests/test_ssh_gpu.py,sha256=W6GQzILCy_qPrvWQlCC8Ris-vuTzTGiyNXEyMzwD1kM,5154
-aws_bootstrap_g4dn-0.2.0.dist-info/licenses/LICENSE,sha256=Hen77Mt8sazSQJ9DgrmZuAvDwo2vc5JAkR_avuFV-CM,1067
-aws_bootstrap_g4dn-0.2.0.dist-info/METADATA,sha256=XqtBIr0EdnRvsy83usvZ5n-B9WNpfLCGoVaVR9_1eaI,11927
-aws_bootstrap_g4dn-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-aws_bootstrap_g4dn-0.2.0.dist-info/entry_points.txt,sha256=T8FXfOgmLEvFi8DHaFJ3tCzId9J3_d2Y6qT98OXxCjA,57
-aws_bootstrap_g4dn-0.2.0.dist-info/top_level.txt,sha256=mix9gZRs8JUv0OMSB_rwdGcRnTKzsKgHrE5fyAn5zJw,14
-aws_bootstrap_g4dn-0.2.0.dist-info/RECORD,,