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

service_capacity_modeling/hardware/profiles/shapes/aws/manual_instances.json

@@ -55,190 +55,6 @@
         "block_size_kib": 4, "single_tenant": true
       }
     },
-    "i4i.large": {
-      "name": "i4i.large",
-      "cpu": 2,
-      "cpu_ghz": 3.5,
-      "cpu_ipc_scale": 1.15,
-      "ram_gib": 15.48,
-      "net_mbps": 781,
-      "drive": {
-        "name": "ephem", "size_gib": 436,
-        "read_io_latency_ms": {
-            "minimum_value":0.05,
-            "low":0.10, "mid":0.125, "high":0.17,
-            "maximum_value":2.05, "confidence":0.9
-        },
-        "read_io_per_s": 50000, "write_io_per_s": 27500,
-        "block_size_kib": 4, "single_tenant": false
-      }
-    },
-    "i4i.xlarge": {
-      "name": "i4i.xlarge",
-      "cpu": 4,
-      "cpu_ghz": 3.5,
-      "cpu_ipc_scale": 1.15,
-      "ram_gib": 30.955,
-      "net_mbps": 1875,
-      "drive": {
-        "name": "ephem", "size_gib": 873,
-        "read_io_latency_ms": {
-            "minimum_value": 0.05,
-            "low": 0.10, "mid": 0.125, "high": 0.17,
-            "maximum_value": 2.05, "confidence": 0.9
-        },
-        "read_io_per_s": 100000, "write_io_per_s": 55000,
-        "block_size_kib": 4, "single_tenant": false
-      }
-    },
-    "i4i.2xlarge": {
-      "name": "i4i.2xlarge",
-      "cpu": 8,
-      "cpu_ghz": 3.5,
-      "cpu_ipc_scale": 1.15,
-      "ram_gib": 61.91,
-      "net_mbps": 4687.5 ,
-      "drive": {
-        "name": "ephem", "size_gib": 1746,
-        "read_io_latency_ms": {
-            "minimum_value": 0.05,
-            "low": 0.10, "mid": 0.125, "high": 0.17,
-            "maximum_value": 2.05, "confidence": 0.9
-        },
-        "read_io_per_s": 200000, "write_io_per_s": 110000,
-        "block_size_kib": 4, "single_tenant": true
-      }
-    },
-    "i4i.4xlarge": {
-      "name": "i4i.4xlarge",
-      "cpu": 16,
-      "cpu_ghz": 3.5,
-      "cpu_ipc_scale": 1.15,
-      "ram_gib": 123.82,
-      "net_mbps": 9375,
-      "drive": {
-        "name": "ephem", "size_gib": 3492,
-        "read_io_latency_ms": {
-            "minimum_value":0.05,
-            "low":0.10, "mid":0.125, "high":0.17,
-            "maximum_value":2.05, "confidence":0.9
-        },
-        "read_io_per_s": 400000, "write_io_per_s": 220000,
-        "block_size_kib": 4, "single_tenant": true
-      }
-    },
-    "i4i.8xlarge": {
-      "name": "i4i.8xlarge",
-      "cpu": 32,
-      "cpu_ghz": 3.5,
-      "cpu_ipc_scale": 1.15,
-      "ram_gib": 247.76,
-      "net_mbps": 18750,
-      "drive": {
-        "name": "ephem", "size_gib": 6984,
-        "read_io_latency_ms": {
-            "minimum_value":0.05,
-            "low":0.10, "mid":0.125, "high":0.17,
-            "maximum_value":2.05, "confidence":0.9
-        },
-        "read_io_per_s": 800000, "write_io_per_s": 440000,
-        "block_size_kib": 4, "single_tenant": true
-      }
-    },
-    "i4i.16xlarge": {
-      "name": "i4i.16xlarge",
-      "cpu": 64,
-      "cpu_ghz": 3.5,
-      "cpu_ipc_scale": 1.15,
-      "ram_gib": 495.82,
-      "net_mbps": 35000,
-      "drive": {
-        "name": "ephem", "size_gib": 13968,
-        "read_io_latency_ms": {
-            "minimum_value":0.05,
-            "low":0.10, "mid":0.125, "high":0.17,
-            "maximum_value":2.05, "confidence":0.9
-        },
-        "read_io_per_s": 16000000, "write_io_per_s": 880000,
-        "block_size_kib": 4, "single_tenant": true
-      }
-    },
-
-    "i3en.large": {
-      "name": "i3en.large",
-      "cpu": 2,
-      "cpu_ghz": 3.1,
-      "ram_gib": 15.8,
-      "net_mbps": 4000,
-      "drive": {
-        "name": "ephem", "size_gib": 1150,
-        "read_io_latency_ms": {
-          "minimum_value":0.07,
-          "low":0.08, "mid":0.12, "high":0.20,
-          "maximum_value":2, "confidence":0.9
-        },
-        "read_io_per_s": 42500, "write_io_per_s": 32500,
-        "block_size_kib": 4, "single_tenant": false
-      }
-    },
-    "i3en.xlarge": {
-      "name": "i3en.xlarge",
-      "cpu": 4,
-      "cpu_ghz": 3.1,
-      "ram_gib": 31.7,
-      "net_mbps": 4000,
-      "drive": {
-        "name": "ephem", "size_gib": 2300,
-        "read_io_latency_ms": {
-            "minimum_value":0.07,
-            "low":0.08, "mid":0.12, "high":0.20,
-            "maximum_value":2, "confidence":0.9
-        },
-        "read_io_per_s": 85000, "write_io_per_s": 65000,
-        "block_size_kib": 4, "single_tenant": false
-      }
-    },
-    "i3en.2xlarge": {
-      "name": "i3en.2xlarge",
-      "cpu": 8,
-      "cpu_ghz": 3.1,
-      "ram_gib": 63.62,
-      "net_mbps": 8000,
-      "drive": {
-        "name": "ephem", "size_gib": 4600,
-        "read_io_latency_ms": {
-            "minimum_value": 0.07,
-            "low":0.08, "mid":0.12, "high": 0.20,
-            "maximum_value":2, "confidence":0.9
-        },
-        "read_io_per_s": 170000, "write_io_per_s": 130000,
-        "block_size_kib": 4, "single_tenant": false
-      }
-    },
-    "i3en.3xlarge": {
-      "name": "i3en.3xlarge",
-      "cpu": 12,
-      "cpu_ghz": 3.1,
-      "ram_gib": 95.54,
-      "net_mbps": 12000,
-      "drive": {"name": "ephem", "size_gib": 6819,
-        "read_io_latency_ms": {"minimum_value":0.07, "low":0.08, "mid":0.12, "high":0.16, "maximum_value":2, "confidence":0.9},
-        "read_io_per_s": 250000, "write_io_per_s": 200000,
-        "block_size_kib": 4, "single_tenant": true
-      }
-    },
-    "i3en.6xlarge": {
-      "name": "i3en.6xlarge",
-      "cpu": 24,
-      "cpu_ghz": 3.1,
-      "ram_gib": 186.62,
-      "net_mbps": 24000,
-      "drive": {"name": "ephem", "size_gib": 14000,
-        "read_io_latency_ms": {"minimum_value":0.07, "low":0.08, "mid":0.12, "high":0.16, "maximum_value":2, "confidence":0.9},
-        "read_io_per_s": 500000, "write_io_per_s": 400000,
-        "block_size_kib": 4, "single_tenant": true
-      }
-    },
     "m5d.large": {
       "name": "m5d.large",
       "cpu": 2,

service_capacity_modeling/interface.py

@@ -27,12 +27,12 @@ MEGABIT_IN_BYTES = (1000 * 1000) / 8
 
 
 class ExcludeUnsetModel(BaseModel):
-    def model_dump(self, *args, **kwargs):
+    def model_dump(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
         if "exclude_unset" not in kwargs:
             kwargs["exclude_unset"] = True
         return super().model_dump(*args, **kwargs)
 
-    def model_dump_json(self, *args, **kwargs):
+    def model_dump_json(self, *args: Any, **kwargs: Any) -> str:
         if "exclude_unset" not in kwargs:
             kwargs["exclude_unset"] = True
         return super().model_dump_json(*args, **kwargs)
@@ -44,10 +44,10 @@ class ExcludeUnsetModel(BaseModel):
 
 
 class IntervalModel(str, Enum):
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self.value)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"D({self.value})"
 
     gamma = "gamma"
@@ -71,11 +71,11 @@ class Interval(ExcludeUnsetModel):
     model_config = ConfigDict(frozen=True, protected_namespaces=())
 
     @property
-    def can_simulate(self):
+    def can_simulate(self) -> bool:
         return self.confidence <= 0.99 and self.allow_simulate
 
     @property
-    def minimum(self):
+    def minimum(self) -> float:
         if self.minimum_value is None:
             if self.confidence == 1.0:
                 return self.low * 0.999
@@ -84,17 +84,19 @@ class Interval(ExcludeUnsetModel):
         return self.minimum_value
 
     @property
-    def maximum(self):
+    def maximum(self) -> float:
         if self.maximum_value is None:
             if self.confidence == 1.0:
                 return self.high * 1.001
             return self.high * 2
         return self.maximum_value
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash((type(self),) + tuple(self.__dict__.values()))
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Interval):
+            return False
         return self.__hash__() == other.__hash__()
 
     def scale(self, factor: float) -> Interval:
