cloudwright-ai 0.3.2__tar.gz → 0.3.4__tar.gz

{cloudwright_ai-0.3.2 → cloudwright_ai-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudwright-ai
-Version: 0.3.2
+Version: 0.3.4
 Summary: Architecture intelligence for cloud engineers — design, cost, compare, export
 Project-URL: Homepage, https://github.com/xmpuspus/cloudwright
 Project-URL: Repository, https://github.com/xmpuspus/cloudwright

{cloudwright_ai-0.3.2 → cloudwright_ai-0.3.4}/cloudwright/__init__.py

@@ -17,7 +17,7 @@ from cloudwright.spec import (
     ValidationResult,
 )
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"
 
 __all__ = [
     "Alternative",

{cloudwright_ai-0.3.2 → cloudwright_ai-0.3.4}/cloudwright/cost.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import logging
 from datetime import date
+from typing import Any
 
 from cloudwright.catalog import _PRICING_MULTIPLIERS, Catalog
 from cloudwright.catalog.formula import PRICING_FORMULAS, default_managed_price
@@ -40,20 +41,202 @@ _SERVICE_EGRESS_OVERRIDES = {
 }
 _DEFAULT_EGRESS_RATE = 0.09
 
+# ---------------------------------------------------------------------------
+# Workload profiles — realistic sizing defaults per environment tier
+# ---------------------------------------------------------------------------
+
+# Config overrides applied to components when a workload profile is active.
+# Only fills in missing config keys; never overwrites explicit values.
+_PROFILE_DEFAULTS: dict[str, dict[str, dict[str, Any]]] = {
+    "small": {
+        # Serverless
+        "lambda": {"monthly_requests": 5_000_000, "avg_duration_ms": 300, "memory_mb": 512},
+        "cloud_functions": {"monthly_requests": 5_000_000, "avg_duration_ms": 300, "memory_mb": 512},
+        "azure_functions": {"monthly_requests": 5_000_000, "avg_duration_ms": 300, "memory_mb": 512},
+        # Databases
+        "rds": {"storage_gb": 50},
+        "aurora": {"storage_gb": 50},
+        "cloud_sql": {"storage_gb": 50},
+        "azure_sql": {"storage_gb": 50},
+        "dynamodb": {"monthly_requests": 5_000_000},
+        # Storage
+        "s3": {"storage_gb": 100},
+        "cloud_storage": {"storage_gb": 100},
+        "blob_storage": {"storage_gb": 100},
+        # CDN
+        "cloudfront": {"estimated_gb": 200},
+        "cloud_cdn": {"estimated_gb": 200},
+        "azure_cdn": {"estimated_gb": 200},
+        # Analytics
+        "bigquery": {"monthly_query_tb": 2, "storage_gb": 200},
+        "redshift": {"num_nodes": 2, "storage_gb": 500},
+        "synapse": {"num_nodes": 2, "storage_gb": 500},
+    },
+    "medium": {
+        # Serverless
+        "lambda": {"monthly_requests": 50_000_000, "avg_duration_ms": 400, "memory_mb": 1024},
+        "cloud_functions": {"monthly_requests": 50_000_000, "avg_duration_ms": 400, "memory_mb": 1024},
+        "azure_functions": {"monthly_requests": 50_000_000, "avg_duration_ms": 400, "memory_mb": 1024},
+        # Databases
+        "rds": {"storage_gb": 200, "multi_az": True},
+        "aurora": {"storage_gb": 200, "multi_az": True},
+        "cloud_sql": {"storage_gb": 200},
+        "azure_sql": {"storage_gb": 200},
+        "dynamodb": {"monthly_requests": 50_000_000},
+        # Storage
+        "s3": {"storage_gb": 500},
+        "cloud_storage": {"storage_gb": 500},
+        "blob_storage": {"storage_gb": 500},
+        # Compute
+        "ec2": {"count": 3},
+        "compute_engine": {"count": 3},
+        "virtual_machines": {"count": 3},
+        # Container orchestration
+        "eks": {"node_count": 6},
+        "gke": {"node_count": 6},
+        "aks": {"node_count": 6},
+        "ecs": {"count": 4},
+        # CDN
+        "cloudfront": {"estimated_gb": 1000},
+        "cloud_cdn": {"estimated_gb": 1000},
+        "azure_cdn": {"estimated_gb": 1000},
+        # Analytics
+        "bigquery": {"monthly_query_tb": 10, "storage_gb": 1000},
+        "redshift": {"num_nodes": 4, "storage_gb": 2000},
+        "synapse": {"num_nodes": 4, "storage_gb": 2000},
+        # Cache
+        "elasticache": {"memory_gb": 13},
+        "memorystore": {"memory_gb": 13},
+        "azure_cache": {"memory_gb": 13},
+    },
+    "large": {
+        # Serverless
+        "lambda": {"monthly_requests": 500_000_000, "avg_duration_ms": 500, "memory_mb": 2048},
+        "cloud_functions": {"monthly_requests": 500_000_000, "avg_duration_ms": 500, "memory_mb": 2048},
+        "azure_functions": {"monthly_requests": 500_000_000, "avg_duration_ms": 500, "memory_mb": 2048},
+        # Databases
+        "rds": {"storage_gb": 1000, "multi_az": True},
+        "aurora": {"storage_gb": 1000, "multi_az": True},
+        "cloud_sql": {"storage_gb": 1000},
+        "azure_sql": {"storage_gb": 1000},
+        "dynamodb": {"monthly_requests": 200_000_000},
+        # Storage
+        "s3": {"storage_gb": 5000},
+        "cloud_storage": {"storage_gb": 5000},
+        "blob_storage": {"storage_gb": 5000},
+        # Compute
+        "ec2": {"count": 6},
+        "compute_engine": {"count": 6},
+        "virtual_machines": {"count": 6},
+        # Container orchestration
+        "eks": {"node_count": 15},
+        "gke": {"node_count": 15},
+        "aks": {"node_count": 15},
+        "ecs": {"count": 10},
+        # CDN
+        "cloudfront": {"estimated_gb": 5000},
+        "cloud_cdn": {"estimated_gb": 5000},
+        "azure_cdn": {"estimated_gb": 5000},
+        # Analytics
+        "bigquery": {"monthly_query_tb": 50, "storage_gb": 5000},
+        "redshift": {"num_nodes": 8, "storage_gb": 10000},
+        "synapse": {"num_nodes": 8, "storage_gb": 10000},
+        # Cache
+        "elasticache": {"memory_gb": 52},
+        "memorystore": {"memory_gb": 52},
+        "azure_cache": {"memory_gb": 52},
+    },
+    "enterprise": {
+        # Serverless
+        "lambda": {"monthly_requests": 2_000_000_000, "avg_duration_ms": 600, "memory_mb": 3072},
+        "cloud_functions": {"monthly_requests": 2_000_000_000, "avg_duration_ms": 600, "memory_mb": 3072},
+        "azure_functions": {"monthly_requests": 2_000_000_000, "avg_duration_ms": 600, "memory_mb": 3072},
+        # Databases
+        "rds": {"storage_gb": 5000, "multi_az": True},
+        "aurora": {"storage_gb": 5000, "multi_az": True},
+        "cloud_sql": {"storage_gb": 5000},
+        "azure_sql": {"storage_gb": 5000},
+        "dynamodb": {"monthly_requests": 1_000_000_000},
+        # Storage
+        "s3": {"storage_gb": 50000},
+        "cloud_storage": {"storage_gb": 50000},
+        "blob_storage": {"storage_gb": 50000},
+        # Compute
+        "ec2": {"count": 20},
+        "compute_engine": {"count": 20},
+        "virtual_machines": {"count": 20},
+        # Container orchestration
+        "eks": {"node_count": 50},
+        "gke": {"node_count": 50},
+        "aks": {"node_count": 50},
+        "ecs": {"count": 30},
+        # CDN
+        "cloudfront": {"estimated_gb": 50000},
+        "cloud_cdn": {"estimated_gb": 50000},
+        "azure_cdn": {"estimated_gb": 50000},
+        # Analytics
+        "bigquery": {"monthly_query_tb": 200, "storage_gb": 50000},
+        "redshift": {"num_nodes": 16, "storage_gb": 50000},
+        "synapse": {"num_nodes": 16, "storage_gb": 50000},
+        # Cache
+        "elasticache": {"memory_gb": 200},
+        "memorystore": {"memory_gb": 200},
+        "azure_cache": {"memory_gb": 200},
+    },
+}
+
+# Default data transfer (GB/month) per connection when a workload profile is active
+# but the connection has no explicit estimated_monthly_gb.
+_PROFILE_TRANSFER_DEFAULTS: dict[str, float] = {
+    "small": 50.0,
+    "medium": 200.0,
+    "large": 1000.0,
+    "enterprise": 5000.0,
+}
+
+VALID_WORKLOAD_PROFILES = set(_PROFILE_DEFAULTS.keys())
+
+
+def _apply_profile(comp: Component, profile: str) -> Component:
+    """Return a copy of the component with profile defaults merged into its config.
+
+    Profile defaults only fill in missing keys — explicit config always wins.
+    """
+    svc_defaults = _PROFILE_DEFAULTS.get(profile, {}).get(comp.service)
+    if not svc_defaults:
+        return comp
+    merged = dict(svc_defaults)
+    merged.update(comp.config or {})
+    return comp.model_copy(update={"config": merged})
+
 
 class CostEngine:
     def __init__(self, catalog: Catalog | None = None, registry: ServiceRegistry | None = None):
         self.catalog = catalog or Catalog()
         self.registry = registry or get_registry()
 
-    def estimate(self, spec: ArchSpec, pricing_tier: str = "on_demand") -> CostEstimate:
-        """Price every component in an ArchSpec and return a full breakdown."""
+    def estimate(
+        self,
+        spec: ArchSpec,
+        pricing_tier: str = "on_demand",
+        workload_profile: str | None = None,
+    ) -> CostEstimate:
+        """Price every component in an ArchSpec and return a full breakdown.
+
+        Args:
+            spec: The architecture specification to price.
+            pricing_tier: Pricing model — on_demand, reserved_1yr, reserved_3yr, spot.
+            workload_profile: Optional sizing profile — small, medium, large, enterprise.
+                When set, applies realistic defaults for request volumes, storage sizes,
+                node counts, and data transfer that match production workloads.
+        """
         breakdown: list[ComponentCost] = []
 
         for comp in spec.components:
-            monthly = self._price_component(comp, spec.provider, spec.region, pricing_tier)
+            effective = _apply_profile(comp, workload_profile) if workload_profile else comp
+            monthly = self._price_component(effective, spec.provider, spec.region, pricing_tier)
             hourly = round(monthly / 730, 4) if monthly > 0 else None
-            notes = self._cost_notes(comp)
+            notes = self._cost_notes(effective)
             breakdown.append(
                 ComponentCost(
                     component_id=comp.id,
@@ -65,7 +248,7 @@ class CostEngine:
             )
 
         component_total = round(sum(c.monthly for c in breakdown), 2)
-        data_transfer = self._estimate_data_transfer(spec)
+        data_transfer = self._estimate_data_transfer(spec, workload_profile=workload_profile)
         total = round(component_total + data_transfer, 2)
 
         return CostEstimate(
@@ -76,12 +259,22 @@ class CostEngine:
             as_of=date.today().isoformat(),
         )
 
-    def price(self, spec: ArchSpec, pricing_tier: str = "on_demand") -> ArchSpec:
+    def price(
+        self,
+        spec: ArchSpec,
+        pricing_tier: str = "on_demand",
+        workload_profile: str | None = None,
+    ) -> ArchSpec:
         """Estimate costs and return a new ArchSpec with cost_estimate attached."""
-        estimate = self.estimate(spec, pricing_tier=pricing_tier)
+        estimate = self.estimate(spec, pricing_tier=pricing_tier, workload_profile=workload_profile)
         return spec.model_copy(update={"cost_estimate": estimate})
 
-    def compare_providers(self, spec: ArchSpec, providers: list[str]) -> list[Alternative]:
+    def compare_providers(
+        self,
+        spec: ArchSpec,
+        providers: list[str],
+        workload_profile: str | None = None,
+    ) -> list[Alternative]:
         """Price the architecture across multiple cloud providers."""
         alternatives: list[Alternative] = []
 
@@ -117,7 +310,7 @@ class CostEngine:
                     "components": mapped_components,
                 }
             )
-            alt_estimate = self.estimate(alt_spec)
+            alt_estimate = self.estimate(alt_spec, workload_profile=workload_profile)
 
             alternatives.append(
                 Alternative(
@@ -216,13 +409,16 @@ class CostEngine:
 
         return round(base, 2)
 
-    def _estimate_data_transfer(self, spec: ArchSpec) -> float:
+    def _estimate_data_transfer(self, spec: ArchSpec, workload_profile: str | None = None) -> float:
         """Estimate monthly data transfer (egress) costs from connections."""
         total = 0.0
         component_map = {c.id: c for c in spec.components}
+        profile_default_gb = _PROFILE_TRANSFER_DEFAULTS.get(workload_profile or "", 0.0)
 
         for conn in spec.connections:
             gb = conn.estimated_monthly_gb
+            if not gb and profile_default_gb:
+                gb = profile_default_gb
             if not gb:
                 continue
             source = component_map.get(conn.source)

{cloudwright_ai-0.3.2 → cloudwright_ai-0.3.4}/cloudwright/importer/__init__.py

@@ -30,6 +30,25 @@ class ImporterPlugin(ABC):
         ...
 
 
+def _apply_import_defaults(spec: "ArchSpec") -> "ArchSpec":
+    _ENCRYPT_SERVICES = {"rds", "aurora", "cloud_sql", "azure_sql", "s3", "cloud_storage", "blob_storage"}
+
+    updated = []
+    changed = False
+    for comp in spec.components:
+        if comp.service in _ENCRYPT_SERVICES and not comp.config.get("encryption"):
+            new_config = dict(comp.config)
+            new_config["encryption"] = True
+            updated.append(comp.model_copy(update={"config": new_config}))
+            changed = True
+        else:
+            updated.append(comp)
+
+    if changed:
+        return spec.model_copy(update={"components": updated})
+    return spec
+
+
 def import_spec(path: str, fmt: str = "auto", design_spec: "ArchSpec | None" = None) -> ArchSpec:
     """Import an ArchSpec from an infrastructure state file.
 
@@ -46,12 +65,14 @@ def import_spec(path: str, fmt: str = "auto", design_spec: "ArchSpec | None" = N
     if fmt == "terraform":
         from cloudwright.importer.terraform_state import TerraformStateImporter
 
-        return TerraformStateImporter().do_import(path, design_spec=design_spec)
+        spec = TerraformStateImporter().do_import(path, design_spec=design_spec)
+        return _apply_import_defaults(spec)
 
     if fmt in ("cloudformation", "cfn"):
         from cloudwright.importer.cloudformation import CloudFormationImporter
 
-        return CloudFormationImporter().do_import(path, design_spec=design_spec)
+        spec = CloudFormationImporter().do_import(path, design_spec=design_spec)
+        return _apply_import_defaults(spec)
 
     raise ValueError(f"Unknown import format: {fmt!r}. Supported: terraform, cloudformation")
 

{cloudwright_ai-0.3.2 → cloudwright_ai-0.3.4}/cloudwright/importer/cloudformation.py

@@ -61,6 +61,34 @@ _CFN_TYPE_MAP: dict[str, str] = {
     # ML
     "AWS::SageMaker::Endpoint": "sagemaker",
     "AWS::SageMaker::Model": "sagemaker",
+    # IAM
+    "AWS::IAM::Role": "iam",
+    "AWS::IAM::Policy": "iam",
+    "AWS::IAM::InstanceProfile": "iam",
+    # Networking
+    "AWS::EC2::VPC": "vpc",
+    "AWS::EC2::Subnet": "vpc",
+    "AWS::EC2::SecurityGroup": "vpc",
+    "AWS::EC2::NatGateway": "nat_gateway",
+    "AWS::EC2::InternetGateway": "vpc",
+    "AWS::EC2::RouteTable": "vpc",
+    # Monitoring
+    "AWS::CloudWatch::Alarm": "cloudwatch",
+    "AWS::Logs::LogGroup": "cloudwatch",
+    "AWS::CloudTrail::Trail": "cloudtrail",
+    # Kinesis
+    "AWS::Kinesis::Stream": "kinesis",
+    # Step Functions
+    "AWS::StepFunctions::StateMachine": "step_functions",
+    # Secrets
+    "AWS::SecretsManager::Secret": "secrets_manager",
+    "AWS::KMS::Key": "kms",
+    # ECR
+    "AWS::ECR::Repository": "ecr",
+    # MSK
+    "AWS::MSK::Cluster": "msk",
+    # EventBridge (additional)
+    "AWS::Scheduler::Schedule": "eventbridge",
 }
 
 _TIER = {
@@ -70,10 +98,15 @@ _TIER = {
     "route53": 1,
     "api_gateway": 1,
     "cognito": 1,
+    "iam": 1,
+    "vpc": 1,
+    "nat_gateway": 1,
     "ec2": 2,
     "lambda": 2,
     "ecs": 2,
     "eks": 2,
+    "step_functions": 2,
+    "sagemaker": 2,
     "rds": 3,
     "aurora": 3,
     "dynamodb": 3,
@@ -82,8 +115,15 @@ _TIER = {
     "sns": 3,
     "eventbridge": 3,
     "redshift": 3,
+    "kinesis": 3,
+    "msk": 3,
     "s3": 4,
     "ebs": 4,
+    "cloudwatch": 4,
+    "cloudtrail": 4,
+    "secrets_manager": 4,
+    "kms": 4,
+    "ecr": 4,
 }
 
 

{cloudwright_ai-0.3.2 → cloudwright_ai-0.3.4}/cloudwright/importer/terraform_state.py

@@ -81,6 +81,81 @@ _TIER = {
     "managed_disks": 4,
 }
 
+_HARDCODED_TF_MAP: dict[str, str] = {
+    # AWS
+    "aws_instance": "ec2",
+    "aws_launch_template": "ec2",
+    "aws_autoscaling_group": "ec2",
+    "aws_ecs_cluster": "ecs",
+    "aws_ecs_service": "ecs",
+    "aws_ecs_task_definition": "ecs",
+    "aws_eks_cluster": "eks",
+    "aws_eks_node_group": "eks",
+    "aws_lambda_function": "lambda",
+    "aws_db_instance": "rds",
+    "aws_rds_cluster": "aurora",
+    "aws_dynamodb_table": "dynamodb",
+    "aws_s3_bucket": "s3",
+    "aws_lb": "alb",
+    "aws_alb": "alb",
+    "aws_lb_target_group": "alb",
+    "aws_cloudfront_distribution": "cloudfront",
+    "aws_route53_zone": "route53",
+    "aws_api_gateway_rest_api": "api_gateway",
+    "aws_apigatewayv2_api": "api_gateway",
+    "aws_wafv2_web_acl": "waf",
+    "aws_cognito_user_pool": "cognito",
+    "aws_elasticache_cluster": "elasticache",
+    "aws_elasticache_replication_group": "elasticache",
+    "aws_sqs_queue": "sqs",
+    "aws_sns_topic": "sns",
+    "aws_kinesis_stream": "kinesis",
+    "aws_redshift_cluster": "redshift",
+    "aws_sagemaker_endpoint": "sagemaker",
+    "aws_nat_gateway": "nat_gateway",
+    "aws_iam_role": "iam",
+    "aws_iam_policy": "iam",
+    "aws_kms_key": "kms",
+    "aws_secretsmanager_secret": "secrets_manager",
+    "aws_ecr_repository": "ecr",
+    "aws_msk_cluster": "msk",
+    "aws_sfn_state_machine": "step_functions",
+    "aws_cloudwatch_log_group": "cloudwatch",
+    "aws_cloudtrail": "cloudtrail",
+    "aws_ebs_volume": "ebs",
+    # GCP
+    "google_compute_instance": "compute_engine",
+    "google_container_cluster": "gke",
+    "google_container_node_pool": "gke",
+    "google_cloud_run_service": "cloud_run",
+    "google_cloudfunctions_function": "cloud_functions",
+    "google_cloudfunctions2_function": "cloud_functions",
+    "google_sql_database_instance": "cloud_sql",
+    "google_storage_bucket": "cloud_storage",
+    "google_compute_backend_service": "cloud_load_balancing",
+    "google_pubsub_topic": "pub_sub",
+    "google_bigquery_dataset": "bigquery",
+    "google_redis_instance": "memorystore",
+    "google_spanner_instance": "spanner",
+    "google_compute_address": "compute_engine",
+    # Azure
+    "azurerm_virtual_machine": "virtual_machines",
+    "azurerm_linux_virtual_machine": "virtual_machines",
+    "azurerm_windows_virtual_machine": "virtual_machines",
+    "azurerm_kubernetes_cluster": "aks",
+    "azurerm_function_app": "azure_functions",
+    "azurerm_mssql_server": "azure_sql",
+    "azurerm_mssql_database": "azure_sql",
+    "azurerm_cosmosdb_account": "cosmos_db",
+    "azurerm_storage_account": "blob_storage",
+    "azurerm_redis_cache": "azure_cache",
+    "azurerm_application_gateway": "app_gateway",
+    "azurerm_lb": "azure_lb",
+    "azurerm_cdn_profile": "azure_cdn",
+    "azurerm_servicebus_namespace": "service_bus",
+    "azurerm_eventhub_namespace": "event_hubs",
+}
+
 _REGISTRY_DIR = Path(__file__).parent.parent / "data" / "registry"
 
 
@@ -120,7 +195,8 @@ class TerraformStateImporter:
     """Parses Terraform state files (v3 and v4) into ArchSpec."""
 
     def __init__(self) -> None:
-        self._tf_map = _build_terraform_map()
+        self._tf_map = dict(_HARDCODED_TF_MAP)  # start with hardcoded fallbacks
+        self._tf_map.update(_build_terraform_map())  # registry overrides take precedence
 
     @property
     def format_name(self) -> str:

{cloudwright_ai-0.3.2 → cloudwright_ai-0.3.4}/tests/test_cfn_importer.py

@@ -166,7 +166,7 @@ class TestInlineTemplate:
             "AWSTemplateFormatVersion": "2010-09-09",
             "Resources": {
                 "CustomResource": {"Type": "Custom::MyThing", "Properties": {}},
-                "IamRole": {"Type": "AWS::IAM::Role", "Properties": {}},
+                "UnknownWidget": {"Type": "AWS::Foo::Bar", "Properties": {}},
                 "Web": {"Type": "AWS::EC2::Instance", "Properties": {}},
             },
         }
@@ -174,6 +174,6 @@ class TestInlineTemplate:
         p.write_text(json.dumps(template))
 
         spec = import_spec(str(p), fmt="cloudformation")
-        # Only ec2 should be imported
+        # Custom::* and unknown AWS types should be skipped
         assert len(spec.components) == 1
         assert spec.components[0].service == "ec2"