service-capacity-modeling 0.3.105__py3-none-any.whl → 0.3.106__py3-none-any.whl

service_capacity_modeling/capacity_planner.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# pylint: disable=too-many-lines
 import functools
 import logging
 import math
@@ -23,6 +24,9 @@ from service_capacity_modeling.interface import CapacityPlan
 from service_capacity_modeling.interface import CapacityRegretParameters
 from service_capacity_modeling.interface import CapacityRequirement
 from service_capacity_modeling.interface import certain_float
+from service_capacity_modeling.interface import ClusterCapacity
+from service_capacity_modeling.interface import Clusters
+from service_capacity_modeling.interface import CurrentClusterCapacity
 from service_capacity_modeling.interface import DataShape
 from service_capacity_modeling.interface import Drive
 from service_capacity_modeling.interface import Hardware
@@ -33,10 +37,15 @@ from service_capacity_modeling.interface import Lifecycle
 from service_capacity_modeling.interface import PlanExplanation
 from service_capacity_modeling.interface import Platform
 from service_capacity_modeling.interface import QueryPattern
+from service_capacity_modeling.interface import RegionClusterCapacity
 from service_capacity_modeling.interface import RegionContext
 from service_capacity_modeling.interface import Requirements
+from service_capacity_modeling.interface import ServiceCapacity
 from service_capacity_modeling.interface import UncertainCapacityPlan
+from service_capacity_modeling.interface import ZoneClusterCapacity
 from service_capacity_modeling.models import CapacityModel
+from service_capacity_modeling.models import CostAwareModel
+from service_capacity_modeling.models.common import get_disk_size_gib
 from service_capacity_modeling.models.common import merge_plan
 from service_capacity_modeling.models.org import netflix
 from service_capacity_modeling.models.utils import reduce_by_family
@@ -211,6 +220,78 @@ def _set_instance_objects(
                 )
 
 
+def _extract_cluster_plan(
+    clusters: Sequence[CurrentClusterCapacity],
+    hardware: Hardware,
+    is_zonal: bool,
+) -> Tuple[List[ClusterCapacity], List[CapacityRequirement]]:
+    """Extract CapacityPlan components from current deployment.
+
+    Takes what's currently deployed and builds the ClusterCapacity and
+    CapacityRequirement objects needed for a CapacityPlan.
+
+    Drives are priced using hardware.price_drive() to get catalog pricing.
+    Cluster annual_cost is computed automatically from instance + drives.
+
+    Args:
+        clusters: Current cluster capacities (must have cluster_type set)
+        hardware: Hardware catalog for the region (used to price drives)
+        is_zonal: True for ZoneClusterCapacity, False for RegionClusterCapacity
+
+    Returns:
+        Tuple of (capacities, requirements) for building CapacityPlan
+
+    Raises:
+        ValueError: If any cluster is missing cluster_type
+    """
+    capacities: List[ClusterCapacity] = []
+    requirements: List[CapacityRequirement] = []
+
+    for current in clusters:
+        if current.cluster_type is None:
+            raise ValueError(
+                f"cluster_type is required for baseline extraction. "
+                f"Cluster '{current.cluster_instance_name}' is missing cluster_type."
+            )
+        cluster_type = current.cluster_type
+        instance = current.cluster_instance
+        if instance is None:
+            raise ValueError(
+                f"cluster_instance not resolved for '{current.cluster_instance_name}'"
+            )
+        count = int(current.cluster_instance_count.mid)
+
+        # Price the drive from hardware catalog (gets annual_cost_per_gib etc.)
+        attached_drives = []
+        if current.cluster_drive is not None:
+            attached_drives.append(hardware.price_drive(current.cluster_drive))
+
+        disk_gib = get_disk_size_gib(current.cluster_drive, instance)
+
+        capacity_cls = ZoneClusterCapacity if is_zonal else RegionClusterCapacity
+        capacities.append(
+            capacity_cls(
+                cluster_type=cluster_type,
+                count=count,
+                instance=instance,
+                attached_drives=attached_drives,
+            )
+        )
+
+        requirements.append(
+            CapacityRequirement(
+                requirement_type=cluster_type,
+                reference_shape=instance,
+                cpu_cores=certain_float(instance.cpu * count),
+                mem_gib=certain_float(instance.ram_gib * count),
+                network_mbps=certain_float(instance.net_mbps * count),
+                disk_gib=certain_float(disk_gib * count),
+            )
+        )
+
+    return capacities, requirements
+
+
 def _allow_instance(
     instance: Instance,
     allowed_names: Sequence[str],
@@ -340,6 +421,7 @@ class CapacityPlanner:
     ) -> None:
         self._shapes: HardwareShapes = shapes
         self._models: Dict[str, CapacityModel] = {}
+        self._cluster_types: Dict[str, str] = {}  # cluster_type -> model_name
 
         self._default_num_simulations = default_num_simulations
         self._default_num_results = default_num_results
@@ -351,6 +433,25 @@ class CapacityPlanner:
             self.register_model(name, model)
 
     def register_model(self, name: str, capacity_model: CapacityModel) -> None:
+        if isinstance(capacity_model, CostAwareModel):
+            # Validate required attributes
+            sn = getattr(capacity_model, "service_name", None)
+            ct = getattr(capacity_model, "cluster_type", None)
+            if not sn or not ct:
+                raise ValueError(
+                    f"CostAwareModel '{name}' must define service_name and "
+                    f"cluster_type (got service_name={sn!r}, cluster_type={ct!r})"
+                )
+
+            # Duplicate cluster_type would cause double-counting
+            if ct in self._cluster_types:
+                raise ValueError(
+                    f"Duplicate cluster_type '{ct}': '{name}' "
+                    f"conflicts with '{self._cluster_types[ct]}'. Must be unique "
+                    f"to avoid double-counting costs."
+                )
+            self._cluster_types[ct] = name
+
         self._models[name] = capacity_model
 
     @property
@@ -364,6 +465,23 @@ class CapacityPlanner:
     def instance(self, name: str, region: Optional[str] = None) -> Instance:
         return self.hardware_shapes.instance(name, region=region)
 
+    def _prepare_context(
+        self,
+        region: str,
+        num_regions: int,
+    ) -> Tuple[Hardware, RegionContext]:
+        """Prepare hardware and region context for capacity planning.
+
+        Loads hardware catalog for region and creates RegionContext.
+        """
+        hardware = self._shapes.region(region)
+        context = RegionContext(
+            zones_in_region=hardware.zones_in_region,
+            services={n: s.model_copy(deep=True) for n, s in hardware.services.items()},
+            num_regions=num_regions,
+        )
+        return hardware, context
+
     def _plan_percentiles(  # pylint: disable=too-many-positional-arguments
         self,
         model_name: str,
@@ -587,6 +705,146 @@ class CapacityPlanner:
             :num_results
         ]
 
