Cost Estimator

{
  "_comment": "Hardcoded Bedrock prices for models not yet in AWS Pricing API. Updated 2026-03-03. Source: https://aws.amazon.com/bedrock/pricing/",
  "us-east-1": [
    {"model": "Claude Sonnet 4.6", "provider": "Anthropic", "inferenceType": "Input tokens",                "price": 0.003,    "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.6", "provider": "Anthropic", "inferenceType": "Output tokens",               "price": 0.015,    "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.6", "provider": "Anthropic", "inferenceType": "Input tokens long context",   "price": 0.006,    "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.6", "provider": "Anthropic", "inferenceType": "Output tokens long context",  "price": 0.0225,   "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.6", "provider": "Anthropic", "inferenceType": "Input tokens batch",          "price": 0.0015,   "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.6", "provider": "Anthropic", "inferenceType": "Output tokens batch",         "price": 0.0075,   "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.6", "provider": "Anthropic", "inferenceType": "Cache write (5m)",            "price": 0.00375,  "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.6", "provider": "Anthropic", "inferenceType": "Cache write (1h)",            "price": 0.006,    "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.6", "provider": "Anthropic", "inferenceType": "Cache read",                  "price": 0.0003,   "unit": "1K tokens"},

    {"model": "Claude Opus 4.6", "provider": "Anthropic", "inferenceType": "Input tokens",                  "price": 0.005,    "unit": "1K tokens"},
    {"model": "Claude Opus 4.6", "provider": "Anthropic", "inferenceType": "Output tokens",                 "price": 0.025,    "unit": "1K tokens"},
    {"model": "Claude Opus 4.6", "provider": "Anthropic", "inferenceType": "Input tokens long context",     "price": 0.01,     "unit": "1K tokens"},
    {"model": "Claude Opus 4.6", "provider": "Anthropic", "inferenceType": "Output tokens long context",    "price": 0.0375,   "unit": "1K tokens"},
    {"model": "Claude Opus 4.6", "provider": "Anthropic", "inferenceType": "Input tokens batch",            "price": 0.0025,   "unit": "1K tokens"},
    {"model": "Claude Opus 4.6", "provider": "Anthropic", "inferenceType": "Output tokens batch",           "price": 0.0125,   "unit": "1K tokens"},
    {"model": "Claude Opus 4.6", "provider": "Anthropic", "inferenceType": "Cache write (5m)",              "price": 0.00625,  "unit": "1K tokens"},
    {"model": "Claude Opus 4.6", "provider": "Anthropic", "inferenceType": "Cache write (1h)",              "price": 0.01,     "unit": "1K tokens"},
    {"model": "Claude Opus 4.6", "provider": "Anthropic", "inferenceType": "Cache read",                    "price": 0.0005,   "unit": "1K tokens"},

    {"model": "Claude Opus 4.5", "provider": "Anthropic", "inferenceType": "Input tokens",                  "price": 0.005,    "unit": "1K tokens"},
    {"model": "Claude Opus 4.5", "provider": "Anthropic", "inferenceType": "Output tokens",                 "price": 0.025,    "unit": "1K tokens"},
    {"model": "Claude Opus 4.5", "provider": "Anthropic", "inferenceType": "Input tokens batch",            "price": 0.0025,   "unit": "1K tokens"},
    {"model": "Claude Opus 4.5", "provider": "Anthropic", "inferenceType": "Output tokens batch",           "price": 0.0125,   "unit": "1K tokens"},
    {"model": "Claude Opus 4.5", "provider": "Anthropic", "inferenceType": "Cache write (5m)",              "price": 0.00625,  "unit": "1K tokens"},
    {"model": "Claude Opus 4.5", "provider": "Anthropic", "inferenceType": "Cache write (1h)",              "price": 0.01,     "unit": "1K tokens"},
    {"model": "Claude Opus 4.5", "provider": "Anthropic", "inferenceType": "Cache read",                    "price": 0.0005,   "unit": "1K tokens"},

    {"model": "Claude Haiku 4.5", "provider": "Anthropic", "inferenceType": "Input tokens",                 "price": 0.001,    "unit": "1K tokens"},
    {"model": "Claude Haiku 4.5", "provider": "Anthropic", "inferenceType": "Output tokens",                "price": 0.005,    "unit": "1K tokens"},
    {"model": "Claude Haiku 4.5", "provider": "Anthropic", "inferenceType": "Input tokens batch",           "price": 0.0005,   "unit": "1K tokens"},
    {"model": "Claude Haiku 4.5", "provider": "Anthropic", "inferenceType": "Output tokens batch",          "price": 0.0025,   "unit": "1K tokens"},
    {"model": "Claude Haiku 4.5", "provider": "Anthropic", "inferenceType": "Cache write (5m)",             "price": 0.00125,  "unit": "1K tokens"},
    {"model": "Claude Haiku 4.5", "provider": "Anthropic", "inferenceType": "Cache write (1h)",             "price": 0.002,    "unit": "1K tokens"},
    {"model": "Claude Haiku 4.5", "provider": "Anthropic", "inferenceType": "Cache read",                   "price": 0.0001,   "unit": "1K tokens"},

    {"model": "Claude Sonnet 4.5", "provider": "Anthropic", "inferenceType": "Input tokens",                "price": 0.003,    "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.5", "provider": "Anthropic", "inferenceType": "Output tokens",               "price": 0.015,    "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.5", "provider": "Anthropic", "inferenceType": "Input tokens long context",   "price": 0.006,    "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.5", "provider": "Anthropic", "inferenceType": "Output tokens long context",  "price": 0.0225,   "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.5", "provider": "Anthropic", "inferenceType": "Input tokens batch",          "price": 0.0015,   "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.5", "provider": "Anthropic", "inferenceType": "Output tokens batch",         "price": 0.0075,   "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.5", "provider": "Anthropic", "inferenceType": "Cache write (5m)",            "price": 0.00375,  "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.5", "provider": "Anthropic", "inferenceType": "Cache write (1h)",            "price": 0.006,    "unit": "1K tokens"},
    {"model": "Claude Sonnet 4.5", "provider": "Anthropic", "inferenceType": "Cache read",                  "price": 0.0003,   "unit": "1K tokens"},

    {"model": "Titan Text Embeddings V2", "provider": "Amazon", "inferenceType": "Input tokens",            "price": 0.00002,  "unit": "1K tokens"},
    {"model": "Titan Multimodal Embeddings G1", "provider": "Amazon", "inferenceType": "Input tokens (text)", "price": 0.00002, "unit": "1K tokens"},
    {"model": "Titan Multimodal Embeddings G1", "provider": "Amazon", "inferenceType": "Input (image)",     "price": 0.0008,   "unit": "per image"},

    {"model": "Nova Micro", "provider": "Amazon", "inferenceType": "Input tokens",                          "price": 0.000035, "unit": "1K tokens"},
    {"model": "Nova Micro", "provider": "Amazon", "inferenceType": "Output tokens",                         "price": 0.00014,  "unit": "1K tokens"},
    {"model": "Nova Lite", "provider": "Amazon", "inferenceType": "Input tokens",                           "price": 0.00006,  "unit": "1K tokens"},
    {"model": "Nova Lite", "provider": "Amazon", "inferenceType": "Output tokens",                          "price": 0.00024,  "unit": "1K tokens"},
    {"model": "Nova Pro", "provider": "Amazon", "inferenceType": "Input tokens",                            "price": 0.0008,   "unit": "1K tokens"},
    {"model": "Nova Pro", "provider": "Amazon", "inferenceType": "Output tokens",                           "price": 0.0032,   "unit": "1K tokens"}
  ]
}