@@ -264,14 +266,14 @@ class Drive(ExcludeUnsetModel):
         return max(self.block_size_kib, self.group_size_kib)
 
     @property
-    def max_size_gib(self):
+    def max_size_gib(self) -> float:
         if self.max_scale_size_gib != 0:
             return self.max_scale_size_gib
         else:
             return self.size_gib
 
     @property
-    def max_io_per_s(self):
+    def max_io_per_s(self) -> int:
         if self.max_scale_io_per_s != 0:
             return self.max_scale_io_per_s
         else:
@@ -279,7 +281,7 @@ class Drive(ExcludeUnsetModel):
 
     @computed_field(return_type=float)  # type: ignore
     @property
-    def annual_cost(self):
+    def annual_cost(self) -> float:
         size = self.size_gib or 0
         r_ios = self.read_io_per_s or 0
         w_ios = self.write_io_per_s or 0
@@ -382,15 +384,15 @@ class Instance(ExcludeUnsetModel):
     family_separator: str = "."
 
     @property
-    def family(self):
+    def family(self) -> str:
         return self.name.rsplit(self.family_separator, 1)[0]
 
     @property
-    def size(self):
+    def size(self) -> str:
         return self.name.rsplit(self.family_separator, 1)[1]
 
     @property
-    def cores(self):
+    def cores(self) -> int:
         if self.cpu_cores is not None:
             return self.cpu_cores
         return self.cpu // 2
