tfcost 0.1.0__tar.gz

tfcost-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: tfcost
+Version: 0.1.0
+Summary: Terraform cost estimation tool
+Author: Rakshith Jakkani
+Requires-Dist: boto3
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: summary

tfcost-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tfcost-0.1.0/setup.py

@@ -0,0 +1,17 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="tfcost",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[
+        "boto3"
+    ],
+    entry_points={
+        "console_scripts": [
+            "tfcost=tfcost.cli:main"
+        ]
+    },
+    author="Rakshith Jakkani",
+    description="Terraform cost estimation tool",
+)

tfcost-0.1.0/tfcost/cli.py

@@ -0,0 +1,148 @@
+import argparse
+import sys
+
+from tfcost.plan_parser import parse_plan
+from tfcost.cost_calculator import calculate_cost
+from tfcost.history import show_cost_trend
+
+
+def main():
+
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--summary",
+        action="store_true",
+        help="Show summary only"
+    )
+
+    parser.add_argument(
+        "--fail-if-increase",
+        type=float,
+        help="Fail if cost increase exceeds this value"
+    )
+
+    parser.add_argument(
+        "--output",
+        choices=["table", "json"],
+        default="table",
+        help="Output format"
+    )
+
+    parser.add_argument(
+        "--trend",
+        action="store_true",
+        help="Show infrastructure cost trend"
+    )
+
+    parser.add_argument(
+        "--var-file",
+        help="Terraform variable file (e.g. prod.tfvars)"
+    )
+
+    parser.add_argument(
+        "--compare",
+        nargs=2,
+        metavar=("ENV1", "ENV2"),
+        help="Compare two Terraform variable files"
+    )
+
+    parser.add_argument(
+        "--diff",
+        action="store_true",
+        help="Show cost difference between current and proposed infrastructure"
+    )
+
+    args = parser.parse_args()
+
+    # --------------------------------
+    # Cost trend
+    # --------------------------------
+    if args.trend:
+        show_cost_trend()
+        return
+
+    # --------------------------------
+    # Environment comparison
+    # --------------------------------
+    if args.compare:
+
+        env1, env2 = args.compare
+
+        print("\nRunning Terraform plan for:", env1)
+        resources1, region1 = parse_plan(var_file=env1)
+        cost1 = calculate_cost(resources1, region1, summary=True)
+
+        print("\nRunning Terraform plan for:", env2)
+        resources2, region2 = parse_plan(var_file=env2)
+        cost2 = calculate_cost(resources2, region2, summary=True)
+
+        diff = cost2 - cost1
+        percent = (diff / cost1 * 100) if cost1 else 0
+
+        print("\nTerraform Environment Cost Comparison")
+        print("─────────────────────────────────────")
+        print(f"{env1:20} ${cost1:>10.2f}")
+        print(f"{env2:20} ${cost2:>10.2f}")
+        print("")
+        print(f"{'Difference':20} ${diff:>10.2f}")
+        print(f"{'Change %':20} {percent:>10.2f} %")
+
+        return
+
+    # --------------------------------
+    # Pull Request Cost Diff
+    # --------------------------------
+    if args.diff:
+
+        print("\nCalculating current infrastructure cost...")
+        resources_old, region_old = parse_plan()
+        current_cost = calculate_cost(resources_old, region_old, summary=True)
+
+        print("\nCalculating proposed infrastructure cost...")
+        resources_new, region_new = parse_plan(var_file=args.var_file)
+        new_cost = calculate_cost(resources_new, region_new, summary=True)
+
+        diff = new_cost - current_cost
+        percent = (diff / current_cost * 100) if current_cost else 0
+
+        print("\nTerraform Cost Diff")
+        print("────────────────────────────────")
+        print(f"{'Current Infrastructure Cost':35} ${current_cost:>10.2f}")
+        print(f"{'Proposed Infrastructure Cost':35} ${new_cost:>10.2f}")
+        print("")
+        print(f"{'Cost Increase':35} ${diff:>10.2f}")
+        print(f"{'Change %':35} {percent:>10.2f}%")
+
+        if diff > 0:
+            print("\n⚠ Infrastructure cost will increase.")
+
+        return
+
+    # --------------------------------
+    # Normal cost estimation
+    # --------------------------------
+    resources, region = parse_plan(var_file=args.var_file)
+
+    cost_change = calculate_cost(
+        resources,
+        region,
+        summary=args.summary,
+        output=args.output
+    )
+
+    # --------------------------------
+    # Cost threshold guardrail
+    # --------------------------------
+    if args.fail_if_increase is not None:
+
+        threshold = args.fail_if_increase
+
+        print(f"\nThreshold : ${threshold:.2f}")
+
+        if cost_change > threshold:
+            print("Status    : FAIL")
+            print("Cost increase exceeds allowed threshold.")
+            sys.exit(1)
+        else:
+            print("Status    : PASS")