#!/usr/bin/env python3
"""
AWS Price List Bulk API query tool.

All queries use the public Bulk API — no AWS credentials needed.
For Bedrock models not yet in the API, falls back to bedrock-fallback-prices.json.

Usage:
    python3 fetch-aws-pricing.py <region> --offer-code CODE [--filter KEY=VALUE ...]
        [--cache-dir DIR] [--output FILE]

Examples:
    # Fargate prices
    python3 fetch-aws-pricing.py us-east-1 --offer-code AmazonECS \
        --filter usagetype=Fargate

    # RDS db.t4g.medium
    python3 fetch-aws-pricing.py cn-northwest-1 --offer-code AmazonRDS \
        --filter instanceType=db.t4g.medium --filter databaseEngine=PostgreSQL

    # NAT Gateway (under AmazonEC2)
    python3 fetch-aws-pricing.py us-east-1 --offer-code AmazonEC2 \
        --filter usagetype=NatGateway

    # Bedrock — tries AmazonBedrockService then AmazonBedrock, plus fallback
    python3 fetch-aws-pricing.py us-east-1 --offer-code Bedrock \
        --filter "model=Claude Sonnet 4.6"

Uses only Python stdlib (urllib). No boto3 or AWS CLI dependency.
"""

import argparse
import hashlib
import json
import os
import sys
import time
import urllib.request
import urllib.error
from datetime import datetime, timezone

