focus-data-toolkit 0.11.0__py3-none-any.whl

focus_data_toolkit/generators/providers/aws.py

@@ -0,0 +1,186 @@
+"""AWS provider profile (FOCUS synthetic data)."""
+
+from __future__ import annotations
+
+import json
+import random
+from decimal import Decimal
+
+from focus_data_toolkit.generators.engine.determinism import hexid
+from focus_data_toolkit.generators.providers.profile import (
+    CommitmentModel,
+    ProviderProfile,
+    ResourceRef,
+    RowContext,
+    ServiceSpec,
+)
+
+_SERVICES: tuple[ServiceSpec, ...] = (
+    ServiceSpec(
+        "AmazonEC2", "Compute", "Virtual Machines", "EC2 Instance",
+        "Compute", "Hours", "Linux on-demand m6i.large", Decimal("0.096"),
+        Decimal("1"), Decimal("1"), "i-", "hourly", True, True,
+        id_fields={"arn_kind": "instance"},
+        sku_details={
+            "InstanceType": "m6i.large", "InstanceSeries": "M6i", "CoreCount": 2,
+            "MemorySize": 8, "OperatingSystem": "Linux", "x_Tenancy": "Shared",
+        },
+    ),
+    ServiceSpec(
+        "AmazonS3", "Storage", "Object Storage", "S3 Bucket",
+        "Storage", "GB-Months", "S3 Standard storage", Decimal("0.023"),
+        Decimal("50"), Decimal("8000"), "bucket-", "monthly", False, False,
+        id_fields={"arn_kind": "bucket"},
+        sku_details={"StorageClass": "Standard", "Redundancy": "LRS"},
+    ),
+    ServiceSpec(
+        "AmazonRDS", "Databases", "Relational Databases", "RDS Instance",
+        "Database", "Hours", "RDS PostgreSQL db.r6g.large", Decimal("0.240"),
+        Decimal("1"), Decimal("1"), "db-", "hourly", False, False,
+        id_fields={"arn_kind": "db"},
+        sku_details={
+            "InstanceType": "db.r6g.large", "InstanceSeries": "R6g", "CoreCount": 2,
+            "MemorySize": 16, "x_Engine": "PostgreSQL",
+        },
+    ),
+    ServiceSpec(
+        "AWSLambda", "Compute", "Serverless Compute", "Lambda Function",
+        "Compute", "GB-Seconds", "Lambda function duration", Decimal("0.0000166667"),
+        Decimal("100000"), Decimal("5000000"), "fn-", "hourly", False, False,
+        id_fields={"arn_kind": "function"},
+        sku_details={"x_Runtime": "python3.12", "x_Architecture": "arm64"},
+    ),
+    ServiceSpec(
+        "AmazonVPC", "Networking", "Network Connectivity", "NAT Gateway",
+        "Data Transfer", "GB", "NAT gateway data processed", Decimal("0.045"),
+        Decimal("1"), Decimal("500"), "nat-", "daily", False, False,
+        id_fields={"arn_kind": "natgateway"},
+        sku_details={"x_TransferType": "InterAZ"},
+    ),
+    ServiceSpec(
+        "AmazonCloudWatch", "Management and Governance", "Observability", "Metric",
+        "Monitoring", "Metrics", "Custom metrics", Decimal("0.300"),
+        Decimal("1"), Decimal("200"), "metric-", "daily", False, False,
+        id_fields={"arn_kind": "metric"},
+        sku_details={"x_MetricType": "Custom"},
+    ),
+    ServiceSpec(
+        "AmazonDynamoDB", "Databases", "NoSQL Databases", "DynamoDB Table",
+        "Database", "Requests", "DynamoDB on-demand write requests", Decimal("0.00000125"),
+        Decimal("100000"), Decimal("5000000"), "table-", "daily", False, False,
+        id_fields={"arn_kind": "table"},
+        sku_details={"x_CapacityMode": "On-Demand"},
+    ),
+    ServiceSpec(
+        "AWSGlue", "Analytics", "Data Processing", "Glue Job",
+        "Data Processing", "DPU-Hours", "Glue ETL job run", Decimal("0.440"),
+        Decimal("1"), Decimal("200"), "job-", "daily", False, False,
+        id_fields={"arn_kind": "job"},
+        sku_details={"x_WorkerType": "G.1X"},
+    ),
+)
+
+_REGIONS: tuple[tuple[str, str, tuple[str, ...]], ...] = (
+    ("us-east-1", "US East (N. Virginia)", ("us-east-1a", "us-east-1b", "us-east-1c")),
+    ("us-west-2", "US West (Oregon)", ("us-west-2a", "us-west-2b")),
+    ("eu-west-1", "EU (Ireland)", ("eu-west-1a", "eu-west-1b")),
+    ("ap-southeast-1", "Asia Pacific (Singapore)", ("ap-southeast-1a", "ap-southeast-1b")),
+)
+
+_BILLING_ACCOUNTS: tuple[tuple[str, str], ...] = (
+    ("100000000001", "ExampleCorp Master Payer"),
+    ("100000000002", "ExampleCorp Secondary Payer"),
+)
+
+_SUB_ACCOUNTS: tuple[tuple[str, str], ...] = (
+    ("200000000011", "prod-platform"),
+    ("200000000012", "staging-platform"),
+    ("200000000013", "data-analytics"),
+    ("200000000014", "sandbox-dev"),
+)
+
+
+def _resource_id(ref: ResourceRef) -> str:
+    svc = ref.spec.name[6:].lower() or "svc"
+    return (
+        f"arn:aws:{svc}:{ref.region_id}:{ref.billing_id}:"
+        f"{ref.spec.id_fields['arn_kind']}/{ref.resource_name}"
+    )
+
+
+def _resource_name(rng: random.Random, spec: ServiceSpec) -> str:
+    return f"{spec.name_prefix}{hexid(rng, 12)}"
+
+
+def _committed_resource_name(rng: random.Random, spec: ServiceSpec, k: int) -> str:
+    return f"{spec.name_prefix}{k:04d}{hexid(rng, 8)}"
+
+
+def _sku_id(rng: random.Random, spec: ServiceSpec) -> str:
+    return f"SKU-{spec.name[:6].upper()}-{hexid(rng, 6)}"
+
+
+def _sku_price_id(rng: random.Random) -> str:
+    return f"SPRICE-{hexid(rng, 8)}"
+
+
+def _allocated_resource_id(rng: random.Random, region_id: str, ctx: RowContext, workload: str) -> str:
+    return f"arn:aws:eks:{region_id}:{ctx.billing_id}:workload/{workload}-{hexid(rng, 6)}"
+
+
+def _commit_id(rng: random.Random, region_id: str, sub_id: str, spend_based: bool) -> str:
+    commit_kind = "savingsplan" if spend_based else "reservation"
+    service = "savingsplans" if spend_based else "ec2"
+    return f"arn:aws:{service}:{region_id}::{commit_kind}/{hexid(rng, 16)}"
+
+
+def _commit_resource_name(rng: random.Random, spend_based: bool) -> str:
+    commit_kind = "savingsplan" if spend_based else "reservation"
+    return f"{commit_kind}-{hexid(rng, 12)}"
+
+
+def _purchase_sku_id(rng: random.Random) -> str:
+    return f"SKU-COMMIT-{hexid(rng, 6)}"
+
+
+def _purchase_sku_details(spend_based: bool) -> str:
+    return json.dumps({"x_PurchaseTerm": "1yr", "x_PaymentOption": "AllUpfront"}, separators=(",", ":"))
+
+
+AWS = ProviderProfile(
+    key="aws",
+    provider_name="AWS",
+    publisher_name="AWS",
+    service_provider_name="AWS",
+    host_provider_name="AWS",
+    invoice_issuer_name="AWS",
+    billing_account_type="Payer Account",
+    sub_account_type="Linked Account",
+    split_allocation_description="Shared EC2 host cost allocated to workload",
+    tag_keys=("Environment", "CostCenter", "Owner"),
+    invoice_id=lambda billing_id: f"INV-2026-05-{billing_id[-4:]}",
+    services=_SERVICES,
+    regions=_REGIONS,
+    billing_accounts=_BILLING_ACCOUNTS,
+    sub_accounts=_SUB_ACCOUNTS,
+    resource_id=_resource_id,
+    resource_name=_resource_name,
+    committed_resource_name=_committed_resource_name,
+    sku_id=_sku_id,
+    sku_price_id=_sku_price_id,
+    allocated_resource_id=_allocated_resource_id,
+    commitment=CommitmentModel(
+        commit_id_before_base_row=True,
+        commit_id=_commit_id,
+        commit_resource_name=_commit_resource_name,
+        purchase_sku_id=_purchase_sku_id,
+        purchase_sku_details=_purchase_sku_details,
+        purchase_description=lambda commit_type: f"{commit_type} commitment purchase (all upfront)",
+        commit_name=lambda spend_based: (
+            "ComputeSavingsPlan-1yr-AllUpfront" if spend_based else "EC2ReservedInstance-1yr-AllUpfront"
+        ),
+        commit_type=lambda spend_based: "Savings Plan" if spend_based else "Reserved Instance",
+        commit_category=lambda spend_based: "Spend" if spend_based else "Usage",
+        commit_unit=lambda spend_based: "USD" if spend_based else "Hours",
+    ),
+)