+    def _get_model_costs(
+        self,
+        *,
+        model_name: str,
+        context: RegionContext,
+        desires: CapacityDesires,
+        zonal_clusters: Sequence[ClusterCapacity],
+        regional_clusters: Sequence[ClusterCapacity],
+        extra_model_arguments: Dict[str, Any],
+    ) -> Tuple[Dict[str, float], List[ServiceCapacity]]:
+        """Get total costs for a model and any models it composes with."""
+        costs: Dict[str, float] = {}
+        services: List[ServiceCapacity] = []
+
+        for sub_model_name, sub_desires in self._sub_models(
+            model_name, desires, extra_model_arguments
+        ):
+            sub_model = self._models[sub_model_name]
+            if not isinstance(sub_model, CostAwareModel):
+                raise TypeError(
+                    f"Sub-model '{sub_model_name}' does not implement CostAwareModel. "
+                    f"All models in the composition tree must implement cost methods."
+                )
+
+            model_costs = sub_model.cluster_costs(
+                service_type=sub_model.service_name,
+                zonal_clusters=zonal_clusters,
+                regional_clusters=regional_clusters,
+            )
+            costs.update(model_costs)
+
+            model_services = sub_model.service_costs(
+                service_type=sub_model.service_name,
+                context=context,
+                desires=sub_desires,
+                extra_model_arguments=extra_model_arguments,
+            )
+            for svc in model_services:
+                costs[svc.service_type] = svc.annual_cost
+            services.extend(model_services)
+
+        return costs, services
+
+    def extract_baseline_plan(  # pylint: disable=too-many-positional-arguments
+        self,
+        model_name: str,
+        region: str,
+        desires: CapacityDesires,
+        num_regions: int = 3,
+        extra_model_arguments: Optional[Dict[str, Any]] = None,
+    ) -> CapacityPlan:
+        """Extract baseline plan from current clusters using model cost methods.
+
+        This converts the current deployment (from desires.current_clusters) into
+        a CapacityPlan that can be compared against recommendations. Uses model-
+        specific cost methods for accurate pricing.
+
+        Note: Only works for models with CostAwareModel mixin (EVCache, Kafka,
+        Cassandra, Key-Value). Other models will raise AttributeError.
+
+        Supports composite models (like Key-Value) that have both zonal and
+        regional clusters - each model's cluster_costs filters by cluster_type.
+
+        Args:
+            model_name: Registered model name (e.g., "org.netflix.cassandra")
+            region: AWS region for pricing
+            desires: CapacityDesires with current_clusters populated
+            num_regions: For cross-region cost calculation (default: 3)
+            extra_model_arguments: Model-specific arguments (e.g., copies_per_region)
+
+        Returns:
+            CapacityPlan with costs from model.cluster_costs() and model.service_costs()
+
+        Raises:
+            ValueError: If model_name not found or current_clusters invalid
+            AttributeError: If model doesn't have CostAwareModel mixin
+        """
+        extra_model_arguments = extra_model_arguments or {}
+        if model_name not in self._models:
+            raise ValueError(
+                f"model_name={model_name} does not exist. "
+                f"Try {sorted(list(self._models.keys()))}"
+            )
+
+        model = self._models[model_name]
+        if not isinstance(model, CostAwareModel):
+            raise TypeError(f"Model '{model_name}' must implement CostAwareModel mixin")
+
+        if desires.current_clusters is None:
+            raise ValueError(
+                "Cannot extract baseline: desires.current_clusters is None. "
+                "This function requires an existing deployment to compare against."
+            )
+        if not desires.current_clusters.zonal and not desires.current_clusters.regional:
+            raise ValueError(
+                "Cannot extract baseline: desires.current_clusters has no zonal "
+                "or regional clusters defined."
+            )
+
+        hardware, context = self._prepare_context(region, num_regions)
+        _set_instance_objects(
+            desires, hardware
+        )  # Resolve instance refs in current_clusters
+
+        zonal_capacities: List[ClusterCapacity] = []
+        zonal_requirements: List[CapacityRequirement] = []
+        regional_capacities: List[ClusterCapacity] = []
+        regional_requirements: List[CapacityRequirement] = []
+
+        if desires.current_clusters.zonal:
+            zonal_capacities, zonal_requirements = _extract_cluster_plan(
+                desires.current_clusters.zonal, hardware, is_zonal=True
+            )
+        if desires.current_clusters.regional:
+            regional_capacities, regional_requirements = _extract_cluster_plan(
+                desires.current_clusters.regional, hardware, is_zonal=False
+            )
+
+        costs, services = self._get_model_costs(
+            model_name=model_name,
+            context=context,
+            desires=desires,
+            zonal_clusters=zonal_capacities,
+            regional_clusters=regional_capacities,
+            extra_model_arguments=extra_model_arguments,
+        )
+
+        return CapacityPlan(
+            requirements=Requirements(
+                zonal=zonal_requirements,
+                regional=regional_requirements,
+            ),
+            candidate_clusters=Clusters(
+                annual_costs=costs,
+                zonal=zonal_capacities,
+                regional=regional_capacities,
+                services=services,
+            ),
+        )
+
     # Calculates the minimum cpu, memory, and network requirements based on desires.
     def _per_instance_requirements(self, desires: CapacityDesires) -> Tuple[int, float]:
         # Applications often set fixed reservations of heap or OS memory
@@ -636,13 +894,10 @@ class CapacityPlanner:
         instance_families = instance_families or []
         drives = drives or []
 
-        hardware = self._shapes.region(region)
-
-        context = RegionContext(
-            zones_in_region=hardware.zones_in_region,
-            services={n: s.model_copy(deep=True) for n, s in hardware.services.items()},
-            num_regions=num_regions,
-        )
+        hardware, context = self._prepare_context(region, num_regions)
+        _set_instance_objects(
+            desires, hardware
+        )  # Resolve instance refs if current_clusters exists
 
         allowed_platforms: Set[Platform] = set(model.allowed_platforms())
         allowed_drives: Set[str] = set(drives or [])
@@ -654,9 +909,6 @@ class CapacityPlanner:
         if len(allowed_drives) == 0:
             allowed_drives.update(hardware.drives.keys())
 