GLOBAL_BASE = "https://pricing.us-east-1.amazonaws.com"
CN_BASE = "https://pricing.cn-northwest-1.amazonaws.com.cn"
CACHE_TTL = 86400  # 24 hours

# Bedrock offer codes to try via Bulk API (in order of preference)
BEDROCK_SERVICE_CODES = ["AmazonBedrockService", "AmazonBedrock"]

# Path to fallback prices JSON (relative to this script)
BEDROCK_FALLBACK_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "bedrock-fallback-prices.json")

# Attributes to keep in output
KEEP_ATTRS = (
    # infra
    "servicecode", "usagetype", "operation", "regionCode",
    "instanceType", "instanceFamily",
    "databaseEngine", "deploymentOption",
    "operatingSystem", "cpuArchitecture",
    "tenancy", "storage", "networkPerformance",
    "vcpu", "memory",
    # bedrock
    "model", "provider", "inferenceType", "featuretype",
)


def is_cn(region: str) -> bool:
    return region.startswith("cn-")


def base_url(region: str) -> tuple[str, str]:
    host = CN_BASE if is_cn(region) else GLOBAL_BASE
    path = "/offers/v1.0/cn" if is_cn(region) else "/offers/v1.0/aws"
    return host, host + path


def cache_key(cache_dir: str, url: str) -> str:
    h = hashlib.sha256(url.encode()).hexdigest()[:16]
    return os.path.join(cache_dir, f"{h}.json")


def fetch_json(url: str, cache_dir: str | None = None) -> dict:
    # Security: Only allow HTTPS URLs to prevent file:// scheme attacks
    if not url.startswith("https://"):
        print(f"  Error: Only HTTPS URLs are allowed: {url}", file=sys.stderr)
        return {}

    if cache_dir:
        cp = cache_key(cache_dir, url)
        if os.path.exists(cp) and (time.time() - os.path.getmtime(cp)) < CACHE_TTL:
            with open(cp) as f:
                return json.load(f)

    print(f"  Fetching {url[:120]}...", file=sys.stderr)
    req = urllib.request.Request(url, headers={"Accept": "application/json"})
    try:
        with urllib.request.urlopen(req, timeout=180) as resp:  # nosec B310 - URL scheme validated above
            data = json.loads(resp.read().decode())
    except (urllib.error.HTTPError, urllib.error.URLError) as e:
        print(f"  Error: {e}", file=sys.stderr)
        return {}

    if cache_dir:
        os.makedirs(cache_dir, exist_ok=True)
        with open(cache_key(cache_dir, url), "w") as f:
            json.dump(data, f)
    return data


def resolve_region_url(host, api_base, offer_code, region, cache_dir):
    index_url = f"{api_base}/{offer_code}/current/region_index.json"
    index = fetch_json(index_url, cache_dir)
    if not index:
        return None
    region_info = index.get("regions", {}).get(region)
    if not region_info:
        print(f"  Region {region} not in {offer_code}", file=sys.stderr)
        return None
    ver_url = region_info.get("currentVersionUrl", "")
    return (host + ver_url) if ver_url.startswith("/") else ver_url


