service-capacity-modeling 0.3.73__py3-none-any.whl → 0.3.79__py3-none-any.whl

service_capacity_modeling/models/org/netflix/aurora.py

@@ -1,6 +1,7 @@
 import logging
 import math
 from typing import Any
+from typing import Callable
 from typing import Dict
 from typing import Optional
 from typing import Tuple
@@ -86,7 +87,9 @@ def _estimate_aurora_requirement(
 
 # MySQL default block size is 16KiB, PostGreSQL is 8KiB Number of reads for B-Tree
 # are given by log of total pages to the base of B-Tree fan out factor
-def _rds_required_disk_ios(disk_size_gib: int, db_type: str, btree_fan_out: int = 100):
+def _rds_required_disk_ios(
+    disk_size_gib: int, db_type: str, btree_fan_out: int = 100
+) -> float:
     disk_size_kb = disk_size_gib * 1024 * 1024
     if db_type == "postgres":
         default_block_size = 8  # KiB
@@ -100,11 +103,11 @@ def _rds_required_disk_ios(disk_size_gib: int, db_type: str, btree_fan_out: int
 # This is a start, we should iterate based on the actual work load
 def _estimate_io_cost(
     db_type: str,
-    desires,
+    desires: CapacityDesires,
     read_io_price: float,
     write_io_price: float,
     cache_hit_rate: float = 0.8,
-):
+) -> float:
     if db_type == "postgres":
         read_byte_per_io = 8192
     else:
@@ -134,8 +137,8 @@ def _compute_aurora_region(  # pylint: disable=too-many-positional-arguments
     needed_disk_gib: int,
     needed_memory_gib: int,
     needed_network_mbps: float,
-    required_disk_ios,
-    required_disk_space,
+    required_disk_ios: Callable[[int], float],
+    required_disk_space: Callable[[int], float],
     db_type: str,
     desires: CapacityDesires,
 ) -> Optional[RegionClusterCapacity]:
@@ -295,7 +298,7 @@ class NflxAuroraCapacityModel(CapacityModel):
         )
 
     @staticmethod
-    def description():
+    def description() -> str:
         return "Netflix Aurora Cluster Model"
 
     @staticmethod
@@ -307,7 +310,9 @@ class NflxAuroraCapacityModel(CapacityModel):
         return Platform.aurora_mysql, Platform.aurora_mysql
 
     @staticmethod