@@ -456,7 +458,7 @@ class Service(ExcludeUnsetModel):
         low=1, mid=10, high=50, confidence=0.9
     )
 
-    def annual_cost_gib(self, data_gib: float = 0):
+    def annual_cost_gib(self, data_gib: float = 0) -> float:
         if isinstance(self.annual_cost_per_gib, float):
             return self.annual_cost_per_gib * data_gib
         else:
@@ -779,23 +781,48 @@ class BufferComponent(str, Enum):
     compute = "compute"
     # [Data Shape]    a.k.a. "Dataset" related buffers, e.g. Disk and Memory
     storage = "storage"
-
     # Resource specific component
     cpu = "cpu"
     network = "network"
     disk = "disk"
     memory = "memory"
 
+    @staticmethod
+    def is_generic(component: str) -> bool:
+        return component in {BufferComponent.compute, BufferComponent.storage}
+
+    @staticmethod
+    def is_specific(component: str) -> bool:
+        return not BufferComponent.is_generic(component)
+
 
 class BufferIntent(str, Enum):
     # Most buffers show "desired" buffer, this is the default
     desired = "desired"
     # ratio on top of existing buffers to ensure exists. Generally combined
     # with a different desired buffer to ensure we don't just scale needlessly
+    # This means we can scale up or down as as long as we meet the desired buffer.
     scale = "scale"