def extract_on_demand_price(terms: dict, sku: str) -> dict:
    for _k, offer in terms.get(sku, {}).items():
        for _dk, dim in offer.get("priceDimensions", {}).items():
            per_unit = dim.get("pricePerUnit", {})
            for currency, val in per_unit.items():
                try:
                    p = float(val)
                    if p > 0:
                        return {"price": p, "currency": currency, "unit": dim.get("unit", ""),
                                "description": dim.get("description", "")}
                except ValueError:
                    pass
    return {}


def match_filters(attrs: dict, filters: list[tuple[str, str]]) -> bool:
    for key, val in filters:
        attr_val = attrs.get(key, "")
        if val.lower() not in attr_val.lower():
            return False
    return True


# ---------- Bulk API query ----------

def query_bulk(region, offer_code, filters, cache_dir):
    host, api_base = base_url(region)
    region_url = resolve_region_url(host, api_base, offer_code, region, cache_dir)
    if not region_url:
        return []

    data = fetch_json(region_url, cache_dir)
    if not data:
        return []

    products = data.get("products", {})
    terms = data.get("terms", {}).get("OnDemand", {})
    results = []

    for sku, product in products.items():
        attrs = product.get("attributes", {})
        if not match_filters(attrs, filters):
            continue

        price_info = extract_on_demand_price(terms, sku)
        if not price_info:
            continue

        results.append({
            "sku": sku,
            "productFamily": product.get("productFamily", attrs.get("productFamily", "")),
            "attributes": {k: v for k, v in attrs.items() if k in KEEP_ATTRS},
            **price_info,
        })

    return results


# ---------- Bedrock fallback from local JSON ----------

def query_bedrock_fallback(region, filters):
    """Load hardcoded Bedrock prices from bedrock-fallback-prices.json."""
    if not os.path.exists(BEDROCK_FALLBACK_PATH):
        print(f"  Fallback file not found: {BEDROCK_FALLBACK_PATH}", file=sys.stderr)
        return []

    with open(BEDROCK_FALLBACK_PATH) as f:
        data = json.load(f)

    entries = data.get(region, data.get("us-east-1", []))
    results = []
    for entry in entries:
        attrs = {
            "model": entry.get("model", ""),
            "provider": entry.get("provider", ""),
            "inferenceType": entry.get("inferenceType", ""),
        }
        if not match_filters(attrs, filters):
            continue
        results.append({
            "sku": "fallback",
            "productFamily": "Amazon Bedrock (fallback)",
            "attributes": attrs,
            "price": entry["price"],
            "currency": "USD",
            "unit": entry.get("unit", "1K tokens"),
            "description": f"Fallback: {entry['model']} {entry['inferenceType']} @ ${entry['price']}/{entry.get('unit','1K tokens')}",
        })
    return results


def main():
    parser = argparse.ArgumentParser(
        description="Query AWS Price List Bulk API",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog=__doc__,
    )
    parser.add_argument("region", help="AWS region (e.g. us-east-1, cn-northwest-1)")
    parser.add_argument("--offer-code", required=True,
                        help="Service offer code. Use 'Bedrock' as shortcut for AmazonBedrockService + fallback.")
    parser.add_argument("--filter", action="append", default=[],
                        help="Filter as KEY=VALUE (substring match). Repeatable.")
    parser.add_argument("--cache-dir", default=None, help="Cache dir (24h TTL)")
    parser.add_argument("--output", default=None, help="Output JSON file (default: stdout)")
    args = parser.parse_args()

    filters = []
    for f in args.filter:
        if "=" not in f:
            print(f"Invalid filter (need KEY=VALUE): {f}", file=sys.stderr)
            sys.exit(1)
        k, v = f.split("=", 1)
        filters.append((k, v))

    offer_code = args.offer_code

    # Bedrock shortcut: Bulk API + fallback for missing models
    if offer_code.lower() in ("bedrock", "amazonbedrock", "amazonbedrockservice"):
        api_results = []
        for svc in BEDROCK_SERVICE_CODES:
            api_results = query_bulk(args.region, svc, filters, args.cache_dir)
            if api_results:
                offer_code = svc
                break
        if not api_results:
            offer_code = "AmazonBedrockService"

        # Fill gaps from fallback for models not in API
        api_models = {r["attributes"].get("model", "") for r in api_results}
        fallback_results = query_bedrock_fallback(args.region, filters)
        merged = list(api_results)
        fallback_count = 0
        for fb in fallback_results:
            if fb["attributes"].get("model", "") not in api_models:
                merged.append(fb)
                fallback_count += 1
        if fallback_count:
            print(f"  Added {fallback_count} entries from fallback (models not in API)", file=sys.stderr)
        results = merged
    else:
        results = query_bulk(args.region, offer_code, filters, args.cache_dir)

    output = {
        "region": args.region,
        "offerCode": offer_code,
        "filters": {k: v for k, v in filters},
        "resultCount": len(results),
        "fetchedAt": datetime.now(timezone.utc).isoformat(),
        "results": results,
    }

    text = json.dumps(output, indent=2, ensure_ascii=False)
    if args.output:
        os.makedirs(os.path.dirname(os.path.abspath(args.output)), exist_ok=True)
        with open(args.output, "w") as f:
            f.write(text)
        print(f"Wrote {len(results)} results to {args.output}", file=sys.stderr)
    else:
        print(text)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Generic JSON-to-styled-Excel converter for pricing reports.