tfcost-0.1.0/tfcost/cost_calculator.py

@@ -0,0 +1,170 @@
+import json
+
+from tfcost.engines.pricing_engine import calculate_resource_cost
+from tfcost.pricing.service_detector import detect_service
+from tfcost.history import save_cost_snapshot
+
+
+def get_module_name(address):
+
+    if address.startswith("module."):
+        parts = address.split(".")
+        return parts[1]
+
+    return "root"
+
+
+def calculate_cost(resources, region, summary=False, output="table"):
+
+    has_changes = False
+
+    show_resources = (not summary) and (output != "json")
+
+    previous_cost = 0
+    final_cost = 0
+
+    service_costs = {}
+    module_costs = {}
+
+    # Header will be printed ONLY if changes exist
+    printed_header = False
+
+    for r in resources:
+
+        actions = r.get("actions", [])
+
+        before_config = r.get("before")
+        after_config = r.get("config")
+
+        before_cost = 0
+        after_cost = 0
+
+        # -----------------------------
+        # BEFORE COST
+        # -----------------------------
+        if before_config:
+            before_resource = {
+                "type": r["type"],
+                "config": before_config
+            }
+
+            before_result = calculate_resource_cost(before_resource, region)
+            before_cost = before_result["cost"]
+
+        # -----------------------------
+        # AFTER COST
+        # -----------------------------
+        if after_config:
+            after_result = calculate_resource_cost(r, region)
+            after_cost = after_result["cost"]
+            service = after_result["service"]
+        else:
+            service = detect_service(r["type"])
+
+        diff = after_cost - before_cost
+
+        if diff != 0:
+            has_changes = True
+
+        # -----------------------------
+        # PRINT ONLY CHANGED RESOURCES
+        # -----------------------------
+        if show_resources and diff != 0:
+
+            # Print header lazily (only when first change appears)
+            if not printed_header:
+                print("\nTerraform Cost Estimate")
+                print("─" * 80)
+                print(f"{'Resource':35} {'Before':>10} {'After':>10} {'Diff':>10}")
+                print("─" * 80)
+                printed_header = True
+
+            if "create" in actions:
+                symbol = "+"
+            elif "delete" in actions:
+                symbol = "-"
+            elif "update" in actions:
+                symbol = "~"
+            else:
+                symbol = " "
+
+            print(
+                f"{symbol} {r['address']:33} "
+                f"${before_cost:>8.2f} → ${after_cost:>8.2f} "
+                f"{diff:+10.2f}"
+            )
+
+        # -----------------------------
+        # AGGREGATION
+        # -----------------------------
+        previous_cost += before_cost
+        final_cost += after_cost
+
+        service_costs[service] = service_costs.get(service, 0) + after_cost
+
+        module = get_module_name(r["address"])
+        module_costs[module] = module_costs.get(module, 0) + after_cost
+
+    cost_change = final_cost - previous_cost
+
+    result = {
+        "previous_cost": round(previous_cost, 2),
+        "estimated_cost": round(final_cost, 2),
+        "cost_change": round(cost_change, 2),
+        "services": {k: round(v, 2) for k, v in service_costs.items()},
+        "modules": {k: round(v, 2) for k, v in module_costs.items()}
+    }
+
+    # -----------------------------
+    # JSON OUTPUT
+    # -----------------------------
+    if output == "json":
+        print(json.dumps(result, indent=2))
+        return final_cost
+
+    # -----------------------------
+    # NO CHANGE CASE
+    # -----------------------------
+    if not has_changes:
+        print("\nNo cost changes detected. Infrastructure cost is up-to-date.")
+        save_cost_snapshot(final_cost)
+        return final_cost
+
+    # -----------------------------
+    # SUMMARY
+    # -----------------------------
+    print("─" * 80)
+    print(f"{'Previous Infrastructure Cost':45} ${previous_cost:>10.2f}")
+    print(f"{'Estimated Infrastructure Cost':45} ${final_cost:>10.2f}")
+    print(f"{'Cost Change':45} {cost_change:+10.2f}")
+    print("─" * 80)
+
+    # -----------------------------
+    # SERVICE BREAKDOWN
+    # -----------------------------
+    print("\nCost Breakdown by Service")
+    print("─" * 30)
+
+    for service, cost in service_costs.items():
+        if cost > 0:
+            print(f"{service:20} ${cost:>8.2f}")
+
+    print("─" * 30)
+
+    # -----------------------------
+    # MODULE BREAKDOWN
+    # -----------------------------
+    print("\nCost Breakdown by Module")
+    print("─" * 30)
+
+    for module, cost in module_costs.items():
+        print(f"{module:20} ${cost:>8.2f}")
+
+    print("─" * 30)
+
+    # -----------------------------
+    # SAVE HISTORY
+    # -----------------------------
+    save_cost_snapshot(final_cost)
+
+    return final_cost