-    # Ignore model preferences, just preserve existing buffers
+
+    # DEPRECATED: Use scale_up/scale_down instead
+    # Ignores model preferences, just preserve existing buffers
+    # We rarely actually want to do this since it can cause severe over provisioning
     preserve = "preserve"
 
+    # Scale up if necessary to meet the desired buffer.
+    # If the existing resource is over-provisioned, do not reduce the requirement.
+    # If under-provisioned, the requirement can be increased to meet the desired buffer.
+    # Example: need 20 cores but have 10 → scale up to 20 cores.
+    # Example 2: need 20 cores but have 40 → do not scale down and require at
+    # least 40 cores
+    scale_up = "scale_up"
+    # Scale down if necessary to meet the desired buffer.
+    # If the existing resource is under-provisioned, do not increase the requirement.
+    # If over-provisioned, the requirement can be decreased to meet the desired buffer.
+    # Example: need 20 cores but have 10 → maintain buffer and do not scale up.
+    # Example 2: need 20 cores but have 40 → scale down to 20 cores.
+    scale_down = "scale_down"
+
 
 class Buffer(ExcludeUnsetModel):
     # The value of the buffer expressed as a ratio over "normal" load e.g. 1.5x
@@ -819,7 +846,6 @@ class Buffers(ExcludeUnsetModel):
             "compute": Buffer(ratio: 1.5),
         }
     )
-
     And then models layer in their buffers, for example if a workload
     requires 10 CPU cores, but the operator of that workload  likes to build in
     2x buffer for background work (20 cores provisioned), they would express that
@@ -955,7 +981,7 @@ class CapacityRequirement(ExcludeUnsetModel):
     network_mbps: Interval = certain_int(0)
     disk_gib: Interval = certain_int(0)
 
-    context: Dict = {}
+    context: Dict[str, Any] = {}
 
 
 class ClusterCapacity(ExcludeUnsetModel):
@@ -968,7 +994,7 @@ class ClusterCapacity(ExcludeUnsetModel):
     # When provisioning services we might need to signal they
     # should have certain configuration, for example flags that
     # affect durability shut off
-    cluster_params: Dict = {}
+    cluster_params: Dict[str, Any] = {}
 
 
 class ServiceCapacity(ExcludeUnsetModel):
@@ -979,7 +1005,7 @@ class ServiceCapacity(ExcludeUnsetModel):
     regret_cost: bool = False
     # Often while provisioning cloud services we need to represent
     # parameters to the cloud APIs, use this to inject those from models
-    service_params: Dict = {}
+    service_params: Dict[str, Any] = {}
 
 
 # For services that are provisioned by zone (e.g. Cassandra, EVCache)

service_capacity_modeling/models/__init__.py

@@ -20,6 +20,25 @@ from service_capacity_modeling.interface import Platform
 from service_capacity_modeling.interface import QueryPattern
 from service_capacity_modeling.interface import RegionContext
 
+__all__ = [
+    "AccessConsistency",
+    "AccessPattern",
+    "CapacityDesires",
+    "CapacityPlan",
+    "CapacityRegretParameters",
+    "certain_float",
+    "Consistency",
+    "DataShape",
+    "Drive",
+    "FixedInterval",
+    "GlobalConsistency",
+    "Instance",
+    "Platform",
+    "QueryPattern",
+    "RegionContext",
+    "CapacityModel",
+]
+
 __common_regrets__ = frozenset(("spend", "disk", "mem"))
 
 
@@ -85,7 +104,7 @@ class CapacityModel:
 
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         pass
 
     @staticmethod
@@ -270,7 +289,7 @@ class CapacityModel:
     @staticmethod
     def default_desires(
         user_desires: CapacityDesires, extra_model_arguments: Dict[str, Any]
-    ):
+    ) -> CapacityDesires:
         """Optional defaults to apply given a user desires
 
         Often users do not know what the on-cpu time of their queries