Reads a JSON file describing the report structure and produces a formatted .xlsx.

Usage:
    python3 generate-pricing-excel.py --input report.json --output pricing.xlsx

Input JSON schema:
{
  "sheets": [
    {
      "name": "us-east-1",                              // Sheet tab name
      "columns": ["Module", "Service", ...],             // Header row
      "columnWidths": [20, 35, ...],                     // Column widths
      "rows": [                                          // Data rows
        {"values": ["Console", "ECS Fargate", ...], "module": "Console"},
        ...
      ],
      "totalRow": {"label": "Total", "value": 639.29},  // Optional total
      "assumptions": ["Deployed in us-east-1", ...]      // Optional Key Assumptions
    }
  ]
}

- "module" on each row → color-banding (same module = same color, auto-assigned).
- Numeric values → right-aligned with #,##0.00 format.
- "—" → centered dash (minimal cost).
- "totalRow" → bold dark summary row.
- "assumptions" → printed below the table as "Key Assumptions:" bullet list.

Requires: openpyxl
"""

import argparse
import json
import os
import sys

try:
    from openpyxl import Workbook
    from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
except ImportError:
    print("Error: openpyxl required. Install: pip3 install openpyxl", file=sys.stderr)
    sys.exit(1)

# --- Style constants ---

COLOR_PALETTE = [
    "E3F2FD", "E8F5E9", "FFF3E0", "F3E5F5",
    "FFEBEE", "E0F7FA", "FFF9C4", "F1F8E9",
]
HEADER_FILL = PatternFill(start_color="607D8B", end_color="607D8B", fill_type="solid")
HEADER_FONT = Font(bold=True, color="FFFFFF", size=11)
TOTAL_FILL = PatternFill(start_color="37474F", end_color="37474F", fill_type="solid")
TOTAL_FONT = Font(bold=True, color="FFFFFF", size=11)
BORDER = Border(
    left=Side(style="thin", color="BDBDBD"),
    right=Side(style="thin", color="BDBDBD"),
    top=Side(style="thin", color="BDBDBD"),
    bottom=Side(style="thin", color="BDBDBD"),
)
NUM_FMT = '#,##0.00'


def build_sheet(wb: Workbook, sheet_def: dict):
    name = sheet_def.get("name", "Sheet")[:31]
    ws = wb.create_sheet(title=name)

    columns = sheet_def.get("columns", [])
    col_widths = sheet_def.get("columnWidths", [])
    rows = sheet_def.get("rows", [])

    # Column widths
    for i, w in enumerate(col_widths):
        ws.column_dimensions[chr(65 + i)].width = w

    # Header row
    for ci, header in enumerate(columns, 1):
        c = ws.cell(row=1, column=ci, value=header)
        c.fill = HEADER_FILL
        c.font = HEADER_FONT
        c.alignment = Alignment(horizontal="center", vertical="center")
        c.border = BORDER

    # Module color assignment
    color_map = {}

    def module_fill(mod: str) -> PatternFill:
        if not mod:
            return PatternFill(fill_type=None)
        if mod not in color_map:
            color_map[mod] = COLOR_PALETTE[len(color_map) % len(COLOR_PALETTE)]
        c = color_map[mod]
        return PatternFill(start_color=c, end_color=c, fill_type="solid")

    # Data rows
    for ri, row_def in enumerate(rows, 2):
        values = row_def.get("values", [])
        mod = row_def.get("module", "")
        fill = module_fill(mod)

        for ci, val in enumerate(values, 1):
            cell = ws.cell(row=ri, column=ci, value=val)
            cell.border = BORDER
            cell.fill = fill

            # Numeric formatting for price columns
            if isinstance(val, (int, float)):
                cell.number_format = NUM_FMT
                cell.alignment = Alignment(horizontal="right")
            elif val == "—" or val == "—":
                cell.alignment = Alignment(horizontal="center")

        # Bold first column if it has a module name (first in group)
        if values and values[0]:
            ws.cell(row=ri, column=1).font = Font(bold=True)

    # Total row
    next_row = len(rows) + 2
    total_def = sheet_def.get("totalRow")
    if total_def:
        tr = next_row
        total_label = total_def.get("label", "Total")
        total_value = total_def.get("value", 0)

        for ci in range(1, len(columns) + 1):
            cell = ws.cell(row=tr, column=ci, value="")
            cell.fill = TOTAL_FILL
            cell.font = TOTAL_FONT
            cell.border = BORDER

        ws.cell(row=tr, column=1, value=total_label).fill = TOTAL_FILL
        ws.cell(row=tr, column=1).font = TOTAL_FONT

        # Put total value in the price column (find "Price" or "Cost" in header)
        price_col = None
        for ci, header in enumerate(columns, 1):
            if "price" in header.lower() or "cost" in header.lower():
                price_col = ci
                break
        if price_col is None and len(columns) >= 5:
            price_col = 5

        if price_col:
            # Use SUM formula instead of hardcoded value for accuracy
            col_letter = chr(64 + price_col)
            data_start = 2
            data_end = len(rows) + 1
            sum_formula = f"=SUM({col_letter}{data_start}:{col_letter}{data_end})"
            tc = ws.cell(row=tr, column=price_col, value=sum_formula)
            tc.fill = TOTAL_FILL
            tc.font = TOTAL_FONT
            tc.number_format = NUM_FMT
            tc.alignment = Alignment(horizontal="right")

        next_row = tr + 2

    # Key Assumptions
    assumptions = sheet_def.get("assumptions", [])
    if assumptions:
        ar = next_row
        cell = ws.cell(row=ar, column=1, value="Key Assumptions:")
        cell.font = Font(bold=True, size=11)
        for i, text in enumerate(assumptions):
            ws.cell(row=ar + 1 + i, column=1, value=f"• {text}").font = Font(size=10)
            ws.merge_cells(start_row=ar + 1 + i, start_column=1,
                           end_row=ar + 1 + i, end_column=len(columns))


def main():
    parser = argparse.ArgumentParser(description="JSON → styled Excel pricing report")
    parser.add_argument("--input", required=True, help="Input JSON file describing the report")
    parser.add_argument("--output", required=True, help="Output .xlsx file path")
    args = parser.parse_args()

    with open(args.input) as f:
        report = json.load(f)

    wb = Workbook()
    wb.remove(wb.active)

    for sheet_def in report.get("sheets", []):
        build_sheet(wb, sheet_def)

    if not wb.sheetnames:
        print("Warning: no sheets defined in input JSON", file=sys.stderr)
        wb.create_sheet("Empty")

    os.makedirs(os.path.dirname(os.path.abspath(args.output)), exist_ok=True)
    wb.save(args.output)
    print(f"Written: {args.output} ({len(wb.sheetnames)} sheets)")


if __name__ == "__main__":
    main()