focus_data_toolkit/generators/providers/azure.py

@@ -0,0 +1,191 @@
+"""Microsoft Azure provider profile (FOCUS synthetic data)."""
+
+from __future__ import annotations
+
+import json
+import random
+from decimal import Decimal
+
+from focus_data_toolkit.generators.engine.determinism import hexid
+from focus_data_toolkit.generators.providers.profile import (
+    CommitmentModel,
+    ProviderProfile,
+    ResourceRef,
+    RowContext,
+    ServiceSpec,
+)
+
+_SERVICES: tuple[ServiceSpec, ...] = (
+    ServiceSpec(
+        "Virtual Machines", "Compute", "Virtual Machines", "Virtual Machine",
+        "Compute", "Hours", "Standard_D4s_v5 instance", Decimal("0.192"),
+        Decimal("1"), Decimal("1"), "vm-", "hourly", True, True,
+        id_fields={"arm_type": "Microsoft.Compute/virtualMachines"},
+        sku_details={
+            "InstanceType": "Standard_D4s_v5", "InstanceSeries": "Ddsv5", "CoreCount": 4,
+            "MemorySize": 16, "OperatingSystem": "Linux", "x_Tenancy": "Shared",
+        },
+    ),
+    ServiceSpec(
+        "Azure Blob Storage", "Storage", "Object Storage", "Storage Account",
+        "Storage", "GB-Months", "Hot LRS data stored", Decimal("0.0184"),
+        Decimal("50"), Decimal("8000"), "stor", "monthly", False, False,
+        id_fields={"arm_type": "Microsoft.Storage/storageAccounts"},
+        sku_details={"StorageClass": "Hot", "Redundancy": "LRS"},
+    ),
+    ServiceSpec(
+        "Azure SQL Database", "Databases", "Relational Databases", "SQL Database",
+        "Database", "Hours", "General Purpose 4 vCore", Decimal("0.504"),
+        Decimal("1"), Decimal("1"), "sqldb-", "hourly", False, False,
+        id_fields={"arm_type": "Microsoft.Sql/servers/databases"},
+        sku_details={"InstanceType": "GP_Gen5_4", "CoreCount": 4, "MemorySize": 20, "x_Engine": "SQLServer"},
+    ),
+    ServiceSpec(
+        "Azure Functions", "Compute", "Serverless Compute", "Function App",
+        "Compute", "GB-Seconds", "Function execution duration", Decimal("0.000016"),
+        Decimal("100000"), Decimal("4000000"), "func-", "hourly", False, False,
+        id_fields={"arm_type": "Microsoft.Web/sites"},
+        sku_details={"x_Plan": "Consumption", "x_Runtime": "dotnet8"},
+    ),
+    ServiceSpec(
+        "Azure Kubernetes Service", "Compute", "Containers", "Managed Cluster",
+        "Compute", "Hours", "AKS node pool hours", Decimal("0.192"),
+        Decimal("1"), Decimal("1"), "aks-", "hourly", False, False,
+        id_fields={"arm_type": "Microsoft.ContainerService/managedClusters"},
+        sku_details={
+            "InstanceType": "Standard_D4s_v5", "CoreCount": 4, "MemorySize": 16,
+            "x_NodePool": "system",
+        },
+    ),
+    ServiceSpec(
+        "Azure Monitor", "Management and Governance", "Observability", "Log Analytics Workspace",
+        "Monitoring", "GB", "Log data ingested", Decimal("2.30"),
+        Decimal("1"), Decimal("500"), "law-", "daily", False, False,
+        id_fields={"arm_type": "Microsoft.OperationalInsights/workspaces"},
+        sku_details={"x_DataType": "Logs"},
+    ),
+    ServiceSpec(
+        "Azure Cosmos DB", "Databases", "NoSQL Databases", "Cosmos DB Account",
+        "Database", "Hours", "Provisioned throughput", Decimal("0.008"),
+        Decimal("1"), Decimal("1"), "cosmos-", "hourly", False, False,
+        id_fields={"arm_type": "Microsoft.DocumentDB/databaseAccounts"},
+        sku_details={"x_CapacityMode": "Provisioned"},
+    ),
+    ServiceSpec(
+        "Virtual Network", "Networking", "Network Connectivity", "Virtual Network",
+        "Data Transfer", "GB", "VNet peering data transfer", Decimal("0.010"),
+        Decimal("1"), Decimal("5000"), "vnet-", "daily", False, False,
+        id_fields={"arm_type": "Microsoft.Network/virtualNetworks"},
+        sku_details={"x_TransferType": "Peering"},
+    ),
+)
+
+_REGIONS: tuple[tuple[str, str, tuple[str, ...]], ...] = (
+    ("eastus", "East US", ("eastus-1", "eastus-2", "eastus-3")),
+    ("westeurope", "West Europe", ("westeurope-1", "westeurope-2")),
+    ("westus2", "West US 2", ("westus2-1", "westus2-2")),
+    ("southeastasia", "Southeast Asia", ("southeastasia-1", "southeastasia-2")),
+)
+
+_BILLING_ACCOUNTS: tuple[tuple[str, str], ...] = (
+    ("8a1b2c3d-0000-4a00-9000-000000000001", "ExampleCorp MCA - Primary"),
+    ("8a1b2c3d-0000-4a00-9000-000000000002", "ExampleCorp MCA - Secondary"),
+)
+
+_SUB_ACCOUNTS: tuple[tuple[str, str], ...] = (
+    ("11111111-1111-4111-8111-111111111111", "prod-platform"),
+    ("22222222-2222-4222-8222-222222222222", "staging-platform"),
+    ("33333333-3333-4333-8333-333333333333", "data-analytics"),
+    ("44444444-4444-4444-8444-444444444444", "sandbox-dev"),
+)
+
+
+def _arm_id(ref: ResourceRef) -> str:
+    return (
+        f"/subscriptions/{ref.sub_id}/resourceGroups/rg-{ref.sub_name}"
+        f"/providers/{ref.spec.id_fields['arm_type']}/{ref.resource_name}"
+    )
+
+
+def _resource_name(rng: random.Random, spec: ServiceSpec) -> str:
+    return f"{spec.name_prefix}{hexid(rng, 8)}"
+
+
+def _committed_resource_name(rng: random.Random, spec: ServiceSpec, k: int) -> str:
+    return f"{spec.name_prefix}{k:04d}{hexid(rng, 6)}"
+
+
+def _sku_id(rng: random.Random, spec: ServiceSpec) -> str:
+    return f"AZ-{spec.name[:4].upper().strip()}-{hexid(rng, 6)}"
+
+
+def _sku_price_id(rng: random.Random) -> str:
+    return f"AZSP-{hexid(rng, 8)}"
+
+
+def _allocated_resource_id(rng: random.Random, region_id: str, ctx: RowContext, workload: str) -> str:
+    return (
+        f"/subscriptions/{ctx.sub_id}/resourceGroups/rg-{ctx.sub_name}"
+        f"/providers/Microsoft.ContainerService/managedClusters/aks-{hexid(rng, 6)}"
+        f"/workloads/{workload}"
+    )
+
+
+def _commit_id(rng: random.Random, region_id: str, sub_id: str, spend_based: bool) -> str:
+    commit_kind = "savingsPlans" if spend_based else "reservations"
+    return (
+        f"/subscriptions/{sub_id}/providers/Microsoft.BillingBenefits"
+        f"/{commit_kind}/{hexid(rng, 12)}"
+    )
+
+
+def _commit_resource_name(rng: random.Random, spend_based: bool) -> str:
+    commit_kind = "savingsPlans" if spend_based else "reservations"
+    return f"{commit_kind}-{hexid(rng, 10)}"
+
+
+def _purchase_sku_id(rng: random.Random) -> str:
+    return f"AZ-COMMIT-{hexid(rng, 6)}"
+
+
+def _purchase_sku_details(spend_based: bool) -> str:
+    return json.dumps({"x_Term": "P1Y", "x_PaymentOption": "AllUpfront"}, separators=(",", ":"))
+
+
+AZURE = ProviderProfile(
+    key="azure",
+    provider_name="Microsoft Azure",
+    publisher_name="Microsoft",
+    service_provider_name="Microsoft Azure",
+    host_provider_name="Microsoft Azure",
+    invoice_issuer_name="Microsoft Azure",
+    billing_account_type="Microsoft Customer Agreement",
+    sub_account_type="Subscription",
+    split_allocation_description="Shared VM host cost allocated to workload",
+    tag_keys=("Environment", "CostCenter", "Owner"),
+    invoice_id=lambda billing_id: f"INV-2026-05-{billing_id[-6:]}",
+    services=_SERVICES,
+    regions=_REGIONS,
+    billing_accounts=_BILLING_ACCOUNTS,
+    sub_accounts=_SUB_ACCOUNTS,
+    resource_id=_arm_id,
+    resource_name=_resource_name,
+    committed_resource_name=_committed_resource_name,
+    sku_id=_sku_id,
+    sku_price_id=_sku_price_id,
+    allocated_resource_id=_allocated_resource_id,
+    commitment=CommitmentModel(
+        commit_id_before_base_row=False,
+        commit_id=_commit_id,
+        commit_resource_name=_commit_resource_name,
+        purchase_sku_id=_purchase_sku_id,
+        purchase_sku_details=_purchase_sku_details,
+        purchase_description=lambda commit_type: f"{commit_type} commitment purchase (all upfront)",
+        commit_name=lambda spend_based: (
+            "AzureSavingsPlan-1yr-AllUpfront" if spend_based else "AzureReservation-1yr-AllUpfront"
+        ),
+        commit_type=lambda spend_based: "Savings Plan" if spend_based else "Reservation",
+        commit_category=lambda spend_based: "Spend" if spend_based else "Usage",
+        commit_unit=lambda spend_based: "USD" if spend_based else "Hours",
+    ),
+)

