Merge pull request #6 from ivyleavedtoadflax/issue-22-instance-pricing

ivyleavedtoadflax · web-flow · commit 2919e43d7b08 · 2026-01-18T00:04:10.000+01:00
feat: Add instance pricing to list command (#22)
diff --git a/remotepy/instance.py b/remotepy/instance.py
@@ -17,6 +17,7 @@
     ResourceNotFoundError,
     ValidationError,
 )
+from remotepy.pricing import format_price, get_instance_price, get_monthly_estimate
 from remotepy.utils import (
     get_ec2_client,
     get_instance_dns,
@@ -51,11 +52,20 @@ def _get_status_style(status: str) -> str:
 
 @app.command("ls")
 @app.command("list")
-def list_instances() -> None:
+def list_instances(
+    no_pricing: bool = typer.Option(
+        False, "--no-pricing", help="Skip pricing lookup (faster, no cost columns)"
+    ),
+) -> None:
     """
     List all EC2 instances.
 
-    Displays a table with instance name, ID, public DNS, status, type, and launch time.
+    Displays a table with instance name, ID, public DNS, status, type, launch time,
+    and pricing information (hourly and monthly estimates).
+
+    Examples:
+        remote list                # List with pricing
+        remote list --no-pricing   # List without pricing (faster)
     """
     instances = get_instances()
     ids = get_instance_ids(instances)
@@ -71,18 +81,31 @@ def list_instances() -> None:
     table.add_column("Type")
     table.add_column("Launch Time")
 
+    if not no_pricing:
+        table.add_column("$/hr", justify="right")
+        table.add_column("$/month", justify="right")
+
     for name, instance_id, dns, status, it, lt in zip(
         names, ids, public_dnss, statuses, instance_types, launch_times, strict=False
     ):
         status_style = _get_status_style(status)
-        table.add_row(
+
+        row_data = [
             name or "",
             instance_id or "",
             dns or "",
             f"[{status_style}]{status}[/{status_style}]",
             it or "",
             lt or "",
-        )
+        ]
+
+        if not no_pricing:
+            hourly_price = get_instance_price(it) if it else None
+            monthly_price = get_monthly_estimate(hourly_price)
+            row_data.append(format_price(hourly_price))
+            row_data.append(format_price(monthly_price))
+
+        table.add_row(*row_data)
 
     console.print(table)
 
diff --git a/remotepy/pricing.py b/remotepy/pricing.py
@@ -0,0 +1,190 @@
+"""AWS EC2 instance pricing functionality.
+
+This module provides functions to retrieve EC2 instance pricing information
+using the AWS Pricing API.
+"""
+
+import json
+from functools import lru_cache
+from typing import Any
+
+import boto3
+from botocore.exceptions import ClientError, NoCredentialsError
+
+# AWS region to location name mapping
+# The Pricing API uses location names, not region codes
+REGION_TO_LOCATION: dict[str, str] = {
+    "us-east-1": "US East (N. Virginia)",
+    "us-east-2": "US East (Ohio)",
+    "us-west-1": "US West (N. California)",
+    "us-west-2": "US West (Oregon)",
+    "eu-west-1": "Europe (Ireland)",
+    "eu-west-2": "Europe (London)",
+    "eu-west-3": "Europe (Paris)",
+    "eu-central-1": "Europe (Frankfurt)",
+    "eu-north-1": "Europe (Stockholm)",
+    "ap-northeast-1": "Asia Pacific (Tokyo)",
+    "ap-northeast-2": "Asia Pacific (Seoul)",
+    "ap-northeast-3": "Asia Pacific (Osaka)",
+    "ap-southeast-1": "Asia Pacific (Singapore)",
+    "ap-southeast-2": "Asia Pacific (Sydney)",
+    "ap-south-1": "Asia Pacific (Mumbai)",
+    "sa-east-1": "South America (Sao Paulo)",
+    "ca-central-1": "Canada (Central)",
+}
+
+# Hours per month (for calculating monthly estimates)
+HOURS_PER_MONTH = 730
+
+
+@lru_cache(maxsize=1)
+def get_pricing_client() -> Any:
+    """Get or create the Pricing client.
+
+    The Pricing API is only available in us-east-1 and ap-south-1.
+    We use us-east-1 for consistency.
+
+    Returns:
+        boto3 Pricing client instance
+    """
+    return boto3.client("pricing", region_name="us-east-1")
+
+
+def get_current_region() -> str:
+    """Get the current AWS region from the session.
+
+    Returns:
+        The current AWS region code
+    """
+    session = boto3.session.Session()
+    return session.region_name or "us-east-1"
+
+
+@lru_cache(maxsize=256)
+def get_instance_price(instance_type: str, region: str | None = None) -> float | None:
+    """Get the hourly on-demand price for an EC2 instance type.
+
+    Args:
+        instance_type: The EC2 instance type (e.g., 't3.micro', 'm5.large')
+        region: AWS region code. If None, uses the current session region.
+
+    Returns:
+        The hourly price in USD, or None if pricing is unavailable.
+
+    Note:
+        This function caches results to reduce API calls.
+        Prices are for Linux on-demand instances with shared tenancy.
+    """
+    if region is None:
+        region = get_current_region()
+
+    # Get location name for region
+    location = REGION_TO_LOCATION.get(region)
+    if not location:
+        # Region not in our mapping, return None
+        return None
+
+    try:
+        pricing_client = get_pricing_client()
+        response = pricing_client.get_products(
+            ServiceCode="AmazonEC2",
+            Filters=[
+                {"Type": "TERM_MATCH", "Field": "instanceType", "Value": instance_type},
+                {"Type": "TERM_MATCH", "Field": "location", "Value": location},
+                {"Type": "TERM_MATCH", "Field": "operatingSystem", "Value": "Linux"},
+                {"Type": "TERM_MATCH", "Field": "tenancy", "Value": "Shared"},
+                {"Type": "TERM_MATCH", "Field": "preInstalledSw", "Value": "NA"},
+                {"Type": "TERM_MATCH", "Field": "capacitystatus", "Value": "Used"},
+            ],
+            MaxResults=1,
+        )
+
+        price_list = response.get("PriceList", [])
+        if not price_list:
+            return None
+
+        # Parse the price from the response
+        price_data = json.loads(price_list[0])
+        terms = price_data.get("terms", {}).get("OnDemand", {})
+
+        if not terms:
+            return None
+
+        # Get the first term and its price dimension
+        for term in terms.values():
+            price_dimensions = term.get("priceDimensions", {})
+            for dimension in price_dimensions.values():
+                price_per_unit = dimension.get("pricePerUnit", {}).get("USD")
+                if price_per_unit:
+                    return float(price_per_unit)
+
+        return None
+
+    except ClientError:
+        # Don't raise an exception for pricing errors - just return None
+        # Pricing failures shouldn't block the main functionality
+        return None
+    except NoCredentialsError:
+        return None
+    except (json.JSONDecodeError, KeyError, ValueError, TypeError):
+        return None
+
+
+def get_monthly_estimate(hourly_price: float | None) -> float | None:
+    """Calculate monthly cost estimate from hourly price.
+
+    Args:
+        hourly_price: The hourly price in USD
+
+    Returns:
+        The estimated monthly cost in USD, or None if hourly_price is None
+    """
+    if hourly_price is None:
+        return None
+    return hourly_price * HOURS_PER_MONTH
+
+
+def format_price(price: float | None, prefix: str = "$") -> str:
+    """Format a price for display.
+
+    Args:
+        price: The price to format
+        prefix: Currency prefix (default: "$")
+
+    Returns:
+        Formatted price string, or "-" if price is None
+    """
+    if price is None:
+        return "-"
+    if price < 0.01:
+        return f"{prefix}{price:.4f}"
+    return f"{prefix}{price:.2f}"
+
+
+def get_instance_pricing_info(instance_type: str, region: str | None = None) -> dict[str, Any]:
+    """Get comprehensive pricing information for an instance type.
+
+    Args:
+        instance_type: The EC2 instance type
+        region: AWS region code. If None, uses the current session region.
+
+    Returns:
+        Dictionary with 'hourly', 'monthly', and formatted strings
+    """
+    hourly = get_instance_price(instance_type, region)
+    monthly = get_monthly_estimate(hourly)
+
+    return {
+        "hourly": hourly,
+        "monthly": monthly,
+        "hourly_formatted": format_price(hourly),
+        "monthly_formatted": format_price(monthly),
+    }
+
+
+def clear_price_cache() -> None:
+    """Clear the pricing cache.
+
+    Useful for testing or when you want to refresh pricing data.
+    """
+    get_instance_price.cache_clear()
diff --git a/specs/issue-22-instance-pricing.md b/specs/issue-22-instance-pricing.md
@@ -1,6 +1,6 @@
 # Issue 22: Add Instance Pricing
 
-**Status:** Not started
+**Status:** COMPLETED
 **Priority:** Low (v0.5.0)
 **GitHub Issue:** #32
 
@@ -58,8 +58,8 @@ db-server     i-0123456789abcdef1  running  r5.large  $0.126   $90.72
 
 ## Acceptance Criteria
 
-- [ ] Add pricing column to `remote list` output
-- [ ] Cache pricing data to reduce API calls
-- [ ] Handle missing/unavailable pricing gracefully
-- [ ] Add `--no-pricing` flag to skip pricing lookup
-- [ ] Add tests with mocked pricing responses
+- [x] Add pricing column to `remote list` output
+- [x] Cache pricing data to reduce API calls
+- [x] Handle missing/unavailable pricing gracefully
+- [x] Add `--no-pricing` flag to skip pricing lookup
+- [x] Add tests with mocked pricing responses
diff --git a/tests/test_instance.py b/tests/test_instance.py
@@ -36,7 +36,7 @@ def test_should_show_table_headers_when_no_instances_exist(self, mocker):
         mock_paginator.paginate.return_value = [{"Reservations": []}]
         mock_ec2_client.return_value.get_paginator.return_value = mock_paginator
 
-        result = runner.invoke(app, ["list"])
+        result = runner.invoke(app, ["list", "--no-pricing"])
 
         assert result.exit_code == 0
         assert "Name" in result.stdout
@@ -53,6 +53,10 @@ def test_should_display_instance_details_when_instances_exist(self, mocker, mock
         mock_paginator.paginate.return_value = [mock_ec2_instances]
         mock_ec2_client.return_value.get_paginator.return_value = mock_paginator
 
+        # Mock pricing to avoid actual API calls
+        mocker.patch("remotepy.instance.get_instance_price", return_value=0.0104)
+        mocker.patch("remotepy.instance.get_monthly_estimate", return_value=7.59)
+
         result = runner.invoke(app, ["list"])
 
         # Verify paginator was used
@@ -72,6 +76,81 @@ def test_should_display_instance_details_when_instances_exist(self, mocker, mock
         assert "t2.micro" in result.stdout
         assert "2023-07-15 00:00:00 UTC" in result.stdout
 
+    def test_should_show_pricing_columns_by_default(self, mocker):
+        """Should display pricing columns when --no-pricing is not specified."""
+        mock_ec2_client = mocker.patch("remotepy.utils.get_ec2_client")
+        mock_paginator = mocker.MagicMock()
+        mock_paginator.paginate.return_value = [{"Reservations": []}]
+        mock_ec2_client.return_value.get_paginator.return_value = mock_paginator
+
+        result = runner.invoke(app, ["list"])
+
+        assert result.exit_code == 0
+        assert "$/hr" in result.stdout
+        assert "$/month" in result.stdout
+
+    def test_should_hide_pricing_columns_with_no_pricing_flag(self, mocker):
+        """Should not display pricing columns when --no-pricing is specified."""
+        mock_ec2_client = mocker.patch("remotepy.utils.get_ec2_client")
+        mock_paginator = mocker.MagicMock()
+        mock_paginator.paginate.return_value = [{"Reservations": []}]
+        mock_ec2_client.return_value.get_paginator.return_value = mock_paginator
+
+        result = runner.invoke(app, ["list", "--no-pricing"])
+
+        assert result.exit_code == 0
+        assert "$/hr" not in result.stdout
+        assert "$/month" not in result.stdout
+
+    def test_should_display_pricing_data_for_instances(self, mocker, mock_ec2_instances):
+        """Should show pricing information for each instance type."""
+        mock_ec2_client = mocker.patch("remotepy.utils.get_ec2_client")
+        mock_paginator = mocker.MagicMock()
+        mock_paginator.paginate.return_value = [mock_ec2_instances]
+        mock_ec2_client.return_value.get_paginator.return_value = mock_paginator
+
+        # Mock pricing functions
+        mocker.patch("remotepy.instance.get_instance_price", return_value=0.0104)
+        mocker.patch("remotepy.instance.get_monthly_estimate", return_value=7.59)
+
+        result = runner.invoke(app, ["list"])
+
+        assert result.exit_code == 0
+        # format_price formats 0.0104 as "$0.01" since it's >= 0.01 (uses 2 decimal places)
+        assert "$0.01" in result.stdout
+        assert "$7.59" in result.stdout
+
+    def test_should_handle_unavailable_pricing_gracefully(self, mocker, mock_ec2_instances):
+        """Should display dash when pricing is unavailable."""
+        mock_ec2_client = mocker.patch("remotepy.utils.get_ec2_client")
+        mock_paginator = mocker.MagicMock()
+        mock_paginator.paginate.return_value = [mock_ec2_instances]
+        mock_ec2_client.return_value.get_paginator.return_value = mock_paginator
+
+        # Mock pricing to return None (unavailable)
+        mocker.patch("remotepy.instance.get_instance_price", return_value=None)
+        mocker.patch("remotepy.instance.get_monthly_estimate", return_value=None)
+
+        result = runner.invoke(app, ["list"])
+
+        assert result.exit_code == 0
+        # format_price returns "-" for None values
+        assert "-" in result.stdout
+
+    def test_should_not_call_pricing_api_with_no_pricing_flag(self, mocker, mock_ec2_instances):
+        """Should skip pricing API calls when --no-pricing flag is used."""
+        mock_ec2_client = mocker.patch("remotepy.utils.get_ec2_client")
+        mock_paginator = mocker.MagicMock()
+        mock_paginator.paginate.return_value = [mock_ec2_instances]
+        mock_ec2_client.return_value.get_paginator.return_value = mock_paginator
+
+        mock_get_price = mocker.patch("remotepy.instance.get_instance_price")
+
+        result = runner.invoke(app, ["list", "--no-pricing"])
+
+        assert result.exit_code == 0
+        mock_get_price.assert_not_called()
+
 
 class TestLaunchTemplateUtilities:
     """Test launch template utility functions."""
diff --git a/tests/test_pricing.py b/tests/test_pricing.py