tfcost-0.1.0/tfcost/history.py

@@ -0,0 +1,42 @@
+import json
+import os
+from datetime import date
+
+HISTORY_FILE = "cost_history.json"
+
+
+def save_cost_snapshot(cost):
+
+    history = []
+
+    if os.path.exists(HISTORY_FILE):
+        with open(HISTORY_FILE) as f:
+            history = json.load(f)
+
+        # prevent duplicate entries
+        if history and history[-1]["cost"] == round(cost, 2):
+            return
+
+    history.append({
+        "date": str(date.today()),
+        "cost": round(cost, 2)
+    })
+
+    with open(HISTORY_FILE, "w") as f:
+        json.dump(history, f, indent=2)
+
+
+def show_cost_trend():
+
+    if not os.path.exists(HISTORY_FILE):
+        print("\nNo cost history available.")
+        return
+
+    with open(HISTORY_FILE) as f:
+        history = json.load(f)
+
+    print("\nInfrastructure Cost Trend")
+    print("─" * 30)
+
+    for entry in history:
+        print(f"{entry['date']:12} ${entry['cost']:>8.2f}")

tfcost-0.1.0/tfcost/plan_parser.py

@@ -0,0 +1,77 @@
+import json
+import subprocess
+
+
+def load_terraform_plan(var_file=None):
+
+    try:
+
+        # Build terraform plan command
+        cmd = ["terraform", "plan", "-out", "tfplan"]
+
+        if var_file:
+            cmd.append(f"-var-file={var_file}")
+        print("Running terraform plan...")
+        # Run terraform plan
+        subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True
+        )
+
+        # Get terraform JSON output
+        result = subprocess.run(
+            ["terraform", "show", "-json", "tfplan"],
+            check=True,
+            capture_output=True,
+            text=True
+        )
+
+        return json.loads(result.stdout)
+
+    except subprocess.CalledProcessError as e:
+        raise Exception("Terraform execution failed:\n" + e.stderr)
+
+
+def parse_plan(var_file=None):
+
+    # Load Terraform plan
+    plan = load_terraform_plan(var_file)
+
+    resources = []
+    region = None
+
+    for r in plan.get("resource_changes", []):
+
+        change = r.get("change", {})
+        actions = change.get("actions", [])
+
+        before = change.get("before")
+        after = change.get("after")
+
+        # Use after for create/update, before for delete
+        config = after if after is not None else before
+
+        if config is None:
+            continue
+
+        # Detect region
+        if not region and isinstance(config, dict) and "region" in config:
+            region = config["region"]
+
+        resource = {
+            "type": r.get("type"),
+            "address": r.get("address"),
+            "config": after,
+            "before": before,
+            "actions": actions
+        }
+
+        resources.append(resource)
+
+    # Fallback region
+    if not region:
+        region = "us-east-1"
+
+    return resources, region

tfcost-0.1.0/tfcost/pricing/__init__.py

@@ -0,0 +1 @@
+# pricing package

tfcost-0.1.0/tfcost/pricing/aws_ebs.py

@@ -0,0 +1,17 @@
+# from tfcost.engines.resource_engine import register
+# from tfcost.pricing.aws_pricing import get_ebs_price
+
+# @register("aws_ebs_volume")
+# def price_ebs(resource, region):
+
+#     size = resource["config"].get("size")
+#     vtype = resource["config"].get("type", "gp3")
+
+#     price = get_ebs_price(vtype, region)
+
+#     monthly = price * size
+
+#     return {
+#         "service": "EBS",
+#         "cost": monthly
+#     }