-        # Set current instance object if exists
-        _set_instance_objects(desires, hardware)
-
         # We should not even bother with shapes that don't meet the minimums
         (
             per_instance_cores,

service_capacity_modeling/interface.py

@@ -565,6 +565,30 @@ class Hardware(ExcludeUnsetModel):
     """Managed services available (e.g. service name -> Service with
     params, cost, etc.)"""
 
+    def price_drive(self, drive: Drive) -> Drive:
+        """Hydrate a drive with pricing information from the hardware catalog.
+
+        User-provided drives (e.g., from CurrentClusterCapacity.cluster_drive)
+        contain size/IOPS but lack pricing. This method looks up pricing by
+        drive name and returns a properly priced Drive instance.
+
+        Args:
+            drive: Drive with name, size_gib, read_io_per_s, write_io_per_s
+
+        Returns:
+            Drive with catalog pricing and input size/IO values
+
+        Raises:
+            ValueError: If drive.name not in hardware catalog
+        """
+        if drive.name not in self.drives:
+            raise ValueError(f"Cannot price drive '{drive.name}'")
+        priced = self.drives[drive.name].model_copy()
+        priced.size_gib = drive.size_gib
+        priced.read_io_per_s = drive.read_io_per_s
+        priced.write_io_per_s = drive.write_io_per_s
+        return priced
+
 
 class GlobalHardware(ExcludeUnsetModel):
     """Represents all possible hardware shapes in all regions
@@ -821,6 +845,10 @@ class CurrentClusterCapacity(ExcludeUnsetModel):
     cluster_instance: Optional[Instance] = None
     cluster_drive: Optional[Drive] = None
     cluster_instance_count: Interval
+    # Optional: if not set, extract_baseline_plan
+    # Required metadata for identifying which model
+    # this capacity belongs to
+    cluster_type: Optional[str] = None
     # The distribution cpu utilization in the cluster.
     cpu_utilization: Interval = certain_float(0.0)
     # The per node distribution of memory used in gib.
@@ -1122,11 +1150,30 @@ class ClusterCapacity(ExcludeUnsetModel):
     count: int
     instance: Instance
     attached_drives: Sequence[Drive] = ()
-    annual_cost: float
     # When provisioning services we might need to signal they
     # should have certain configuration, for example flags that
     # affect durability shut off
     cluster_params: Dict[str, Any] = {}
+    # Override for models with non-standard cost calculation (e.g., Aurora
+    # has shared storage so drive cost isn't multiplied by count)
+    annual_cost_override: Optional[float] = None
+
+    @computed_field(return_type=float)  # type: ignore
+    @property
+    def annual_cost(self) -> float:
+        """Compute annual cost from instance and attached drives.
+
+        Standard formula: count * instance.annual_cost + sum(drive.annual_cost * count)
+
+        Models with different cost structures (e.g., Aurora with shared storage)
+        can set annual_cost_override to bypass this calculation.
+        """
+        if self.annual_cost_override is not None:
+            return self.annual_cost_override
+        cost = self.count * self.instance.annual_cost
+        for drive in self.attached_drives:
+            cost += drive.annual_cost * self.count
+        return cost
 
 
 class ServiceCapacity(ExcludeUnsetModel):

service_capacity_modeling/models/__init__.py

@@ -1,7 +1,9 @@
 from typing import Any
 from typing import Callable
 from typing import Dict
+from typing import List
 from typing import Optional
+from typing import Sequence
 from typing import Tuple
 
 from service_capacity_modeling.interface import AccessConsistency
@@ -18,7 +20,9 @@ from service_capacity_modeling.interface import GlobalConsistency
 from service_capacity_modeling.interface import Instance
 from service_capacity_modeling.interface import Platform
 from service_capacity_modeling.interface import QueryPattern
+from service_capacity_modeling.interface import ClusterCapacity
 from service_capacity_modeling.interface import RegionContext
+from service_capacity_modeling.interface import ServiceCapacity
 
 __all__ = [
     "AccessConsistency",
@@ -37,6 +41,7 @@ __all__ = [
     "QueryPattern",
     "RegionContext",
     "CapacityModel",
+    "CostAwareModel",
 ]
 
 __common_regrets__ = frozenset(("spend", "disk", "mem"))
@@ -87,6 +92,47 @@ def _disk_regret(  # noqa: C901
     return regret
 
 
+class CostAwareModel:
+    """Mixin for models that implement cost calculation methods.
+
+    Models using this mixin MUST define:
+        service_name: str  # prefix for cost keys (e.g., "cassandra")
+        cluster_type: str  # filters which clusters this model costs
+
+    Example:
+        class MyModel(CapacityModel, CostAwareModel):
+            service_name = "myservice"
+            cluster_type = "myservice"
+    """
+
+    # Subclasses MUST override these (validated in register_model)
+    service_name: str
+    cluster_type: str
+
+    @staticmethod
+    def service_costs(
+        service_type: str,
+        context: RegionContext,
+        desires: CapacityDesires,
+        extra_model_arguments: Dict[str, Any],
+    ) -> List[ServiceCapacity]:
+        """Calculate additional service costs (network, backup, etc)."""
+        raise NotImplementedError(
+            f"service_costs() must be implemented by {service_type} model"
+        )
+
+    @staticmethod
+    def cluster_costs(
+        service_type: str,
+        zonal_clusters: Sequence["ClusterCapacity"] = (),
+        regional_clusters: Sequence["ClusterCapacity"] = (),
+    ) -> Dict[str, float]:
+        """Calculate cluster infrastructure costs (instances, drives)."""
+        raise NotImplementedError(
+            f"cluster_costs() must be implemented by {service_type} model"
+        )
+
+
 class CapacityModel:
     """Stateless interface for defining a capacity model
 

service_capacity_modeling/models/common.py

@@ -8,6 +8,7 @@ from typing import Callable
 from typing import Dict
 from typing import List
 from typing import Optional
+from typing import Sequence
 from typing import Set
 from typing import Tuple
 
@@ -25,6 +26,7 @@ from service_capacity_modeling.interface import CapacityPlan
 from service_capacity_modeling.interface import CapacityRequirement
 from service_capacity_modeling.interface import certain_float
 from service_capacity_modeling.interface import certain_int
+from service_capacity_modeling.interface import ClusterCapacity
 from service_capacity_modeling.interface import Clusters
 from service_capacity_modeling.interface import CurrentClusterCapacity
 from service_capacity_modeling.interface import CurrentClusters
@@ -48,6 +50,31 @@ logger = logging.getLogger(__name__)
 SECONDS_IN_YEAR = 31556926
 
 
+def cluster_infra_cost(
+    service_type: str,
+    zonal_clusters: Sequence[ClusterCapacity],
+    regional_clusters: Sequence[ClusterCapacity],
+    cluster_type: Optional[str] = None,
+) -> Dict[str, float]:
+    """Sum cluster annual_costs, optionally filtering by cluster_type."""
+    if cluster_type is not None:
+        zonal_clusters = [c for c in zonal_clusters if c.cluster_type == cluster_type]
+        regional_clusters = [
+            c for c in regional_clusters if c.cluster_type == cluster_type
+        ]
+
+    costs: Dict[str, float] = {}
+    if zonal_clusters:
+        costs[f"{service_type}.zonal-clusters"] = sum(
+            c.annual_cost for c in zonal_clusters
+        )
+    if regional_clusters:
+        costs[f"{service_type}.regional-clusters"] = sum(
+            c.annual_cost for c in regional_clusters
+        )
+    return costs
+
+
 # In square root staffing we have to take into account the QOS parameter
 # Which is related to the probability that a user queues. On low tier clusters
 # (aka critical clusters) we want a lower probability of queueing
@@ -92,6 +119,17 @@ def _sqrt_staffed_cores(rps: float, latency_s: float, qos: float) -> int:
     return math.ceil((rps * latency_s) + qos * math.sqrt(rps * latency_s))
 
 
+def get_disk_size_gib(
+    cluster_drive: Optional[Drive],
+    instance: Instance,
+) -> float:
+    if cluster_drive is not None:
+        return cluster_drive.size_gib or 0.0
+    if instance.drive is not None:
+        return instance.drive.size_gib or 0.0
+    return 0.0
+
+
 def get_effective_disk_per_node_gib(
     instance: Instance,
     drive: Drive,
@@ -910,14 +948,8 @@ class RequirementFromCurrentCapacity(BaseModel):
             self.current_capacity.disk_utilization_gib.mid
             * self.current_capacity.cluster_instance_count.mid
         )
-        current_node_disk_gib = float(
-            self.current_instance.drive.max_size_gib
-            if self.current_instance.drive is not None
-            else (
-                self.current_capacity.cluster_drive.size_gib
-                if self.current_capacity.cluster_drive is not None
-                else 0
-            )
+        current_node_disk_gib = get_disk_size_gib(
+            self.current_capacity.cluster_drive, self.current_instance
         )
 
         zonal_disk_allocated = float(

service_capacity_modeling/models/org/netflix/aurora.py

@@ -178,6 +178,10 @@ def _compute_aurora_region(  # pylint: disable=too-many-positional-arguments
         drive.annual_cost_per_read_io[0][1],
         drive.annual_cost_per_write_io[0][1],
     )
+
+    # TODO (homatthew): Should instance.annual_cost be multiplied by instance_count?
+    # Aurora has shared storage, so storage cost is correct (not multiplied).
+    # But compute cost should arguably be instance_count * instance.annual_cost.
     total_annual_cost = instance.annual_cost + attached_drive.annual_cost + io_cost
 
     logger.debug(
@@ -202,7 +206,8 @@ def _compute_aurora_region(  # pylint: disable=too-many-positional-arguments
         count=instance_count,
         instance=instance,
         attached_drives=attached_drives,
-        annual_cost=total_annual_cost,
+        # Aurora's cost model differs from standard (shared storage), so override
+        annual_cost_override=total_annual_cost,
         cluster_params={"instance_cost": instance.annual_cost},
     )
 

service_capacity_modeling/models/org/netflix/cassandra.py

@@ -1,9 +1,12 @@
+# pylint: disable=too-many-lines
 import logging
 import math
 from typing import Any
 from typing import Callable
 from typing import Dict
+from typing import List
 from typing import Optional
+from typing import Sequence
 from typing import Set
 
 from pydantic import BaseModel
@@ -19,6 +22,7 @@ from service_capacity_modeling.interface import CapacityPlan
 from service_capacity_modeling.interface import CapacityRequirement
 from service_capacity_modeling.interface import certain_float
 from service_capacity_modeling.interface import certain_int
+from service_capacity_modeling.interface import ClusterCapacity
 from service_capacity_modeling.interface import Clusters
 from service_capacity_modeling.interface import Consistency
 from service_capacity_modeling.interface import CurrentClusterCapacity
@@ -33,7 +37,9 @@ from service_capacity_modeling.interface import RegionContext
 from service_capacity_modeling.interface import Requirements
 from service_capacity_modeling.interface import ServiceCapacity
 from service_capacity_modeling.models import CapacityModel
+from service_capacity_modeling.models import CostAwareModel
 from service_capacity_modeling.models.common import buffer_for_components
+from service_capacity_modeling.models.common import cluster_infra_cost
 from service_capacity_modeling.models.common import compute_stateful_zone
 from service_capacity_modeling.models.common import DerivedBuffers
 from service_capacity_modeling.models.common import get_effective_disk_per_node_gib
@@ -195,11 +201,7 @@ def _estimate_cassandra_requirement(
     zones_per_region: int = 3,
     copies_per_region: int = 3,
 ) -> CapacityRequirement:
-    """Estimate the capacity required for one zone given a regional desire
-
-    The input desires should be the **regional** desire, and this function will
-    return the zonal capacity requirement
-    """
+    # Input: regional desires → Output: zonal requirement
     disk_buffer = buffer_for_components(
         buffers=desires.buffers, components=[BufferComponent.disk]
     )
@@ -533,40 +535,27 @@ def _estimate_cassandra_cluster_zonal(  # pylint: disable=too-many-positional-ar
     if cluster.count > (max_regional_size // zones_per_region):
         return None
 
-    # Durable Cassandra clusters backup to S3
-    # TODO use the write rate and estimated write size to estimate churn
-    # over the retention period.
-    cap_services = []
-    if desires.data_shape.durability_slo_order.mid >= 1000:
-        blob = context.services.get("blob.standard", None)
-        if blob:
-            cap_services = [
-                ServiceCapacity(
-                    service_type=f"cassandra.backup.{blob.name}",
-                    annual_cost=blob.annual_cost_gib(requirement.disk_gib.mid),
-                    service_params={
-                        "nines_required": (
-                            1 - 1.0 / desires.data_shape.durability_slo_order.mid
-                        )
-                    },
-                )
-            ]
+    # Calculate service costs (network + backup)
+    cap_services = NflxCassandraCapacityModel.service_costs(
+        service_type=NflxCassandraCapacityModel.service_name,
+        context=context,
+        desires=desires,
+        extra_model_arguments={"copies_per_region": copies_per_region},
+    )
 
-    network_costs = network_services("cassandra", context, desires, copies_per_region)
-    if network_costs:
-        cap_services.extend(network_costs)
+    cluster.cluster_type = NflxCassandraCapacityModel.cluster_type
+    zonal_clusters = [cluster] * zones_per_region
 
     # Account for the clusters, backup, and network costs
-    cassandra_costs = {
-        "cassandra.zonal-clusters": zones_per_region * cluster.annual_cost,
-    }
-    for s in cap_services:
-        cassandra_costs[f"{s.service_type}"] = s.annual_cost
+    cassandra_costs = NflxCassandraCapacityModel.cluster_costs(
+        service_type=NflxCassandraCapacityModel.service_name,
+        zonal_clusters=zonal_clusters,
+    )
+    cassandra_costs.update({s.service_type: s.annual_cost for s in cap_services})
 
-    cluster.cluster_type = "cassandra"
     clusters = Clusters(
         annual_costs=cassandra_costs,
-        zonal=[cluster] * zones_per_region,
+        zonal=zonal_clusters,
         regional=[],
         services=cap_services,
     )
@@ -711,7 +700,10 @@ class NflxCassandraArguments(BaseModel):
         return cls.model_validate(args)
 
 
-class NflxCassandraCapacityModel(CapacityModel):
+class NflxCassandraCapacityModel(CapacityModel, CostAwareModel):
+    service_name = "cassandra"
+    cluster_type = "cassandra"
+
     def __init__(self) -> None:
         pass
 
@@ -744,6 +736,60 @@ class NflxCassandraCapacityModel(CapacityModel):
 
         return required_cluster_size
 
+    @staticmethod
+    def service_costs(
+        service_type: str,
+        context: RegionContext,
+        desires: CapacityDesires,
+        extra_model_arguments: Dict[str, Any],
+    ) -> List[ServiceCapacity]:
+        # C* service costs: network + backup
+        copies_per_region: int = _target_rf(
+            desires, extra_model_arguments.get("copies_per_region")
+        )
+
+        services: List[ServiceCapacity] = []
+        services.extend(
+            network_services(service_type, context, desires, copies_per_region)
+        )
+
+        if desires.data_shape.durability_slo_order.mid >= 1000:
+            blob = context.services.get("blob.standard", None)
+            if blob:
+                # Calculate backup disk from desires (same as capacity_plan)
+                # This ensures consistent backup costs regardless of how requirement was built
+                backup_disk_gib = max(
+                    1,
+                    _get_disk_from_desires(desires, copies_per_region)
+                    // context.zones_in_region,
+                )
+                services.append(
+                    ServiceCapacity(
+                        service_type=f"{service_type}.backup.{blob.name}",
+                        annual_cost=blob.annual_cost_gib(backup_disk_gib),
+                        service_params={
+                            "nines_required": (
+                                1 - 1.0 / desires.data_shape.durability_slo_order.mid
+                            )
+                        },
+                    )
+                )
+
+        return services
+
+    @staticmethod
+    def cluster_costs(
+        service_type: str,
+        zonal_clusters: Sequence[ClusterCapacity] = (),
+        regional_clusters: Sequence[ClusterCapacity] = (),
+    ) -> Dict[str, float]:
+        return cluster_infra_cost(
+            service_type,
+            zonal_clusters,
+            regional_clusters,
+            cluster_type=NflxCassandraCapacityModel.cluster_type,
+        )
+
     @staticmethod
     def capacity_plan(
         instance: Instance,

service_capacity_modeling/models/org/netflix/evcache.py

@@ -2,6 +2,8 @@ import logging
 import math
 from typing import Any
 from typing import Dict
+from typing import List
+from typing import Sequence
 from typing import Optional
 from typing import Tuple
 
@@ -28,10 +30,14 @@ from service_capacity_modeling.interface import GlobalConsistency
 from service_capacity_modeling.interface import Instance
 from service_capacity_modeling.interface import Interval
 from service_capacity_modeling.interface import QueryPattern
+from service_capacity_modeling.interface import ClusterCapacity
 from service_capacity_modeling.interface import RegionContext
 from service_capacity_modeling.interface import Requirements
+from service_capacity_modeling.interface import ServiceCapacity
 from service_capacity_modeling.models import CapacityModel
+from service_capacity_modeling.models import CostAwareModel
 from service_capacity_modeling.models.common import buffer_for_components
+from service_capacity_modeling.models.common import cluster_infra_cost
 from service_capacity_modeling.models.common import compute_stateful_zone
 from service_capacity_modeling.models.common import get_effective_disk_per_node_gib
 from service_capacity_modeling.models.common import network_services
@@ -330,36 +336,29 @@ def _estimate_evcache_cluster_zonal(  # noqa: C901,E501 pylint: disable=too-many
     if cluster.count > (max_regional_size // copies_per_region):
         return None
 
-    services = []
-    if cross_region_replication is Replication.sets:
-        services.extend(
-            network_services("evcache", context, desires, copies_per_region)
-        )
-    elif cross_region_replication is Replication.evicts:
-        modified = desires.model_copy(deep=True)
-        # Assume that DELETES replicating cross region mean 128 bytes
-        # of key per evict.
-        modified.query_pattern.estimated_mean_write_size_bytes = certain_int(128)
-        services.extend(
-            network_services("evcache", context, modified, copies_per_region)
-        )
-
-    ec2_cost = copies_per_region * cluster.annual_cost
-    spread_cost = calculate_spread_cost(cluster.count)
+    # Calculate service costs (network transfer) using the model's service_costs method
+    services = NflxEVCacheCapacityModel.service_costs(
+        service_type=NflxEVCacheCapacityModel.service_name,
+        context=context,
+        desires=desires,
+        extra_model_arguments={
+            "copies_per_region": copies_per_region,
+            "cross_region_replication": cross_region_replication.value,
+        },
+    )
 
-    # Account for the clusters and replication costs
-    evcache_costs = {
-        "evcache.zonal-clusters": ec2_cost,
-        "evcache.spread.cost": spread_cost,
-    }
+    cluster.cluster_type = NflxEVCacheCapacityModel.cluster_type
+    zonal_clusters = [cluster] * copies_per_region
 
-    for s in services:
-        evcache_costs[f"{s.service_type}"] = s.annual_cost
+    evcache_costs = NflxEVCacheCapacityModel.cluster_costs(
+        service_type=NflxEVCacheCapacityModel.service_name,
+        zonal_clusters=zonal_clusters,
+    )
+    evcache_costs.update({s.service_type: s.annual_cost for s in services})
 
-    cluster.cluster_type = "evcache"
     clusters = Clusters(
         annual_costs=evcache_costs,
-        zonal=[cluster] * copies_per_region,
+        zonal=zonal_clusters,
         regional=[],
         services=services,
     )
@@ -399,7 +398,69 @@ class NflxEVCacheArguments(BaseModel):
     )
 
 
-class NflxEVCacheCapacityModel(CapacityModel):
+class NflxEVCacheCapacityModel(CapacityModel, CostAwareModel):
+    service_name = "evcache"
+    cluster_type = "evcache"
+
+    @staticmethod
+    def cluster_costs(
+        service_type: str,
+        zonal_clusters: Sequence[ClusterCapacity] = (),
+        regional_clusters: Sequence[ClusterCapacity] = (),
+    ) -> Dict[str, float]:
+        # Adds "{service_type}.spread.cost" penalty for small clusters
+        filtered_zonal = [
+            c
+            for c in zonal_clusters
+            if c.cluster_type == NflxEVCacheCapacityModel.cluster_type
+        ]
+
+        costs = cluster_infra_cost(
+            service_type,
+            filtered_zonal,
+            regional_clusters,
+            cluster_type=NflxEVCacheCapacityModel.cluster_type,
+        )
+
+        # Add spread cost penalty for small clusters
+        if filtered_zonal:
+            cluster_count = filtered_zonal[0].count
+            costs[f"{service_type}.spread.cost"] = calculate_spread_cost(cluster_count)
+
+        return costs
+
+    @staticmethod
+    def service_costs(
+        service_type: str,
+        context: RegionContext,
+        desires: CapacityDesires,
+        extra_model_arguments: Dict[str, Any],
+    ) -> List[ServiceCapacity]:
+        # Network costs depend on cross_region_replication mode:
+        # - 'none': No network costs (default)
+        # - 'sets': Full write size replicated cross-region
+        # - 'evicts': Only 128-byte keys replicated (DELETE operations)
+        # Default to 'none' for composite models (like Key-Value) that compose
+        # EVCache without specifying cross_region_replication
+        cross_region_replication = Replication(
+            extra_model_arguments.get("cross_region_replication", "none")
+        )
+
+        match cross_region_replication:
+            case Replication.sets:
+                copies: int = extra_model_arguments["copies_per_region"]
+                return network_services(service_type, context, desires, copies)
+            case Replication.evicts:
+                copies = extra_model_arguments["copies_per_region"]
+                # For evicts mode, only replicate 128-byte keys (DELETE operations)
+                modified = desires.model_copy(deep=True)
+                modified.query_pattern.estimated_mean_write_size_bytes = certain_int(
+                    128
+                )
+                return network_services(service_type, context, modified, copies)
+            case Replication.none:
+                return []
+
     @staticmethod
     def capacity_plan(
         instance: Instance,

service_capacity_modeling/models/org/netflix/kafka.py

@@ -2,7 +2,9 @@ import logging
 import math
 from typing import Any
 from typing import Dict
+from typing import List
 from typing import Optional
+from typing import Sequence
 from typing import Tuple
 
 from pydantic import BaseModel
@@ -17,6 +19,7 @@ from service_capacity_modeling.interface import Buffers
 from service_capacity_modeling.interface import CapacityDesires
 from service_capacity_modeling.interface import CapacityPlan
 from service_capacity_modeling.interface import CapacityRequirement
+from service_capacity_modeling.interface import ClusterCapacity
 from service_capacity_modeling.interface import certain_float
 from service_capacity_modeling.interface import certain_int
 from service_capacity_modeling.interface import Clusters
@@ -33,8 +36,11 @@ from service_capacity_modeling.interface import MIB_IN_BYTES
 from service_capacity_modeling.interface import QueryPattern
 from service_capacity_modeling.interface import RegionContext
 from service_capacity_modeling.interface import Requirements
+from service_capacity_modeling.interface import ServiceCapacity
 from service_capacity_modeling.models import CapacityModel
+from service_capacity_modeling.models import CostAwareModel
 from service_capacity_modeling.models.common import buffer_for_components
+from service_capacity_modeling.models.common import cluster_infra_cost
 from service_capacity_modeling.models.common import compute_stateful_zone
 from service_capacity_modeling.models.common import get_effective_disk_per_node_gib
 from service_capacity_modeling.models.common import normalize_cores
@@ -388,15 +394,18 @@ def _estimate_kafka_cluster_zonal(  # noqa: C901
     if cluster.count > (max_regional_size // zones_per_region):
         return None
 
-    ec2_cost = zones_per_region * cluster.annual_cost
+    cluster.cluster_type = NflxKafkaCapacityModel.cluster_type
+    zonal_clusters = [cluster] * zones_per_region
 
     # Account for the clusters and replication costs
-    kafka_costs = {"kafka.zonal-clusters": ec2_cost}
+    kafka_costs = NflxKafkaCapacityModel.cluster_costs(
+        service_type=NflxKafkaCapacityModel.service_name,
+        zonal_clusters=zonal_clusters,
+    )
 
-    cluster.cluster_type = "kafka"
     clusters = Clusters(
         annual_costs=kafka_costs,
-        zonal=[cluster] * zones_per_region,
+        zonal=zonal_clusters,
         regional=[],
         services=[],
     )
@@ -464,7 +473,9 @@ class NflxKafkaArguments(BaseModel):
     )
 
 
-class NflxKafkaCapacityModel(CapacityModel):
+class NflxKafkaCapacityModel(CapacityModel, CostAwareModel):
+    service_name = "kafka"
+    cluster_type = "kafka"
     HA_DEFAULT_REPLICATION_FACTOR = 2
     SC_DEFAULT_REPLICATION_FACTOR = 3
 
@@ -537,6 +548,29 @@ class NflxKafkaCapacityModel(CapacityModel):
             require_same_instance_family=require_same_instance_family,
         )
 
+    @staticmethod
+    def cluster_costs(
+        service_type: str,
+        zonal_clusters: Sequence[ClusterCapacity] = (),
+        regional_clusters: Sequence[ClusterCapacity] = (),
+    ) -> Dict[str, float]:
+        return cluster_infra_cost(
+            service_type,
+            zonal_clusters,
+            regional_clusters,
+            cluster_type=NflxKafkaCapacityModel.cluster_type,
+        )
+
+    @staticmethod
+    def service_costs(
+        service_type: str,
+        context: RegionContext,
+        desires: CapacityDesires,
+        extra_model_arguments: Dict[str, Any],
+    ) -> List[ServiceCapacity]:
+        _ = (service_type, context, desires, extra_model_arguments)
+        return []
+
     @staticmethod
     def description() -> str:
         return "Netflix Streaming Kafka Model"

service_capacity_modeling/models/org/netflix/key_value.py

@@ -1,14 +1,18 @@
 from typing import Any
 from typing import Callable
 from typing import Dict
+from typing import List
 from typing import Optional
+from typing import Sequence
 from typing import Tuple
 
 from .stateless_java import nflx_java_app_capacity_model
+from .stateless_java import NflxJavaAppCapacityModel
 from service_capacity_modeling.interface import AccessConsistency
 from service_capacity_modeling.interface import AccessPattern
 from service_capacity_modeling.interface import CapacityDesires
 from service_capacity_modeling.interface import CapacityPlan
+from service_capacity_modeling.interface import ClusterCapacity
 from service_capacity_modeling.interface import Consistency
 from service_capacity_modeling.interface import DataShape
 from service_capacity_modeling.interface import Drive
@@ -18,10 +22,16 @@ from service_capacity_modeling.interface import Instance
 from service_capacity_modeling.interface import Interval
 from service_capacity_modeling.interface import QueryPattern
 from service_capacity_modeling.interface import RegionContext
+from service_capacity_modeling.interface import ServiceCapacity
 from service_capacity_modeling.models import CapacityModel
+from service_capacity_modeling.models import CostAwareModel
+from service_capacity_modeling.models.common import cluster_infra_cost
 
 
-class NflxKeyValueCapacityModel(CapacityModel):
+class NflxKeyValueCapacityModel(CapacityModel, CostAwareModel):
+    service_name = "key-value"
+    cluster_type = "dgwkv"
+
     @staticmethod
     def capacity_plan(
         instance: Instance,
@@ -44,7 +54,7 @@ class NflxKeyValueCapacityModel(CapacityModel):
             return None
 
         for cluster in kv_app.candidate_clusters.regional:
-            cluster.cluster_type = "dgwkv"
+            cluster.cluster_type = NflxKeyValueCapacityModel.cluster_type
         return kv_app
 
     @staticmethod
@@ -122,6 +132,7 @@ class NflxKeyValueCapacityModel(CapacityModel):
     def default_desires(
         user_desires: CapacityDesires, extra_model_arguments: Dict[str, Any]
     ) -> CapacityDesires:
+        _ = extra_model_arguments
         if user_desires.query_pattern.access_pattern == AccessPattern.latency:
             return CapacityDesires(
                 query_pattern=QueryPattern(
@@ -225,5 +236,36 @@ class NflxKeyValueCapacityModel(CapacityModel):
                 ),
             )
 
+    @staticmethod
+    def cluster_costs(
+        service_type: str,
+        zonal_clusters: Sequence[ClusterCapacity] = (),
+        regional_clusters: Sequence[ClusterCapacity] = (),
+    ) -> Dict[str, float]:
+        # Uses NflxJavaAppCapacityModel.service_name (not service_type param)
+        # because capacity_plan delegates to nflx_java_app_capacity_model
+        _ = service_type
+        return cluster_infra_cost(
+            service_type=NflxJavaAppCapacityModel.service_name,
+            zonal_clusters=zonal_clusters,
+            regional_clusters=regional_clusters,
+            cluster_type=NflxKeyValueCapacityModel.cluster_type,
+        )
+
+    @staticmethod
+    def service_costs(
+        service_type: str,
+        context: RegionContext,
+        desires: CapacityDesires,
+        extra_model_arguments: Dict[str, Any],
+    ) -> List[ServiceCapacity]:
+        # Returns empty - dgwkv has no direct network costs:
+        # - DataStax driver selects local Cassandra coordinators (same AZ = free)
+        # - Coordinator→replica fan-out is counted in cassandra.net.intra.region
+        # - EVCache access uses local nodes (same AZ = free)
+        # Cassandra/EVCache service costs come from _sub_models() DAG traversal.
+        _ = (service_type, context, desires, extra_model_arguments)
+        return []
+
 
 nflx_key_value_capacity_model = NflxKeyValueCapacityModel()

service_capacity_modeling/models/org/netflix/stateless_java.py

@@ -1,7 +1,9 @@
 import math
 from typing import Any
 from typing import Dict
+from typing import List
 from typing import Optional
+from typing import Sequence
 
 from pydantic import BaseModel
 from pydantic import Field
@@ -14,6 +16,7 @@ from service_capacity_modeling.interface import CapacityRegretParameters
 from service_capacity_modeling.interface import CapacityRequirement
 from service_capacity_modeling.interface import certain_float
 from service_capacity_modeling.interface import certain_int
+from service_capacity_modeling.interface import ClusterCapacity
 from service_capacity_modeling.interface import Clusters
 from service_capacity_modeling.interface import Consistency
 from service_capacity_modeling.interface import DataShape
@@ -26,7 +29,10 @@ from service_capacity_modeling.interface import QueryPattern
 from service_capacity_modeling.interface import RegionClusterCapacity
 from service_capacity_modeling.interface import RegionContext
 from service_capacity_modeling.interface import Requirements
+from service_capacity_modeling.interface import ServiceCapacity
 from service_capacity_modeling.models import CapacityModel
+from service_capacity_modeling.models import CostAwareModel
+from service_capacity_modeling.models.common import cluster_infra_cost
 from service_capacity_modeling.models.common import compute_stateless_region
 from service_capacity_modeling.models.common import network_services
 from service_capacity_modeling.models.common import normalize_cores
@@ -110,24 +116,25 @@ def _estimate_java_app_region(  # pylint: disable=too-many-positional-arguments
         needed_network_mbps=requirement.network_mbps.mid,
         num_zones=zones_per_region,
     )
-    cluster.cluster_type = "nflx-java-app"
+    cluster.cluster_type = NflxJavaAppCapacityModel.cluster_type
     cluster.attached_drives = attached_drives
 
-    # Add drive cost (root volume is EBS and costs money)
-    drive_cost = sum(d.annual_cost for d in attached_drives) * cluster.count
-    cluster.annual_cost = cluster.annual_cost + drive_cost
-
     # Generally don't want giant clusters
     # Especially not above 1000 because some load balancers struggle
     # with such large clusters
 
     if cluster.count <= 256:
-        costs = {"nflx-java-app.regional-clusters": cluster.annual_cost}
-        # Assume stateless java stays in the same region but crosses a zone
-        network = network_services(
-            "nflx-java-app", RegionContext(num_regions=1), desires, copies_per_region=2
+        costs = NflxJavaAppCapacityModel.cluster_costs(
+            service_type=NflxJavaAppCapacityModel.service_name,
+            regional_clusters=[cluster],
+        )
+        services = NflxJavaAppCapacityModel.service_costs(
+            service_type=NflxJavaAppCapacityModel.service_name,
+            context=context,
+            desires=desires,
+            extra_model_arguments={},
         )
-        for s in network:
+        for s in services:
             costs[s.service_type] = s.annual_cost
 
         return CapacityPlan(
@@ -136,6 +143,7 @@ def _estimate_java_app_region(  # pylint: disable=too-many-positional-arguments
                 annual_costs=costs,
                 regional=[cluster],
                 zonal=[],
+                services=services,
             ),
         )
     return None
@@ -154,7 +162,41 @@ class NflxJavaAppArguments(BaseModel):
     )
 
 
-class NflxJavaAppCapacityModel(CapacityModel):
+class NflxJavaAppCapacityModel(CapacityModel, CostAwareModel):
+    service_name = "nflx-java-app"
+    cluster_type = "nflx-java-app"
+
+    @staticmethod
+    def cluster_costs(
+        service_type: str,
+        zonal_clusters: Sequence[ClusterCapacity] = (),
+        regional_clusters: Sequence[ClusterCapacity] = (),
+    ) -> Dict[str, float]:
+        return cluster_infra_cost(
+            service_type,
+            zonal_clusters,
+            regional_clusters,
+            cluster_type=NflxJavaAppCapacityModel.cluster_type,
+        )
+
+    @staticmethod
+    def service_costs(
+        service_type: str,
+        context: RegionContext,
+        desires: CapacityDesires,
+        extra_model_arguments: Dict[str, Any],
+    ) -> List[ServiceCapacity]:
+        # TODO(matthewho): Currently returns empty because RegionContext is
+        # created without services. Need to determine if stateless apps should
+        # have cross-zone costs (copies_per_region=2 implies 1 cross-AZ hop).
+        _ = (context, extra_model_arguments)
+        return network_services(
+            service_type,
+            RegionContext(num_regions=1),
+            desires,
+            copies_per_region=2,
+        )
+
     @staticmethod
     def capacity_plan(
         instance: Instance,

{service_capacity_modeling-0.3.105.dist-info → service_capacity_modeling-0.3.106.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: service-capacity-modeling
-Version: 0.3.105
+Version: 0.3.106
 Summary: Contains utilities for modeling capacity for pluggable workloads
 Author: Joseph Lynch
 Author-email: josephl@netflix.com

{service_capacity_modeling-0.3.105.dist-info → service_capacity_modeling-0.3.106.dist-info}/RECORD

@@ -1,7 +1,7 @@
 service_capacity_modeling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-service_capacity_modeling/capacity_planner.py,sha256=JRagEFlg3u_zB1N5GzGsKAN55JZLad6p4IF_PmL8kcg,32780
+service_capacity_modeling/capacity_planner.py,sha256=56pGPVwSMv7snqwT0XQiTNSuqFYuWI9cDH9pyzqZwbY,43094
 service_capacity_modeling/enum_utils.py,sha256=50Rw2kgYoJYCrybSbo9WaPPCWxlF5CyPCQtHxQ3kB18,5229
-service_capacity_modeling/interface.py,sha256=jTuMoMc6XEbMl859YNAwV9RiEgJf4phe6g1qHp7_kNg,43453
+service_capacity_modeling/interface.py,sha256=nwNRTTr4gD38rprpF9ql1RxMfVK1IeDL1atAVI_87S0,45420
 service_capacity_modeling/stats.py,sha256=LCNUcQPfwF5hhIZwsfAsDe4ZbnuhDnl3vQHKfpK61Xc,6142
 service_capacity_modeling/hardware/__init__.py,sha256=P5ostvoSOMUqPODtepeFYb4qfTVH0E73mMFraP49rYU,9196
 service_capacity_modeling/hardware/profiles/__init__.py,sha256=7-y3JbCBkgzaAjFla2RIymREcImdZ51HTl3yn3vzoGw,1602
@@ -51,28 +51,28 @@ service_capacity_modeling/hardware/profiles/shapes/aws/auto_r8i.json,sha256=CxRt
 service_capacity_modeling/hardware/profiles/shapes/aws/manual_drives.json,sha256=0qxEciNTb0yGhAmX1bI6hV-4SSkGMp1FZ8OQvaOET64,1709
 service_capacity_modeling/hardware/profiles/shapes/aws/manual_instances.json,sha256=-6Nsy-LlDuxm6LNp-hm7LkEf_6yGRxNSqU77pFtFHeY,12457
 service_capacity_modeling/hardware/profiles/shapes/aws/manual_services.json,sha256=h63675KKmu5IrI3BORDN8fiAqLjAyYHArErKbC7-T30,776
-service_capacity_modeling/models/__init__.py,sha256=03Y1aOe1fNgRKOO-x50SbrtfHTfdAqEs0ipeAx0WzMc,13940
-service_capacity_modeling/models/common.py,sha256=Bs-G1eHrb9qmS9qEWzx0rzN9QjQ419UomQu78dFoxXk,36704
+service_capacity_modeling/models/__init__.py,sha256=MbnmdVfxDJFVtS5d6GK567RSa5V086oEDX-tJtB68WA,15494
+service_capacity_modeling/models/common.py,sha256=6a2ar_0lrrXKZtBAFKl7ETmd2Vp7lneH2C9eXUy0TBM,37713
 service_capacity_modeling/models/headroom_strategy.py,sha256=rGo_d7nxkQDjx0_hIAXKKZAWnQDBtqZhc0eTMouVh8s,682
 service_capacity_modeling/models/utils.py,sha256=WlBaU9l11V5atThMTWDV9-FT1uf0FJS_2iyu8RF5NIk,2665
 service_capacity_modeling/models/org/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 service_capacity_modeling/models/org/netflix/__init__.py,sha256=keaBt7dk6DB2VuRINdo8wRfsobK655Gfw3hYjruacJs,2553
-service_capacity_modeling/models/org/netflix/aurora.py,sha256=ZCileXosW1A8D9QfPf8mCu1BIt4xKvzGdqU5iW487Jg,13076
-service_capacity_modeling/models/org/netflix/cassandra.py,sha256=6CV0UIWpK0lcfF9_-LGrUjDomysswCvoMYS3S-wpSOU,39627
+service_capacity_modeling/models/org/netflix/aurora.py,sha256=I-V89y5AYq9SfQ1ntpUWQUP9Sb4XNfNBOADXPYODHY8,13412
+service_capacity_modeling/models/org/netflix/cassandra.py,sha256=4jnxoDcPLm1y-kwYtuF27hr8aWfpjsCui098UvInsIA,41336
 service_capacity_modeling/models/org/netflix/control.py,sha256=4F9yw60mnOvLrhzRwJwk6kGDBB861a9GhPCNGcC9_Ho,5774
 service_capacity_modeling/models/org/netflix/counter.py,sha256=kTDL7dCnkn-XU27_Z1VBc4CCLCPoOqJZe9WgcENHHd4,10517
 service_capacity_modeling/models/org/netflix/crdb.py,sha256=iW7tyG8jpXhHIdXrw3DPYSHRAknPN42MlCRLJO4o9C8,20826
 service_capacity_modeling/models/org/netflix/ddb.py,sha256=9qRiuTqWev9zbYFFzewyowU7M41uALsuLklYx20yAXw,26502
 service_capacity_modeling/models/org/netflix/elasticsearch.py,sha256=zPrC6b2LNrAh3IWE3HCMUEYASacjYbHChbO4WZSMma4,25234
 service_capacity_modeling/models/org/netflix/entity.py,sha256=CrexndRmoVA_082XYMIL9LVM13qqI8ILJUPbzH6uYZY,8858
-service_capacity_modeling/models/org/netflix/evcache.py,sha256=BDVRWely3F_3Ecb3Um3dQ024_I6XgvagpRJ6zdP5E18,25687
+service_capacity_modeling/models/org/netflix/evcache.py,sha256=I4V2AAtK_nZj6KVLX3QMWfG7fP_1Xq12F9tIqkwQ6rk,28215
 service_capacity_modeling/models/org/netflix/graphkv.py,sha256=7ncEhx9lLsN_vGIKNHkvWfDdKffG7cYe91Wr-DB7IjU,8659
 service_capacity_modeling/models/org/netflix/iso_date_math.py,sha256=oC5sgIXDqwOp6-5z2bdTkm-bJLlnzhqcONI_tspHjac,1137
-service_capacity_modeling/models/org/netflix/kafka.py,sha256=1GA18idG9kk7yfoFbzRdlE-2_9yHTDAAHMxxdyaaSAc,25825
-service_capacity_modeling/models/org/netflix/key_value.py,sha256=WH8NblHqHwnAAumB2Zz1Qd4NBFWDQEQ1rpBcP3fVVQk,9409
+service_capacity_modeling/models/org/netflix/kafka.py,sha256=pkq9e0O3K6Nh_4V9aOuczlKFfSBW-bjhgkMwJ7b3bTg,27025
+service_capacity_modeling/models/org/netflix/key_value.py,sha256=Z-En08IgwJ9e0rgszH-6a9hy3SxfzGGAf4oEDk_aqvs,11235
 service_capacity_modeling/models/org/netflix/postgres.py,sha256=LBxDqkc-lYxDBu2VwNLuf2Q4o4hU3jPwu4YSt33Oe-8,4128
 service_capacity_modeling/models/org/netflix/rds.py,sha256=8GVmpMhTisZPdT-mP1Sx5U7VAF32lnTI27iYPfGg9CY,10930
-service_capacity_modeling/models/org/netflix/stateless_java.py,sha256=-Se9VdLpKP8HdvvwGcbO87qsOfs9HiwUucV_uch0PxM,11574
+service_capacity_modeling/models/org/netflix/stateless_java.py,sha256=wiZ7bPEEv-fMePkB7q_LaoVRsYdtVbJiA64UZn_K7EA,13014
 service_capacity_modeling/models/org/netflix/time_series.py,sha256=NjZTr0NC6c0tduY4O1Z6Nfm0S8Mt0pKxPgphywIulvQ,8240
 service_capacity_modeling/models/org/netflix/time_series_config.py,sha256=usV7y9NVb8hfGrB6POg63lzSfxUafyBMu0zP-HvPOMo,7326
 service_capacity_modeling/models/org/netflix/wal.py,sha256=QtRlqP_AIVpTg-XEINAfvf7J7J9EzXMY5PrxE3DIOU0,4482
@@ -84,9 +84,9 @@ service_capacity_modeling/tools/fetch_pricing.py,sha256=fO84h77cqiiIHF4hZt490Rwb
 service_capacity_modeling/tools/generate_missing.py,sha256=F7YqvMJAV4nZc20GNrlIsnQSF8_77sLgwYZqc5k4LDg,3099
 service_capacity_modeling/tools/instance_families.py,sha256=e5RuYkCLUITvsAazDH12B6KjX_PaBsv6Ne3mj0HK_sQ,9223
 service_capacity_modeling/tools/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-service_capacity_modeling-0.3.105.dist-info/licenses/LICENSE,sha256=nl_Lt5v9VvJ-5lWJDT4ddKAG-VZ-2IaLmbzpgYDz2hU,11343
-service_capacity_modeling-0.3.105.dist-info/METADATA,sha256=7fl7iFryz6jAn2-G1AX2ZCC4QMcaoozJHVjszJpYAN8,10367
-service_capacity_modeling-0.3.105.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-service_capacity_modeling-0.3.105.dist-info/entry_points.txt,sha256=ZsjzpG5SomWpT1zCE19n1uSXKH2gTI_yc33sdl0vmJg,146
-service_capacity_modeling-0.3.105.dist-info/top_level.txt,sha256=H8XjTCLgR3enHq5t3bIbxt9SeUkUT8HT_SDv2dgIT_A,26
-service_capacity_modeling-0.3.105.dist-info/RECORD,,
+service_capacity_modeling-0.3.106.dist-info/licenses/LICENSE,sha256=nl_Lt5v9VvJ-5lWJDT4ddKAG-VZ-2IaLmbzpgYDz2hU,11343
+service_capacity_modeling-0.3.106.dist-info/METADATA,sha256=_SvhiphVKCZqoHRPWFVckzh0W7xhSLNz04focrlzDLw,10367
+service_capacity_modeling-0.3.106.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+service_capacity_modeling-0.3.106.dist-info/entry_points.txt,sha256=ZsjzpG5SomWpT1zCE19n1uSXKH2gTI_yc33sdl0vmJg,146
+service_capacity_modeling-0.3.106.dist-info/top_level.txt,sha256=H8XjTCLgR3enHq5t3bIbxt9SeUkUT8HT_SDv2dgIT_A,26
+service_capacity_modeling-0.3.106.dist-info/RECORD,,