focus_data_toolkit/generators/providers/gcp.py

@@ -0,0 +1,194 @@
+"""Google Cloud provider profile (FOCUS synthetic data)."""
+
+from __future__ import annotations
+
+import json
+import random
+from decimal import Decimal
+
+from focus_data_toolkit.generators.engine.determinism import HEX_UPPER, hexid
+from focus_data_toolkit.generators.providers.profile import (
+    CommitmentModel,
+    ProviderProfile,
+    ResourceRef,
+    RowContext,
+    ServiceSpec,
+)
+
+_SERVICES: tuple[ServiceSpec, ...] = (
+    ServiceSpec(
+        "Compute Engine", "Compute", "Virtual Machines", "Compute Instance",
+        "Compute", "Hours", "e2-standard-4 running", Decimal("0.134"),
+        Decimal("1"), Decimal("1"), "instance-", "hourly", True, True,
+        id_fields={"api": "compute.googleapis.com", "collection": "instances"},
+        sku_details={
+            "InstanceType": "e2-standard-4", "InstanceSeries": "E2", "CoreCount": 4,
+            "MemorySize": 16, "OperatingSystem": "Linux", "x_Preemptible": "false",
+        },
+    ),
+    ServiceSpec(
+        "Cloud Storage", "Storage", "Object Storage", "Storage Bucket",
+        "Storage", "GB-Months", "Standard storage", Decimal("0.020"),
+        Decimal("50"), Decimal("8000"), "bucket-", "monthly", False, False,
+        id_fields={"api": "storage.googleapis.com", "collection": "buckets"},
+        sku_details={"StorageClass": "Standard"},
+    ),
+    ServiceSpec(
+        "Cloud SQL", "Databases", "Relational Databases", "Cloud SQL Instance",
+        "Database", "Hours", "Cloud SQL custom 4 vCPU", Decimal("0.200"),
+        Decimal("1"), Decimal("1"), "sql-", "hourly", False, False,
+        id_fields={"api": "sqladmin.googleapis.com", "collection": "instances"},
+        sku_details={"InstanceType": "db-custom-4-16384", "CoreCount": 4, "MemorySize": 16,
+                     "x_Engine": "PostgreSQL"},
+    ),
+    ServiceSpec(
+        "Cloud Functions", "Compute", "Serverless Compute", "Cloud Function",
+        "Compute", "GB-Seconds", "Function execution duration", Decimal("0.0000025"),
+        Decimal("100000"), Decimal("8000000"), "fn-", "hourly", False, False,
+        id_fields={"api": "cloudfunctions.googleapis.com", "collection": "functions"},
+        sku_details={"x_Runtime": "python312", "x_Generation": "gen2"},
+    ),
+    ServiceSpec(
+        "Google Kubernetes Engine", "Compute", "Containers", "GKE Cluster",
+        "Compute", "Hours", "GKE node pool hours", Decimal("0.134"),
+        Decimal("1"), Decimal("1"), "gke-", "hourly", False, False,
+        id_fields={"api": "container.googleapis.com", "collection": "clusters"},
+        sku_details={
+            "InstanceType": "e2-standard-4", "CoreCount": 4, "MemorySize": 16,
+            "x_NodePool": "default",
+        },
+    ),
+    ServiceSpec(
+        "Cloud Monitoring", "Management and Governance", "Observability", "Monitoring Workspace",
+        "Monitoring", "MiB", "Monitoring data ingested", Decimal("0.2580"),
+        Decimal("1"), Decimal("300"), "mon-", "daily", False, False,
+        id_fields={"api": "monitoring.googleapis.com", "collection": "metricsScopes"},
+        sku_details={"x_DataType": "Metrics"},
+    ),
+    ServiceSpec(
+        "BigQuery", "Databases", "Data Warehouses", "BigQuery Dataset",
+        "Analysis", "TiB", "On-demand query analysis", Decimal("6.250"),
+        Decimal("0.01"), Decimal("50"), "ds_", "daily", False, False,
+        id_fields={"api": "bigquery.googleapis.com", "collection": "datasets"},
+        sku_details={"x_Edition": "OnDemand"},
+    ),
+    ServiceSpec(
+        "Cloud Run", "Compute", "Serverless Compute", "Cloud Run Service",
+        "Compute", "Core-Seconds", "Cloud Run vCPU allocation", Decimal("0.000024"),
+        Decimal("100000"), Decimal("5000000"), "svc-", "hourly", False, False,
+        id_fields={"api": "run.googleapis.com", "collection": "services"},
+        sku_details={"x_Generation": "gen2"},
+    ),
+)
+
+_REGIONS: tuple[tuple[str, str, tuple[str, ...]], ...] = (
+    ("us-central1", "Iowa", ("us-central1-a", "us-central1-b", "us-central1-c")),
+    ("europe-west1", "Belgium", ("europe-west1-b", "europe-west1-c")),
+    ("us-east1", "South Carolina", ("us-east1-b", "us-east1-c")),
+    ("asia-southeast1", "Singapore", ("asia-southeast1-a", "asia-southeast1-b")),
+)
+
+_BILLING_ACCOUNTS: tuple[tuple[str, str], ...] = (
+    ("01A2B3-C4D5E6-F70819", "ExampleCorp Billing - Primary"),
+    ("11C2D3-E4F506-A7B8C9", "ExampleCorp Billing - Secondary"),
+)
+
+_SUB_ACCOUNTS: tuple[tuple[str, str], ...] = (
+    ("examplecorp-prod-481627", "prod-platform"),
+    ("examplecorp-staging-552831", "staging-platform"),
+    ("examplecorp-data-739104", "data-analytics"),
+    ("examplecorp-sandbox-160942", "sandbox-dev"),
+)
+
+
+def _sku(rng: random.Random) -> str:
+    def block() -> str:
+        return hexid(rng, 4, HEX_UPPER)
+
+    return f"{block()}-{block()}-{block()}"
+
+
+def _resource_id(ref: ResourceRef) -> str:
+    return (
+        f"//{ref.spec.id_fields['api']}/projects/{ref.sub_id}"
+        f"/{ref.spec.id_fields['collection']}/{ref.resource_name}"
+    )
+
+
+def _resource_name(rng: random.Random, spec: ServiceSpec) -> str:
+    return f"{spec.name_prefix}{hexid(rng, 8)}"
+
+
+def _committed_resource_name(rng: random.Random, spec: ServiceSpec, k: int) -> str:
+    return f"{spec.name_prefix}{k:04d}{hexid(rng, 6)}"
+
+
+def _sku_id(rng: random.Random, spec: ServiceSpec) -> str:
+    return _sku(rng)
+
+
+def _sku_price_id(rng: random.Random) -> str:
+    return _sku(rng)
+
+
+def _allocated_resource_id(rng: random.Random, region_id: str, ctx: RowContext, workload: str) -> str:
+    return (
+        f"//container.googleapis.com/projects/{ctx.sub_id}/clusters/gke-{hexid(rng, 6)}"
+        f"/workloads/{workload}"
+    )
+
+
+def _commit_id(rng: random.Random, region_id: str, sub_id: str, spend_based: bool) -> str:
+    return (
+        f"//compute.googleapis.com/projects/{sub_id}/regions/{region_id}"
+        f"/commitments/cud-{hexid(rng, 10)}"
+    )
+
+
+def _commit_resource_name(rng: random.Random, spend_based: bool) -> str:
+    return f"cud-{hexid(rng, 10)}"
+
+
+def _purchase_sku_id(rng: random.Random) -> str:
+    return _sku(rng)
+
+
+def _purchase_sku_details(spend_based: bool) -> str:
+    return json.dumps({"x_Plan": "TWELVE_MONTH", "x_Type": "COMPUTE_OPTIMIZED"}, separators=(",", ":"))
+
+
+GCP = ProviderProfile(
+    key="gcp",
+    provider_name="Google Cloud",
+    publisher_name="Google",
+    service_provider_name="Google Cloud",
+    host_provider_name="Google Cloud",
+    invoice_issuer_name="Google Cloud",
+    billing_account_type="Billing Account",
+    sub_account_type="Project",
+    split_allocation_description="Shared Compute Engine host cost allocated to workload",
+    tag_keys=("environment", "cost-center", "owner"),
+    invoice_id=lambda billing_id: f"INV-2026-05-{billing_id.replace('-', '')[-6:]}",
+    services=_SERVICES,
+    regions=_REGIONS,
+    billing_accounts=_BILLING_ACCOUNTS,
+    sub_accounts=_SUB_ACCOUNTS,
+    resource_id=_resource_id,
+    resource_name=_resource_name,
+    committed_resource_name=_committed_resource_name,
+    sku_id=_sku_id,
+    sku_price_id=_sku_price_id,
+    allocated_resource_id=_allocated_resource_id,
+    commitment=CommitmentModel(
+        commit_id_before_base_row=False,
+        commit_id=_commit_id,
+        commit_resource_name=_commit_resource_name,
+        purchase_sku_id=_purchase_sku_id,
+        purchase_sku_details=_purchase_sku_details,
+        purchase_description=lambda commit_type: "Committed Use Discount purchase (all upfront)",
+        commit_name=lambda spend_based: "SpendBasedCUD-1yr" if spend_based else "ResourceBasedCUD-1yr-Compute",
+        commit_type=lambda spend_based: "Committed Use Discount",
+        commit_category=lambda spend_based: "Spend" if spend_based else "Usage",
+        commit_unit=lambda spend_based: "USD" if spend_based else "Hours",
+    ),
+)