tfcost-0.1.0/tfcost/pricing/aws_ec2.py

@@ -0,0 +1,18 @@
+# from tfcost.engines.resource_engine import register
+# from tfcost.pricing.aws_pricing import get_ec2_price
+
+# HOURS_PER_MONTH = 730.5
+
+# @register("aws_instance")
+# def price_ec2(resource, region):
+
+#     instance_type = resource["config"]["instance_type"]
+
+#     hourly = get_ec2_price(instance_type, region)
+
+#     monthly = hourly * HOURS_PER_MONTH
+
+#     return {
+#         "service": "EC2",
+#         "cost": monthly
+#     }

tfcost-0.1.0/tfcost/pricing/aws_nat_gateway.py

@@ -0,0 +1,15 @@
+# from tfcost.engines.resource_engine import register
+
+# HOURS_PER_MONTH = 730.5
+# NAT_HOURLY_PRICE = 0.045
+
+
+# @register("aws_nat_gateway")
+# def price_nat_gateway(resource, region):
+
+#     monthly = NAT_HOURLY_PRICE * HOURS_PER_MONTH
+
+#     return {
+#         "service": "NAT Gateway",
+#         "cost": monthly
+#     }

tfcost-0.1.0/tfcost/pricing/aws_pricing.py

@@ -0,0 +1,130 @@
+
+
+import boto3
+import json
+
+pricing_client = boto3.client("pricing", region_name="us-east-1")
+
+PRICE_CACHE = {}
+
+def get_pricing_location(region):
+
+    REGION_MAP = {
+        "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": "EU (Ireland)",
+        "eu-west-2": "EU (London)",
+        "eu-west-3": "EU (Paris)",
+        "ap-south-1": "Asia Pacific (Mumbai)"
+    }
+
+    return REGION_MAP.get(region, "US East (N. Virginia)")
+
+EC2_CLIENT_CACHE = {}
+
+def get_ami_root_volume(ami_id, region):
+    if region not in EC2_CLIENT_CACHE:
+        EC2_CLIENT_CACHE[region] = boto3.client("ec2", region_name=region)
+    ec2 = EC2_CLIENT_CACHE[region]
+    response = ec2.describe_images(ImageIds=[ami_id])
+    images = response.get("Images", [])
+    if not images:
+        return None, None
+    image = images[0]
+    mappings = image.get("BlockDeviceMappings", [])
+    for mapping in mappings:
+        ebs = mapping.get("Ebs")
+        if ebs:
+            size = ebs.get("VolumeSize")
+            vtype = ebs.get("VolumeType")
+            return size, vtype
+
+    return None, None
+
+def get_ec2_price(instance_type, region):
+
+    cache_key = f"{instance_type}:{region}"
+
+    if cache_key in PRICE_CACHE:
+        return PRICE_CACHE[cache_key]
+
+    # location = REGION_MAP.get(region, "US East (N. Virginia)")
+    location = get_pricing_location(region)
+
+    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
+    )
+
+    if not response["PriceList"]:
+        return 0
+
+    price_item = json.loads(response["PriceList"][0])
+
+    terms = price_item["terms"]["OnDemand"]
+
+    for term in terms.values():
+        for dim in term["priceDimensions"].values():
+            price = float(dim["pricePerUnit"]["USD"])
+
+            # store in cache
+            PRICE_CACHE[cache_key] = price
+
+            return price
+
+    return 0
+
+
+def get_ebs_price(volume_type, region):
+
+    # location = REGION_MAP.get(region, "US East (N. Virginia)")
+    location = get_pricing_location(region)
+
+    response = pricing_client.get_products(
+        ServiceCode="AmazonEC2",
+        Filters=[
+            {"Type": "TERM_MATCH", "Field": "volumeApiName", "Value": volume_type},
+            {"Type": "TERM_MATCH", "Field": "location", "Value": location},
+            {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "Storage"}
+        ],
+        MaxResults=1
+    )
+
+    if not response["PriceList"]:
+        return 0
+
+    price_item = json.loads(response["PriceList"][0])
+
+    terms = price_item["terms"]["OnDemand"]
+
+    for term in terms.values():
+        for dim in term["priceDimensions"].values():
+            return float(dim["pricePerUnit"]["USD"])
+
+    return 0
+
+def get_instance_price(instance_type, region):
+    """
+    Generic instance pricing.
+    Currently uses EC2 pricing API.
+    Works for EC2 and similar instance-based services.
+    """
+    return get_ec2_price(instance_type, region)
+
+
+def get_storage_price(volume_type, region):
+    """
+    Generic storage pricing.
+    Currently uses EBS pricing API.
+    """
+    return get_ebs_price(volume_type, region)