-    def default_desires(user_desires, extra_model_arguments):
+    def default_desires(
+        user_desires: CapacityDesires, extra_model_arguments: Dict[str, Any]
+    ) -> CapacityDesires:
         return CapacityDesires(
             query_pattern=QueryPattern(
                 access_pattern=AccessPattern.latency,

service_capacity_modeling/models/org/netflix/cassandra.py

@@ -35,7 +35,7 @@ from service_capacity_modeling.interface import ServiceCapacity
 from service_capacity_modeling.models import CapacityModel
 from service_capacity_modeling.models.common import buffer_for_components
 from service_capacity_modeling.models.common import compute_stateful_zone
-from service_capacity_modeling.models.common import derived_buffer_for_component
+from service_capacity_modeling.models.common import DerivedBuffers
 from service_capacity_modeling.models.common import get_effective_disk_per_node_gib
 from service_capacity_modeling.models.common import network_services
 from service_capacity_modeling.models.common import normalize_cores
@@ -79,7 +79,7 @@ def _write_buffer_gib_zone(
     return float(write_buffer_gib) / zones_per_region
 
 
-def _get_cores_from_desires(desires, instance):
+def _get_cores_from_desires(desires: CapacityDesires, instance: Instance) -> int:
     cpu_buffer = buffer_for_components(
         buffers=desires.buffers, components=[BACKGROUND_BUFFER]
     )
@@ -97,7 +97,7 @@ def _get_cores_from_desires(desires, instance):
     return needed_cores
 
 
-def _get_disk_from_desires(desires, copies_per_region):
+def _get_disk_from_desires(desires: CapacityDesires, copies_per_region: int) -> int:
     disk_buffer = buffer_for_components(
         buffers=desires.buffers, components=[BufferComponent.disk]
     )
@@ -116,7 +116,7 @@ def _get_min_count(
     needed_disk_gib: float,
     disk_per_node_gib: float,
     cluster_size_lambda: Callable[[int], int],
-):
+) -> int:
     """
     Compute the minimum number of nodes required for a zone.
 
@@ -158,7 +158,10 @@ def _get_min_count(
 
 
 def _zonal_requirement_for_new_cluster(
-    desires, instance, copies_per_region, zones_per_region
+    desires: CapacityDesires,
+    instance: Instance,
+    copies_per_region: int,
+    zones_per_region: int,
 ) -> CapacityRequirement:
     needed_cores = _get_cores_from_desires(desires, instance)
     needed_disk = _get_disk_from_desires(desires, copies_per_region)
@@ -181,7 +184,9 @@ def _zonal_requirement_for_new_cluster(
     )
 
 
-def _estimate_cassandra_requirement(  # pylint: disable=too-many-positional-arguments
+# pylint: disable=too-many-locals
+# pylint: disable=too-many-positional-arguments
+def _estimate_cassandra_requirement(
     instance: Instance,
     desires: CapacityDesires,
     working_set: float,
@@ -205,19 +210,22 @@ def _estimate_cassandra_requirement(  # pylint: disable=too-many-positional-argu
     # If the cluster is already provisioned
     if current_capacity and desires.current_clusters is not None:
         capacity_requirement = zonal_requirements_from_current(
-            desires.current_clusters, desires.buffers, instance, reference_shape
+            desires.current_clusters,
+            desires.buffers,
+            instance,
+            reference_shape,
         )
-        disk_scale, _ = derived_buffer_for_component(
-            desires.buffers.derived, ["storage", "disk"]
+        disk_derived_buffer = DerivedBuffers.for_components(
+            desires.buffers.derived, [BufferComponent.disk]
         )
         disk_used_gib = (
             current_capacity.disk_utilization_gib.mid
             * current_capacity.cluster_instance_count.mid
-            * (disk_scale or 1)
-        )
-        _, memory_preserve = derived_buffer_for_component(
-            desires.buffers.derived, ["storage", "memory"]
+            * disk_derived_buffer.scale
         )
+        memory_preserve = DerivedBuffers.for_components(
+            desires.buffers.derived, [BufferComponent.memory]
+        ).preserve
     else:
         # If the cluster is not yet provisioned
         capacity_requirement = _zonal_requirement_for_new_cluster(
@@ -320,14 +328,14 @@ def _estimate_cassandra_requirement(  # pylint: disable=too-many-positional-argu
     )
 
 
-def _get_current_cluster_size(desires) -> int:
+def _get_current_cluster_size(desires: CapacityDesires) -> int:
     current_capacity = _get_current_capacity(desires)
     if current_capacity is None:
         return 0
     return math.ceil(current_capacity.cluster_instance_count.mid)
 
 
-def _get_current_capacity(desires) -> Optional[CurrentClusterCapacity]:
+def _get_current_capacity(desires: CapacityDesires) -> Optional[CurrentClusterCapacity]:
     current_capacity = (
         None
         if desires.current_clusters is None
@@ -340,7 +348,7 @@ def _get_current_capacity(desires) -> Optional[CurrentClusterCapacity]:
     return current_capacity
 
 
-def _upsert_params(cluster, params):
+def _upsert_params(cluster: Any, params: Dict[str, Any]) -> None:
     if cluster.cluster_params:
         cluster.cluster_params.update(params)
     else:
@@ -369,7 +377,7 @@ def _estimate_cassandra_cluster_zonal(  # pylint: disable=too-many-positional-ar
     desires: CapacityDesires,
     zones_per_region: int = 3,
     copies_per_region: int = 3,
-    require_local_disks: bool = True,
+    require_local_disks: bool = False,
     require_attached_disks: bool = False,
     required_cluster_size: Optional[int] = None,
     max_rps_to_disk: int = 500,
@@ -570,7 +578,7 @@ def _estimate_cassandra_cluster_zonal(  # pylint: disable=too-many-positional-ar
 
 
 # C* LCS has 160 MiB sstables by default and 10 sstables per level
-def _cass_io_per_read(node_size_gib, sstable_size_mb=160):
+def _cass_io_per_read(node_size_gib: float, sstable_size_mb: int = 160) -> int:
     gb = node_size_gib * 1024
     sstables = max(1, gb // sstable_size_mb)
     # 10 sstables per level, plus 1 for L0 (avg)
@@ -580,7 +588,7 @@ def _cass_io_per_read(node_size_gib, sstable_size_mb=160):
     return 2 * levels
 
 
-def _get_base_memory(desires: CapacityDesires):
+def _get_base_memory(desires: CapacityDesires) -> float:
     return (
         desires.data_shape.reserved_instance_app_mem_gib
         + desires.data_shape.reserved_instance_system_mem_gib
@@ -636,7 +644,7 @@ class NflxCassandraArguments(BaseModel):
         " this will be deduced from durability and consistency desires",
     )
     require_local_disks: bool = Field(
-        default=True,
+        default=False,
         description="If local (ephemeral) drives are required",
     )
     require_attached_disks: bool = Field(
@@ -674,8 +682,13 @@ class NflxCassandraArguments(BaseModel):
 
 
 class NflxCassandraCapacityModel(CapacityModel):
+    def __init__(self) -> None:
+        pass
+
     @staticmethod
-    def get_required_cluster_size(tier, extra_model_arguments):
+    def get_required_cluster_size(
+        tier: int, extra_model_arguments: Dict[str, Any]
+    ) -> Optional[int]:
         required_cluster_size: Optional[int] = (
             math.ceil(extra_model_arguments["required_cluster_size"])
             if "required_cluster_size" in extra_model_arguments
@@ -719,7 +732,7 @@ class NflxCassandraCapacityModel(CapacityModel):
             desires, extra_model_arguments.get("copies_per_region", None)
         )
         require_local_disks: bool = extra_model_arguments.get(
-            "require_local_disks", True
+            "require_local_disks", False
         )
         require_attached_disks: bool = extra_model_arguments.get(
             "require_attached_disks", False
@@ -770,7 +783,7 @@ class NflxCassandraCapacityModel(CapacityModel):
         )
 
     @staticmethod
-    def description():
+    def description() -> str:
         return "Netflix Streaming Cassandra Model"
 
     @staticmethod
@@ -798,7 +811,9 @@ class NflxCassandraCapacityModel(CapacityModel):
         )
 
     @staticmethod
-    def default_desires(user_desires, extra_model_arguments: Dict[str, Any]):
+    def default_desires(
+        user_desires: CapacityDesires, extra_model_arguments: Dict[str, Any]
+    ) -> CapacityDesires:
         acceptable_consistency = {
             None,
             AccessConsistency.best_effort,

service_capacity_modeling/models/org/netflix/counter.py

@@ -46,7 +46,8 @@ class NflxCounterArguments(NflxJavaAppArguments):
     )
     counter_cardinality: NflxCounterCardinality = Field(
         alias="counter.cardinality",
-        description="Low means < 1,000, medium (1,000—100,000), high means > 100,000.",
+        description="Low means < 10,000, medium (10,000—1,000,000), high means "
+        "> 1,000,000.",
     )
     counter_mode: NflxCounterMode = Field(
         alias="counter.mode",
@@ -81,7 +82,7 @@ class NflxCounterCapacityModel(CapacityModel):
         return counter_app
 
     @staticmethod
-    def description():
+    def description() -> str:
         return "Netflix Streaming Counter Model"
 
     @staticmethod
@@ -92,36 +93,57 @@ class NflxCounterCapacityModel(CapacityModel):
     def compose_with(
         user_desires: CapacityDesires, extra_model_arguments: Dict[str, Any]
     ) -> Tuple[Tuple[str, Callable[[CapacityDesires], CapacityDesires]], ...]:
-        stores = [("org.netflix.evcache", lambda x: x)]
-        if extra_model_arguments["counter.mode"] != NflxCounterMode.best_effort.value:
+        stores = []
 
+        if extra_model_arguments["counter.mode"] == NflxCounterMode.best_effort.value:
+            stores.append(("org.netflix.evcache", lambda x: x))
+        else:
+            # Shared evcache cluster is used for eventual and exact counters
             def _modify_cassandra_desires(
                 user_desires: CapacityDesires,
             ) -> CapacityDesires:
                 modified = user_desires.model_copy(deep=True)
+                counter_cardinality = extra_model_arguments["counter.cardinality"]
+
+                counter_deltas_per_second = (
+                    user_desires.query_pattern.estimated_write_per_second
+                )
 
-                # counts per second
-                cps = user_desires.query_pattern.estimated_write_per_second
+                # low cardinality : rollups happen once every 60 seconds
+                # medium cardinality : rollups happen once every 30 seconds
+                # high cardinality : rollups happen once every 10 seconds
+                # TODO: Account for read amplification from time slice configs
+                #       for better model accuracy
+                if counter_cardinality == NflxCounterCardinality.low.value:
+                    rollups_per_second = counter_deltas_per_second.scale(0.0167)
+                elif counter_cardinality == NflxCounterCardinality.medium.value:
+                    rollups_per_second = counter_deltas_per_second.scale(0.0333)
+                else:
+                    rollups_per_second = counter_deltas_per_second.scale(0.1)
 
-                # rollups happen once every 10 seconds after a write
-                rps = cps.scale(0.1)
-                modified.query_pattern.estimated_read_per_second = rps
+                modified.query_pattern.estimated_read_per_second = rollups_per_second
 
                 # storage size fix
-                event_size = 128  # bytes
-                count_size = 64  # bytes
+                delta_event_size = 256  # bytes
+                rolled_up_count_size = 128  # bytes
                 GiB = 1024 * 1024 * 1024
-                retention = timedelta(days=1).total_seconds()
+
+                # Events can be discarded as soon as rollup is complete
+                # We default to a 1 day slice with 2 day retention
+                retention = timedelta(days=2).total_seconds()
+
                 cardinality = {
-                    "low": 1_000,
-                    "medium": 10_000,
-                    "high": 100_000,
+                    "low": 10_000,
+                    "medium": 100_000,
+                    "high": 1_000_000,
                 }[extra_model_arguments["counter.cardinality"]]
 
-                event_store = cps.scale(count_size * retention / GiB)
-                count_store = event_size * cardinality / GiB
-                store = event_store.offset(count_store)
-                modified.data_shape.estimated_state_size_gib = store
+                event_storage_size = counter_deltas_per_second.scale(
+                    delta_event_size * retention / GiB
+                )
+                rollup_storage_size = rolled_up_count_size * cardinality / GiB
+                total_store_size = event_storage_size.offset(rollup_storage_size)
+                modified.data_shape.estimated_state_size_gib = total_store_size
 
                 return modified
 
@@ -129,7 +151,9 @@ class NflxCounterCapacityModel(CapacityModel):
         return tuple(stores)
 
     @staticmethod
-    def default_desires(user_desires, extra_model_arguments):
+    def default_desires(
+        user_desires: CapacityDesires, extra_model_arguments: Dict[str, Any]
+    ) -> CapacityDesires:
         if user_desires.query_pattern.access_pattern == AccessPattern.latency:
             return CapacityDesires(
                 query_pattern=QueryPattern(

service_capacity_modeling/models/org/netflix/crdb.py

@@ -29,6 +29,7 @@ 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 Requirements
+from service_capacity_modeling.interface import ZoneClusterCapacity
 from service_capacity_modeling.models import CapacityModel
 from service_capacity_modeling.models.common import buffer_for_components
 from service_capacity_modeling.models.common import compute_stateful_zone
@@ -44,7 +45,7 @@ logger = logging.getLogger(__name__)
 
 # Pebble does Leveled compaction with tieres of size??
 # (FIXME) What does pebble actually do
-def _crdb_io_per_read(node_size_gib, sstable_size_mb=1000):
+def _crdb_io_per_read(node_size_gib: float, sstable_size_mb: int = 1000) -> int:
     gb = node_size_gib * 1024
     sstables = max(1, gb // sstable_size_mb)
     # 10 sstables per level, plus 1 for L0 (avg)
@@ -128,7 +129,7 @@ def _estimate_cockroachdb_requirement(  # noqa=E501 pylint: disable=too-many-pos
     )
 
 
-def _upsert_params(cluster, params):
+def _upsert_params(cluster: ZoneClusterCapacity, params: Dict[str, Any]) -> None:
     if cluster.cluster_params:
         cluster.cluster_params.update(params)
     else:
@@ -329,7 +330,7 @@ class NflxCockroachDBCapacityModel(CapacityModel):
         )
 
     @staticmethod
-    def description():
+    def description() -> str:
         return "Netflix Streaming CockroachDB Model"
 
     @staticmethod
@@ -337,7 +338,9 @@ class NflxCockroachDBCapacityModel(CapacityModel):
         return NflxCockroachDBArguments.model_json_schema()
 
     @staticmethod
-    def default_desires(user_desires, extra_model_arguments: Dict[str, Any]):
+    def default_desires(
+        user_desires: CapacityDesires, extra_model_arguments: Dict[str, Any]
+    ) -> CapacityDesires:
         acceptable_consistency = {
             None,
             AccessConsistency.linearizable,

service_capacity_modeling/models/org/netflix/ddb.py

@@ -139,11 +139,12 @@ def _get_read_consistency_percentages(
     )
     if total_percent == 0:
         access_consistency = desires.query_pattern.access_consistency.same_region
-        if access_consistency == AccessConsistency.serializable:
+        target_consistency = access_consistency.target_consistency
+        if target_consistency == AccessConsistency.serializable:
             transactional_read_percent = 1.0
             eventual_read_percent = 0.0
             strong_read_percent = 0.0
-        elif access_consistency in (
+        elif target_consistency in (
             AccessConsistency.read_your_writes,
             AccessConsistency.linearizable,
         ):
@@ -184,7 +185,8 @@ def _get_write_consistency_percentages(
     total_percent = transactional_write_percent + non_transactional_write_percent
     if total_percent == 0:
         access_consistency = desires.query_pattern.access_consistency.same_region
-        if access_consistency == AccessConsistency.serializable:
+        target_consistency = access_consistency.target_consistency
+        if target_consistency == AccessConsistency.serializable:
             transactional_write_percent = 1.0
             non_transactional_write_percent = 0.0
         else:
@@ -547,7 +549,7 @@ class NflxDynamoDBCapacityModel(CapacityModel):
         )
 
     @staticmethod
-    def description():
+    def description() -> str:
         return "Netflix Streaming DynamoDB Model"
 
     @staticmethod
@@ -559,7 +561,9 @@ class NflxDynamoDBCapacityModel(CapacityModel):
         return False
 
     @staticmethod
-    def default_desires(user_desires, extra_model_arguments: Dict[str, Any]):
+    def default_desires(
+        user_desires: CapacityDesires, extra_model_arguments: Dict[str, Any]
+    ) -> CapacityDesires:
         acceptable_consistency = {
             "same_region": {
                 None,

service_capacity_modeling/models/org/netflix/elasticsearch.py

@@ -58,7 +58,7 @@ def _target_rf(desires: CapacityDesires, user_copies: Optional[int]) -> int:
 # segments of 512 megs per
 # https://lucene.apache.org/core/8_1_0/core/org/apache/lucene/index/TieredMergePolicy.html#setSegmentsPerTier(double)
 # (FIXME) Verify what elastic merge actually does
-def _es_io_per_read(node_size_gib, segment_size_mb=512):
+def _es_io_per_read(node_size_gib: float, segment_size_mb: int = 512) -> int:
     size_mib = node_size_gib * 1024
     segments = max(1, size_mib // segment_size_mb)
     # 10 segments per tier, plus 1 for L0 (avg)
@@ -75,7 +75,7 @@ def _estimate_elasticsearch_requirement(  # noqa: E501 pylint: disable=too-many-
     max_rps_to_disk: int,
     zones_in_region: int = 3,
     copies_per_region: int = 3,
-    jvm_memory_overhead=1.2,
+    jvm_memory_overhead: float = 1.2,
 ) -> CapacityRequirement:
     """Estimate the capacity required for one zone given a regional desire
 
@@ -153,7 +153,7 @@ def _estimate_elasticsearch_requirement(  # noqa: E501 pylint: disable=too-many-
     )
 
 
-def _upsert_params(cluster, params):
+def _upsert_params(cluster: ZoneClusterCapacity, params: Dict[str, Any]) -> None:
     if cluster.cluster_params:
         cluster.cluster_params.update(params)
     else:
@@ -194,7 +194,7 @@ class NflxElasticsearchDataCapacityModel(CapacityModel):
 
     @staticmethod
     def default_desires(
-        user_desires, extra_model_arguments: Dict[str, Any]
+        user_desires: CapacityDesires, extra_model_arguments: Dict[str, Any]
     ) -> CapacityDesires:
         desires = CapacityModel.default_desires(user_desires, extra_model_arguments)
         desires.buffers = NflxElasticsearchDataCapacityModel.default_buffers()
@@ -452,7 +452,7 @@ class NflxElasticsearchCapacityModel(CapacityModel):
         return None
 
     @staticmethod
-    def description():
+    def description() -> str:
         return "Netflix Streaming Elasticsearch Model"
 
     @staticmethod
@@ -482,7 +482,9 @@ class NflxElasticsearchCapacityModel(CapacityModel):
         return NflxElasticsearchArguments.model_json_schema()
 
     @staticmethod
-    def default_desires(user_desires, extra_model_arguments: Dict[str, Any]):
+    def default_desires(
+        user_desires: CapacityDesires, extra_model_arguments: Dict[str, Any]
+    ) -> CapacityDesires:
         acceptable_consistency = {
             AccessConsistency.best_effort,
             AccessConsistency.eventual,

service_capacity_modeling/models/org/netflix/entity.py

@@ -48,7 +48,7 @@ class NflxEntityCapacityModel(CapacityModel):
         return entity_app
 
     @staticmethod
-    def description():
+    def description() -> str:
         return "Netflix Streaming Entity Model"
 
     @staticmethod
@@ -76,7 +76,7 @@ class NflxEntityCapacityModel(CapacityModel):
                         / 1024**3
                     )
                 else:
-                    item_size_gib = 10 / 1024**2
+                    item_size_gib = 10 / 1024**2  # type: ignore[unreachable]
                 item_count = user_desires.data_shape.estimated_state_size_gib.scale(
                     1 / item_size_gib
                 )
@@ -102,7 +102,9 @@ class NflxEntityCapacityModel(CapacityModel):
         )
 
     @staticmethod
-    def default_desires(user_desires, extra_model_arguments):
+    def default_desires(
+        user_desires: CapacityDesires, extra_model_arguments: Dict[str, Any]
+    ) -> CapacityDesires:
         if user_desires.query_pattern.access_pattern == AccessPattern.latency:
             return CapacityDesires(
                 query_pattern=QueryPattern(

service_capacity_modeling/models/org/netflix/evcache.py

@@ -33,13 +33,10 @@ from service_capacity_modeling.interface import Requirements
 from service_capacity_modeling.models import CapacityModel
 from service_capacity_modeling.models.common import buffer_for_components
 from service_capacity_modeling.models.common import compute_stateful_zone
-from service_capacity_modeling.models.common import get_cores_from_current_capacity
-from service_capacity_modeling.models.common import get_disk_from_current_capacity
 from service_capacity_modeling.models.common import get_effective_disk_per_node_gib
-from service_capacity_modeling.models.common import get_memory_from_current_capacity
-from service_capacity_modeling.models.common import get_network_from_current_capacity
 from service_capacity_modeling.models.common import network_services
 from service_capacity_modeling.models.common import normalize_cores
+from service_capacity_modeling.models.common import RequirementFromCurrentCapacity
 from service_capacity_modeling.models.common import simple_network_mbps
 from service_capacity_modeling.models.common import sqrt_staffed_cores
 from service_capacity_modeling.models.common import working_set_from_drive_and_slo
@@ -72,7 +69,9 @@ def calculate_read_cpu_time_evcache_ms(read_size_bytes: float) -> float:
     return max(read_latency_ms, 0.005)
 
 
-def calculate_spread_cost(cluster_size: int, max_cost=100000, min_cost=0.0) -> float:
+def calculate_spread_cost(
+    cluster_size: int, max_cost: float = 100000, min_cost: float = 0.0
+) -> float:
     if cluster_size > 10:
         return min_cost
     if cluster_size < 2:
@@ -85,14 +84,14 @@ def calculate_vitals_for_capacity_planner(
     instance: Instance,
     current_memory_gib: float,
     current_disk_gib: float,
-):
+) -> Tuple[float, float, float, float]:
     # First calculate assuming new deployment
     needed_cores = normalize_cores(
         core_count=sqrt_staffed_cores(desires),
         target_shape=instance,
         reference_shape=desires.reference_shape,
     )
-    needed_network_mbps = simple_network_mbps(desires)
+    needed_network_mbps = float(simple_network_mbps(desires))
     needed_memory_gib = current_memory_gib
     needed_disk_gib = current_disk_gib
 
@@ -104,25 +103,20 @@ def calculate_vitals_for_capacity_planner(
     )
     if not current_capacity:
         return needed_cores, needed_network_mbps, needed_memory_gib, needed_disk_gib
+    requirements = RequirementFromCurrentCapacity(
+        current_capacity=current_capacity,
+        buffers=desires.buffers,
+    )
     needed_cores = normalize_cores(
-        core_count=get_cores_from_current_capacity(
-            current_capacity, desires.buffers, instance
-        ),
+        core_count=requirements.cpu(instance_candidate=instance),
         target_shape=instance,
         reference_shape=current_capacity.cluster_instance,
     )
-    needed_network_mbps = get_network_from_current_capacity(
-        current_capacity, desires.buffers
-    )
-    needed_memory_gib = get_memory_from_current_capacity(
-        current_capacity, desires.buffers
+    needed_network_mbps = float(requirements.network_mbps)
+    needed_disk_gib = float(
+        requirements.disk_gib if current_capacity.cluster_drive is not None else 0.0
     )
-    if current_capacity.cluster_drive is None:
-        needed_disk_gib = 0.0
-    else:
-        needed_disk_gib = get_disk_from_current_capacity(
-            current_capacity, desires.buffers
-        )
+    needed_memory_gib = requirements.mem_gib
     return needed_cores, needed_network_mbps, needed_memory_gib, needed_disk_gib
 
 
@@ -204,7 +198,7 @@ def _estimate_evcache_requirement(
     )
 
 
-def _upsert_params(cluster, params):
+def _upsert_params(cluster: Any, params: Dict[str, Any]) -> None:
     if cluster.cluster_params:
         cluster.cluster_params.update(params)
     else:
@@ -271,7 +265,7 @@ def _estimate_evcache_cluster_zonal(  # noqa: C901,E501 pylint: disable=too-many
     # larger to account for additional overhead. Note that the
     # reserved_instance_system_mem_gib has a base of 1 GiB OSMEM so this
     # just represents the variable component
-    def reserve_memory(instance_mem_gib):
+    def reserve_memory(instance_mem_gib: float) -> float:
         # (Joey) From the chart it appears to be about a 3% overhead for
         # OS memory.
         variable_os = int(instance_mem_gib * 0.03)
@@ -447,7 +441,7 @@ class NflxEVCacheCapacityModel(CapacityModel):
         )
 
     @staticmethod
-    def description():
+    def description() -> str:
         return "Netflix Streaming EVCache (memcached) Model"
 
     @staticmethod
@@ -455,7 +449,9 @@ class NflxEVCacheCapacityModel(CapacityModel):
         return NflxEVCacheArguments.model_json_schema()
 
     @staticmethod
-    def default_desires(user_desires, extra_model_arguments: Dict[str, Any]):
+    def default_desires(
+        user_desires: CapacityDesires, extra_model_arguments: Dict[str, Any]
+    ) -> CapacityDesires:
         acceptable_consistency = {
             AccessConsistency.best_effort,
             AccessConsistency.never,

service_capacity_modeling/models/org/netflix/graphkv.py

@@ -45,7 +45,7 @@ class NflxGraphKVCapacityModel(CapacityModel):
         return graphkv_app
 
     @staticmethod
-    def description():
+    def description() -> str:
         return "Netflix Streaming Graph Abstraction"
 
     @staticmethod
@@ -89,7 +89,7 @@ class NflxGraphKVCapacityModel(CapacityModel):
                         / 1024**3
                     )
                 else:
-                    item_size_gib = 1 / 1024**2
+                    item_size_gib = 1 / 1024**2  # type: ignore[unreachable]
                 item_count = user_desires.data_shape.estimated_state_size_gib.scale(
                     1 / item_size_gib
                 )
@@ -102,7 +102,9 @@ class NflxGraphKVCapacityModel(CapacityModel):
         return (("org.netflix.key-value", _modify_kv_desires),)
 
     @staticmethod
-    def default_desires(user_desires, extra_model_arguments):
+    def default_desires(
+        user_desires: CapacityDesires, extra_model_arguments: Dict[str, Any]
+    ) -> CapacityDesires:
         if user_desires.query_pattern.access_pattern == AccessPattern.latency:
             return CapacityDesires(
                 query_pattern=QueryPattern(