tfcost-0.1.0/tfcost/pricing/aws_s3.py

@@ -0,0 +1,14 @@
+# from tfcost.engines.resource_engine import register
+
+# @register("aws_s3_bucket")
+# def price_s3(resource, region):
+
+#     storage_gb = 10
+#     price_per_gb = 0.023
+
+#     monthly = storage_gb * price_per_gb
+
+#     return {
+#         "service": "S3",
+#         "cost": monthly
+#     }

tfcost-0.1.0/tfcost/pricing/resource_pricing_map.py

@@ -0,0 +1,205 @@
+RESOURCE_PRICING_MAP = {
+
+# ========================
+# EC2
+# ========================
+"aws_instance": {
+    "service": "EC2",
+    "lookup": "instance_type",
+    "pricing_model": "instance_hour"
+},
+
+"aws_launch_template": {
+    "service": "EC2",
+    "lookup": "instance_type",
+    "pricing_model": "instance_hour"
+},
+
+"aws_autoscaling_group": {
+    "service": "EC2",
+    "lookup": "instance_type",
+    "pricing_model": "instance_hour"
+},
+
+"aws_spot_instance_request": {
+    "service": "EC2",
+    "lookup": "instance_type",
+    "pricing_model": "instance_hour"
+},
+
+# ========================
+# EBS
+# ========================
+"aws_ebs_volume": {
+    "service": "EBS",
+    "lookup": "type",
+    "size": "size",
+    "pricing_model": "storage_gb_month"
+},
+
+"aws_ebs_snapshot": {
+    "service": "EBS",
+    "size": "size",
+    "pricing_model": "storage_gb_month"
+},
+
+# ========================
+# S3
+# ========================
+"aws_s3_bucket": {
+    "service": "S3",
+    "pricing_model": "bucket_storage",
+    "default_size": 10,
+    "price_per_gb": 0.023
+},
+
+# ========================
+# RDS
+# ========================
+"aws_db_instance": {
+    "service": "RDS",
+    "lookup": "instance_class",
+    "pricing_model": "instance_hour"
+},
+
+"aws_rds_cluster_instance": {
+    "service": "RDS",
+    "lookup": "instance_class",
+    "pricing_model": "instance_hour"
+},
+
+"aws_rds_cluster": {
+    "service": "RDS",
+    "lookup": "engine",
+    "pricing_model": "instance_hour"
+},
+
+# ========================
+# Load Balancers
+# ========================
+"aws_lb": {
+    "service": "ELB",
+    "pricing_model": "hourly_fixed",
+    "price": 0.025
+},
+
+"aws_elb": {
+    "service": "ELB",
+    "pricing_model": "hourly_fixed",
+    "price": 0.025
+},
+
+# ========================
+# NAT Gateway
+# ========================
+"aws_nat_gateway": {
+    "service": "NAT Gateway",
+    "pricing_model": "hourly_fixed",
+    "price": 0.045
+},
+
+# ========================
+# Elastic IP
+# ========================
+"aws_eip": {
+    "service": "Elastic IP",
+    "pricing_model": "hourly_fixed",
+    "price": 0.005
+},
+
+# ========================
+# EFS
+# ========================
+"aws_efs_file_system": {
+    "service": "EFS",
+    "size": "size",
+    "pricing_model": "storage_gb_month"
+},
+
+# ========================
+# DynamoDB
+# ========================
+"aws_dynamodb_table": {
+    "service": "DynamoDB",
+    "pricing_model": "capacity"
+},
+
+# ========================
+# ElastiCache
+# ========================
+"aws_elasticache_cluster": {
+    "service": "ElastiCache",
+    "lookup": "node_type",
+    "pricing_model": "instance_hour"
+},
+
+"aws_elasticache_replication_group": {
+    "service": "ElastiCache",
+    "lookup": "node_type",
+    "pricing_model": "instance_hour"
+},
+
+# ========================
+# Redshift
+# ========================
+"aws_redshift_cluster": {
+    "service": "Redshift",
+    "lookup": "node_type",
+    "pricing_model": "instance_hour"
+},
+
+# ========================
+# EKS
+# ========================
+"aws_eks_cluster": {
+    "service": "EKS",
+    "pricing_model": "hourly_fixed",
+    "price": 0.10
+},
+
+"aws_eks_node_group": {
+    "service": "EKS",
+    "lookup": "instance_types",
+    "count": "desired_size",
+    "pricing_model": "eks_node_group"
+},
+
+# ========================
+# MSK
+# ========================
+"aws_msk_cluster": {
+    "service": "MSK",
+    "lookup": "instance_type",
+    "pricing_model": "instance_hour"
+},
+
+# ========================
+# OpenSearch
+# ========================
+"aws_opensearch_domain": {
+    "service": "OpenSearch",
+    "lookup": "instance_type",
+    "pricing_model": "instance_hour"
+},
+
+# ========================
+# EKS
+# ========================
+
+"aws_eks_cluster": {
+    "service": "EKS",
+    "pricing_model": "hourly_fixed",
+    "price": 0.10
+},
+
+# ========================
+# Glue
+# ========================
+"aws_glue_job": {
+    "service": "Glue",
+    "pricing_model": "hourly_fixed",
+    "price": 0.44
+}
+
+
+}

tfcost-0.1.0/tfcost/pricing/service_detector.py

@@ -0,0 +1,33 @@
+SERVICE_PREFIX_MAP = {
+
+    "aws_instance": "EC2",
+    "aws_ebs": "EBS",
+    "aws_s3": "S3",
+    "aws_lambda": "Lambda",
+    "aws_lb": "ELB",
+    "aws_elb": "ELB",
+    "aws_nat_gateway": "NAT Gateway",
+    "aws_dynamodb": "DynamoDB",
+    "aws_db": "RDS",
+    "aws_rds": "RDS",
+    "aws_redshift": "Redshift",
+    "aws_cloudfront": "CloudFront",
+    "aws_efs": "EFS",
+    "aws_elasticache": "ElastiCache",
+    "aws_kinesis": "Kinesis",
+    "aws_sqs": "SQS",
+    "aws_sns": "SNS",
+    "aws_api_gateway": "API Gateway",
+    "aws_eks": "EKS"
+}
+
+
+def detect_service(resource_type):
+
+    for prefix, service in SERVICE_PREFIX_MAP.items():
+
+        if resource_type.startswith(prefix):
+
+            return service
+
+    return "Other"

tfcost-0.1.0/tfcost/terraform_runner.py

@@ -0,0 +1,13 @@
+import subprocess
+
+def run_terraform_plan(terraform_args):
+
+    cmd = ["terraform", "plan"] + list(terraform_args) + ["-out=tfplan"]
+
+    subprocess.run(cmd, check=True)
+
+    subprocess.run(
+        ["terraform", "show", "-json", "tfplan"],
+        stdout=open("plan.json", "w"),
+        check=True
+    )

tfcost-0.1.0/tfcost.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: tfcost
+Version: 0.1.0
+Summary: Terraform cost estimation tool
+Author: Rakshith Jakkani
+Requires-Dist: boto3
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: summary

tfcost-0.1.0/tfcost.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+setup.py
+tfcost/__init__.py
+tfcost/cli.py
+tfcost/cost_calculator.py
+tfcost/history.py
+tfcost/plan_parser.py
+tfcost/terraform_runner.py
+tfcost.egg-info/PKG-INFO
+tfcost.egg-info/SOURCES.txt
+tfcost.egg-info/dependency_links.txt
+tfcost.egg-info/entry_points.txt
+tfcost.egg-info/requires.txt
+tfcost.egg-info/top_level.txt
+tfcost/pricing/__init__.py
+tfcost/pricing/aws_ebs.py
+tfcost/pricing/aws_ec2.py
+tfcost/pricing/aws_nat_gateway.py
+tfcost/pricing/aws_pricing.py
+tfcost/pricing/aws_s3.py
+tfcost/pricing/resource_pricing_map.py
+tfcost/pricing/service_detector.py

tfcost-0.1.0/tfcost.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tfcost-0.1.0/tfcost.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tfcost = tfcost.cli:main

tfcost-0.1.0/tfcost.egg-info/requires.txt

@@ -0,0 +1 @@
+boto3

tfcost-0.1.0/tfcost.egg-info/top_level.txt

@@ -0,0 +1 @@
+tfcost