Skip to content

table_fields

sc_crawler.table_fields #

Enumerations, JSON nested data objects & other helper classes used in sc_crawler.tables.

Classes:

Name Description
HashableDict

A dict that can be hashed by its JSON representation.
HashableJSON

Alternative JSON SQLAlchemy column representation, which can be hashed.
Json

Custom base SQLModel class that supports dumping as JSON.
Status

Last known status of a resource, e.g. active or inactive.
Cpu

CPU details.
Gpu

GPU accelerator details.
StorageType

Type of a storage, e.g. HDD or SSD.
DatabaseEngine

Managed database engine.
DatabaseSupportLevel

Vendor support tier for a managed database SKU.
DatabaseStorageScope

Scope of a managed database storage product.
Disk

Disk definition based on size and storage type.
TrafficDirection

Direction of the network traffic.
CpuAllocation

CPU allocation methods at cloud vendors.
CpuArchitecture

CPU architectures.
DdrGeneration

Generation of the DDR SDRAM.
Allocation

Server allocation options.
PriceUnit

Supported units for the price tables.
PriceTier

Price tier definition.
Parallelism

Parallelism mode of a benchmark run.
BenchmarkComponentAggregationMethod

How component benchmark scores are combined into one composite score.
BenchmarkComponentNormalizationMethod

How each raw benchmark value is scaled to be comparable across benchmarks.
BenchmarkComponentMissingPolicy

What to do when a component has no usable measurement for a server.
ScoreComponent

One component's contribution to a composite workload profile score.
WorkloadScoreBreakdown

Per-server realized calculation of a composite workload profile score.
Category

Workload category for a cloud server type.

HashableDict #

Bases: dict

A dict that can be hashed by its JSON representation.

Useful for typehinting dict-type table columns that are primary keys (which need to be hashable for SQLAlchemy ORM). See sc_crawler.table_fields.HashableJSON class for the related sa_type.

Source code in sc_crawler/table_fields.py 
12
13
14
15
16
17
18
19
20
21
class HashableDict(dict):
    """A dict that can be hashed by its JSON representation.

    Useful for typehinting dict-type table columns that are primary
    keys (which need to be hashable for SQLAlchemy ORM). See
    [sc_crawler.table_fields.HashableJSON][] class for the related `sa_type`.
    """

    def __hash__(self):
        return hash(dumps(self, sort_keys=True))

HashableJSON #

Bases: TypeDecorator

Alternative JSON SQLAlchemy column representation, which can be hashed.

Source code in sc_crawler/table_fields.py 
24
25
26
27
28
29
30
31
32
33
class HashableJSON(TypeDecorator):
    """Alternative JSON SQLAlchemy column representation, which can be hashed."""

    impl = JSON
    cache_ok = True

    def process_result_value(self, value: str, dialect: Any) -> Any:
        if value is None:
            return None
        return HashableDict(value)

Json #

Bases: BaseModel

Custom base SQLModel class that supports dumping as JSON.

Methods:

Name Description
__json__

Call self.model_dump to serialize into JSON.
Source code in sc_crawler/table_fields.py 
36
37
38
39
40
41
class Json(BaseModel):
    """Custom base SQLModel class that supports dumping as JSON."""

    def __json__(self):
        """Call `self.model_dump` to serialize into JSON."""
        return dict(sorted(self.model_dump().items()))

__json__ #

__json__()

Call self.model_dump to serialize into JSON.

Source code in sc_crawler/table_fields.py 
39
40
41
def __json__(self):
    """Call `self.model_dump` to serialize into JSON."""
    return dict(sorted(self.model_dump().items()))

Status #

Bases: str, Enum

Last known status of a resource, e.g. active or inactive.

Attributes:

Name Type Description
ACTIVE

Active and available resource.
INACTIVE

Inactive resource that is not available anymore.
Source code in sc_crawler/table_fields.py 
44
45
46
47
48
49
50
class Status(str, Enum):
    """Last known status of a resource, e.g. active or inactive."""

    ACTIVE = "active"
    """Active and available resource."""
    INACTIVE = "inactive"
    """Inactive resource that is not available anymore."""

ACTIVE class-attribute instance-attribute #

ACTIVE = 'active'

Active and available resource.

INACTIVE class-attribute instance-attribute #

INACTIVE = 'inactive'

Inactive resource that is not available anymore.

Cpu #

Bases: Json

CPU details.

Attributes:

Name Type Description
manufacturer Optional[str]

The manufacturer of the processor, e.g. Intel or AMD.
family Optional[str]

The product line/family of the processor, e.g. Xeon, Core i7, Ryzen 9.
model Optional[str]

The model number of the processor, e.g. 9750H.
cores Optional[int]

Number of CPU cores.
threads Optional[int]

Number of CPU threads.
l1_cache_size Optional[int]

L1 cache size in bytes.
l2_cache_size Optional[int]

L2 cache size in bytes.
l3_cache_size Optional[int]

L3 cache size in bytes.
microcode Optional[str]

Microcode version.
capabilities List[str]

List of CPU flag/features/capabilities, e.g. MMX, Intel SGX etc.
bugs List[str]

List of known bugs, e.g. cpu_meltdown spectre_v1.
bogomips Optional[float]

BogoMips value.
Source code in sc_crawler/table_fields.py 
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
class Cpu(Json):
    """CPU details."""

    manufacturer: Optional[str] = None
    """The manufacturer of the processor, e.g. Intel or AMD."""
    family: Optional[str] = None
    """The product line/family of the processor, e.g. Xeon, Core i7, Ryzen 9."""
    model: Optional[str] = None
    """The model number of the processor, e.g. 9750H."""
    cores: Optional[int] = None
    """Number of CPU cores."""
    threads: Optional[int] = None
    """Number of CPU threads."""
    l1_cache_size: Optional[int] = None
    """L1 cache size in bytes."""
    l2_cache_size: Optional[int] = None
    """L2 cache size in bytes."""
    l3_cache_size: Optional[int] = None
    """L3 cache size in bytes."""
    microcode: Optional[str] = None
    """Microcode version."""
    capabilities: List[str] = []
    """List of CPU flag/features/capabilities, e.g. MMX, Intel SGX etc."""
    bugs: List[str] = []
    """List of known bugs, e.g. cpu_meltdown spectre_v1."""
    bogomips: Optional[float] = None
    """BogoMips value."""

manufacturer class-attribute instance-attribute #

manufacturer = None

The manufacturer of the processor, e.g. Intel or AMD.

family class-attribute instance-attribute #

family = None

The product line/family of the processor, e.g. Xeon, Core i7, Ryzen 9.

model class-attribute instance-attribute #

model = None

The model number of the processor, e.g. 9750H.

cores class-attribute instance-attribute #

cores = None

Number of CPU cores.

threads class-attribute instance-attribute #

threads = None

Number of CPU threads.

l1_cache_size class-attribute instance-attribute #

l1_cache_size = None

L1 cache size in bytes.

l2_cache_size class-attribute instance-attribute #

l2_cache_size = None

L2 cache size in bytes.

l3_cache_size class-attribute instance-attribute #

l3_cache_size = None

L3 cache size in bytes.

microcode class-attribute instance-attribute #

microcode = None

Microcode version.

capabilities class-attribute instance-attribute #

capabilities = []

List of CPU flag/features/capabilities, e.g. MMX, Intel SGX etc.

bugs class-attribute instance-attribute #

bugs = []

List of known bugs, e.g. cpu_meltdown spectre_v1.

bogomips class-attribute instance-attribute #

bogomips = None

BogoMips value.

Gpu #

Bases: Json

GPU accelerator details.

Attributes:

Name Type Description
manufacturer str

The manufacturer/brand of the GPU accelerator, e.g. Nvidia or AMD.
family Optional[str]

The model family/architecture of the GPU accelerator.
model Optional[str]

The model number of the GPU accelerator.
memory int

Memory (MiB) allocated to the GPU accelerator.
firmware_version Optional[str]

Firmware version.
bios_version Optional[str]

Video BIOS version.
graphics_clock Optional[int]

GPU core clock speed (Mhz).
sm_clock Optional[int]

Streaming Multiprocessor clock speed (Mhz).
mem_clock Optional[int]

Memory clock speed (Mhz).
video_clock Optional[int]

Video clock speed (Mhz).
Source code in sc_crawler/table_fields.py 
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
class Gpu(Json):
    """GPU accelerator details."""

    manufacturer: str
    """The manufacturer/brand of the GPU accelerator, e.g. Nvidia or AMD."""
    family: Optional[str] = None
    """The model family/architecture of the GPU accelerator."""
    model: Optional[str] = None
    """The model number of the GPU accelerator."""
    memory: int
    """Memory (MiB) allocated to the GPU accelerator."""
    firmware_version: Optional[str] = None
    """Firmware version."""
    bios_version: Optional[str] = None
    """Video BIOS version."""
    graphics_clock: Optional[int] = None
    """GPU core clock speed (Mhz)."""
    sm_clock: Optional[int] = None
    """Streaming Multiprocessor clock speed (Mhz)."""
    mem_clock: Optional[int] = None
    """Memory clock speed (Mhz)."""
    video_clock: Optional[int] = None
    """Video clock speed (Mhz)."""

manufacturer instance-attribute #

manufacturer

The manufacturer/brand of the GPU accelerator, e.g. Nvidia or AMD.

family class-attribute instance-attribute #

family = None

The model family/architecture of the GPU accelerator.

model class-attribute instance-attribute #

model = None

The model number of the GPU accelerator.

memory instance-attribute #

memory

Memory (MiB) allocated to the GPU accelerator.

firmware_version class-attribute instance-attribute #

firmware_version = None

Firmware version.

bios_version class-attribute instance-attribute #

bios_version = None

Video BIOS version.

graphics_clock class-attribute instance-attribute #

graphics_clock = None

GPU core clock speed (Mhz).

sm_clock class-attribute instance-attribute #

sm_clock = None

Streaming Multiprocessor clock speed (Mhz).

mem_clock class-attribute instance-attribute #

mem_clock = None

Memory clock speed (Mhz).

video_clock class-attribute instance-attribute #

video_clock = None

Video clock speed (Mhz).

StorageType #

Bases: str, Enum

Type of a storage, e.g. HDD or SSD.

Attributes:

Name Type Description
HDD

Magnetic hard disk drive.
SSD

Solid-state drive.
NVME_SSD

NVMe based solid-state drive.
NETWORK

Storage over network, e.g. using NFS.
Source code in sc_crawler/table_fields.py 
107
108
109
110
111
112
113
114
115
116
117
class StorageType(str, Enum):
    """Type of a storage, e.g. HDD or SSD."""

    HDD = "hdd"
    """Magnetic hard disk drive."""
    SSD = "ssd"
    """Solid-state drive."""
    NVME_SSD = "nvme ssd"
    """NVMe based solid-state drive."""
    NETWORK = "network"
    """Storage over network, e.g. using NFS."""

HDD class-attribute instance-attribute #

HDD = 'hdd'

Magnetic hard disk drive.

SSD class-attribute instance-attribute #

SSD = 'ssd'

Solid-state drive.

NVME_SSD class-attribute instance-attribute #

NVME_SSD = 'nvme ssd'

NVMe based solid-state drive.

NETWORK class-attribute instance-attribute #

NETWORK = 'network'

Storage over network, e.g. using NFS.

DatabaseEngine #

Bases: str, Enum

Managed database engine.

Attributes:

Name Type Description
POSTGRESQL

PostgreSQL.
Source code in sc_crawler/table_fields.py 
120
121
122
123
124
class DatabaseEngine(str, Enum):
    """Managed database engine."""

    POSTGRESQL = "postgresql"
    """PostgreSQL."""

POSTGRESQL class-attribute instance-attribute #

POSTGRESQL = 'postgresql'

PostgreSQL.

DatabaseSupportLevel #

Bases: str, Enum

Vendor support tier for a managed database SKU.

Attributes:

Name Type Description
STANDARD

Standard support level.
Source code in sc_crawler/table_fields.py 
127
128
129
130
131
class DatabaseSupportLevel(str, Enum):
    """Vendor support tier for a managed database SKU."""

    STANDARD = "standard"
    """Standard support level."""

STANDARD class-attribute instance-attribute #

STANDARD = 'standard'

Standard support level.

DatabaseStorageScope #

Bases: str, Enum

Scope of a managed database storage product.

Attributes:

Name Type Description
DATA

Primary database data storage.
BACKUP

Backup or archive storage.
Source code in sc_crawler/table_fields.py 
134
135
136
137
138
139
140
class DatabaseStorageScope(str, Enum):
    """Scope of a managed database storage product."""

    DATA = "data"
    """Primary database data storage."""
    BACKUP = "backup"
    """Backup or archive storage."""

DATA class-attribute instance-attribute #

DATA = 'data'

Primary database data storage.

BACKUP class-attribute instance-attribute #

BACKUP = 'backup'

Backup or archive storage.

Disk #

Bases: Json

Disk definition based on size and storage type.

Attributes:

Name Type Description
size int

Storage size in GB.
storage_type StorageType

Type of the storage.
description Optional[str]

Optional description of the storage, e.g. temp disk.
Source code in sc_crawler/table_fields.py 
143
144
145
146
147
148
149
150
151
class Disk(Json):
    """Disk definition based on size and storage type."""

    size: int = 0
    """Storage size in GB."""
    storage_type: StorageType
    """[Type][sc_crawler.table_fields.StorageType] of the storage."""
    description: Optional[str] = None
    """Optional description of the storage, e.g. temp disk."""

size class-attribute instance-attribute #

size = 0

Storage size in GB.

storage_type instance-attribute #

storage_type

Type of the storage.

description class-attribute instance-attribute #

description = None

Optional description of the storage, e.g. temp disk.

TrafficDirection #

Bases: str, Enum

Direction of the network traffic.

Attributes:

Name Type Description
IN

Inbound traffic.
OUT

Outbound traffic.
Source code in sc_crawler/table_fields.py 
154
155
156
157
158
159
160
class TrafficDirection(str, Enum):
    """Direction of the network traffic."""

    IN = "inbound"
    """Inbound traffic."""
    OUT = "outbound"
    """Outbound traffic."""

IN class-attribute instance-attribute #

IN = 'inbound'

Inbound traffic.

OUT class-attribute instance-attribute #

OUT = 'outbound'

Outbound traffic.

CpuAllocation #

Bases: str, Enum

CPU allocation methods at cloud vendors.

Attributes:

Name Type Description
SHARED

Shared CPU with other virtual server tenants.
BURSTABLE

CPU that can temporarily burst above its baseline performance.
DEDICATED

Dedicated CPU with known performance.
Source code in sc_crawler/table_fields.py 
163
164
165
166
167
168
169
170
171
class CpuAllocation(str, Enum):
    """CPU allocation methods at cloud vendors."""

    SHARED = "Shared"
    """Shared CPU with other virtual server tenants."""
    BURSTABLE = "Burstable"
    """CPU that can temporarily burst above its baseline performance."""
    DEDICATED = "Dedicated"
    """Dedicated CPU with known performance."""

SHARED class-attribute instance-attribute #

SHARED = 'Shared'

Shared CPU with other virtual server tenants.

BURSTABLE class-attribute instance-attribute #

BURSTABLE = 'Burstable'

CPU that can temporarily burst above its baseline performance.

DEDICATED class-attribute instance-attribute #

DEDICATED = 'Dedicated'

Dedicated CPU with known performance.

CpuArchitecture #

Bases: str, Enum

CPU architectures.

Attributes:

Name Type Description
ARM64

64-bit ARM architecture.
ARM64_MAC

Apple 64-bit ARM architecture.
I386

32-bit x86 architecture.
X86_64

64-bit x86 architecture.
X86_64_MAC

Apple 64-bit x86 architecture.
Source code in sc_crawler/table_fields.py 
174
175
176
177
178
179
180
181
182
183
184
185
186
class CpuArchitecture(str, Enum):
    """CPU architectures."""

    ARM64 = "arm64"
    """64-bit ARM architecture."""
    ARM64_MAC = "arm64_mac"
    """Apple 64-bit ARM architecture."""
    I386 = "i386"
    """32-bit x86 architecture."""
    X86_64 = "x86_64"
    """64-bit x86 architecture."""
    X86_64_MAC = "x86_64_mac"
    """Apple 64-bit x86 architecture."""

ARM64 class-attribute instance-attribute #

ARM64 = 'arm64'

64-bit ARM architecture.

ARM64_MAC class-attribute instance-attribute #

ARM64_MAC = 'arm64_mac'

Apple 64-bit ARM architecture.

I386 class-attribute instance-attribute #

I386 = 'i386'

32-bit x86 architecture.

X86_64 class-attribute instance-attribute #

X86_64 = 'x86_64'

64-bit x86 architecture.

X86_64_MAC class-attribute instance-attribute #

X86_64_MAC = 'x86_64_mac'

Apple 64-bit x86 architecture.

DdrGeneration #

Bases: str, Enum

Generation of the DDR SDRAM.

Attributes:

Name Type Description
DDR3

DDR3 SDRAM.
DDR4

DDR4 SDRAM.
DDR5

DDR5 SDRAM.
Source code in sc_crawler/table_fields.py 
189
190
191
192
193
194
195
196
197
class DdrGeneration(str, Enum):
    """Generation of the DDR SDRAM."""

    DDR3 = "DDR3"
    """DDR3 SDRAM."""
    DDR4 = "DDR4"
    """DDR4 SDRAM."""
    DDR5 = "DDR5"
    """DDR5 SDRAM."""

DDR3 class-attribute instance-attribute #

DDR3 = 'DDR3'

DDR3 SDRAM.

DDR4 class-attribute instance-attribute #

DDR4 = 'DDR4'

DDR4 SDRAM.

DDR5 class-attribute instance-attribute #

DDR5 = 'DDR5'

DDR5 SDRAM.

Allocation #

Bases: str, Enum

Server allocation options.

Attributes:

Name Type Description
ONDEMAND

On-demand server.
RESERVED

Reserved server.
SPOT

Spot/preemptible server.
Source code in sc_crawler/table_fields.py 
200
201
202
203
204
205
206
207
208
class Allocation(str, Enum):
    """Server allocation options."""

    ONDEMAND = "ondemand"
    """On-demand server."""
    RESERVED = "reserved"
    """Reserved server."""
    SPOT = "spot"
    """Spot/preemptible server."""

ONDEMAND class-attribute instance-attribute #

ONDEMAND = 'ondemand'

On-demand server.

RESERVED class-attribute instance-attribute #

RESERVED = 'reserved'

Reserved server.

SPOT class-attribute instance-attribute #

SPOT = 'spot'

Spot/preemptible server.

PriceUnit #

Bases: str, Enum

Supported units for the price tables.

Attributes:

Name Type Description
YEAR

Price per year.
MONTH

Price per month.
HOUR

Price per hour.
GIB

Price per gibibyte (GiB).
GB

Price per gigabyte (GB).
GB_MONTH

Price per gigabyte (GB)/month.
Source code in sc_crawler/table_fields.py 
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
class PriceUnit(str, Enum):
    """Supported units for the price tables."""

    YEAR = "year"
    """Price per year."""
    MONTH = "month"
    """Price per month."""
    HOUR = "hour"
    """Price per hour."""
    GIB = "GiB"
    """Price per gibibyte (GiB)."""
    GB = "GB"
    """Price per gigabyte (GB)."""
    GB_MONTH = "GB/month"
    """Price per gigabyte (GB)/month."""

YEAR class-attribute instance-attribute #

YEAR = 'year'

Price per year.

MONTH class-attribute instance-attribute #

MONTH = 'month'

Price per month.

HOUR class-attribute instance-attribute #

HOUR = 'hour'

Price per hour.

GIB class-attribute instance-attribute #

GIB = 'GiB'

Price per gibibyte (GiB).

GB class-attribute instance-attribute #

GB = 'GB'

Price per gigabyte (GB).

GB_MONTH class-attribute instance-attribute #

GB_MONTH = 'GB/month'

Price per gigabyte (GB)/month.

PriceTier #

Bases: Json

Price tier definition.

Infinite bounds (e.g. for an open-ended upper tier) are stored as float("inf") in Python and automatically serialized to the JSON-safe string "Infinity" on export. Both representations are accepted as input: the model validator converts "Infinity" back to float("inf") when loading from JSON.

Attributes:

Name Type Description
lower float

Lower bound of pricing tier, e.g. 100 GB. Unit is defined in the parent object.
upper float

Upper bound of pricing tier, e.g. 1 TB. Unit is defined in the parent object.
price float

Price in the pricing tier. Currency is defined in the parent object.
Source code in sc_crawler/table_fields.py 
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
class PriceTier(Json):
    """Price tier definition.

    Infinite bounds (e.g. for an open-ended upper tier) are stored as
    `float("inf")` in Python and automatically serialized to the
    JSON-safe string `"Infinity"` on export. Both representations are
    accepted as input: the model validator converts `"Infinity"` back
    to `float("inf")` when loading from JSON."""

    lower: float
    """Lower bound of pricing tier, e.g. 100 GB. Unit is defined in the parent object."""
    upper: float
    """Upper bound of pricing tier, e.g. 1 TB. Unit is defined in the parent object."""
    price: float
    """Price in the pricing tier. Currency is defined in the parent object."""

    @field_validator("upper", "lower", mode="before")
    @classmethod
    def _deserialize_inf_bounds(cls, value):
        """Convert string values to float when deserializing from JSON."""
        if isinstance(value, str):
            return float(value)
        return value

    @field_serializer("upper", "lower")
    def _serialize_inf_bounds(self, value):
        """Convert float('inf') bounds to 'Infinity' strings when dumping to JSON."""
        if value == float("inf"):
            return "Infinity"
        return value

lower instance-attribute #

lower

Lower bound of pricing tier, e.g. 100 GB. Unit is defined in the parent object.

upper instance-attribute #

upper

Upper bound of pricing tier, e.g. 1 TB. Unit is defined in the parent object.

price instance-attribute #

price

Price in the pricing tier. Currency is defined in the parent object.

Parallelism #

Bases: str, Enum

Parallelism mode of a benchmark run.

Attributes:

Name Type Description
SINGLE

Benchmark run on a single core.
MULTI

Benchmark run across multiple cores.
Source code in sc_crawler/table_fields.py 
260
261
262
263
264
265
266
class Parallelism(str, Enum):
    """Parallelism mode of a benchmark run."""

    SINGLE = "single"
    """Benchmark run on a single core."""
    MULTI = "multi"
    """Benchmark run across multiple cores."""

SINGLE class-attribute instance-attribute #

SINGLE = 'single'

Benchmark run on a single core.

MULTI class-attribute instance-attribute #

MULTI = 'multi'

Benchmark run across multiple cores.

BenchmarkComponentAggregationMethod #

Bases: str, Enum

How component benchmark scores are combined into one composite score.

Attributes:

Name Type Description
WEIGHTED_GEOMETRIC_MEAN

Weighted geometric mean: 2 ** (Σ wᵢ·log2(normalizedᵢ) / Σ wᵢ). Preserves
Source code in sc_crawler/table_fields.py 
269
270
271
272
273
274
class BenchmarkComponentAggregationMethod(str, Enum):
    """How component benchmark scores are combined into one composite score."""

    WEIGHTED_GEOMETRIC_MEAN = "weighted_geometric_mean"
    """Weighted geometric mean: 2 ** (Σ wᵢ·log2(normalizedᵢ) / Σ wᵢ). Preserves
    ratio/percentage linearity and is robust to outliers."""

WEIGHTED_GEOMETRIC_MEAN class-attribute instance-attribute #

WEIGHTED_GEOMETRIC_MEAN = 'weighted_geometric_mean'

Weighted geometric mean: 2 ** (Σ wᵢ·log2(normalizedᵢ) / Σ wᵢ). Preserves ratio/percentage linearity and is robust to outliers.

BenchmarkComponentNormalizationMethod #

Bases: str, Enum

How each raw benchmark value is scaled to be comparable across benchmarks.

Attributes:

Name Type Description
MEDIAN_RATIO

Oriented ratio to the fleet median for that benchmark: raw/median when
Source code in sc_crawler/table_fields.py 
277
278
279
280
281
282
class BenchmarkComponentNormalizationMethod(str, Enum):
    """How each raw benchmark value is scaled to be comparable across benchmarks."""

    MEDIAN_RATIO = "median_ratio"
    """Oriented ratio to the fleet median for that benchmark: raw/median when
    higher-is-better, median/raw otherwise. 1.0 == the fleet median."""

MEDIAN_RATIO class-attribute instance-attribute #

MEDIAN_RATIO = 'median_ratio'

Oriented ratio to the fleet median for that benchmark: raw/median when higher-is-better, median/raw otherwise. 1.0 == the fleet median.

BenchmarkComponentMissingPolicy #

Bases: str, Enum

What to do when a component has no usable measurement for a server.

Attributes:

Name Type Description
IGNORE

Omit the component and renormalize weights over the rest (default).
PENALIZE

Substitute the component's penalty floor as the normalized value and keep
REQUIRE

Suppress the whole compound score for that server if the component is
Source code in sc_crawler/table_fields.py 
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
class BenchmarkComponentMissingPolicy(str, Enum):
    """What to do when a component has no usable measurement for a server."""

    IGNORE = "ignore"
    """Omit the component and renormalize weights over the rest (default).
    Use when the metric is genuinely optional"""

    PENALIZE = "penalize"
    """Substitute the component's `penalty` floor as the normalized value and keep
    its full weight, so the composite collapses toward zero. Use when missing means
    failure (e.g. a benchmark that timed out / could not complete)."""

    REQUIRE = "require"
    """Suppress the whole compound score for that server if the component is
    missing. Use when the component is load-bearing for the profile's meaning."""

IGNORE class-attribute instance-attribute #

IGNORE = 'ignore'

Omit the component and renormalize weights over the rest (default). Use when the metric is genuinely optional

PENALIZE class-attribute instance-attribute #

PENALIZE = 'penalize'

Substitute the component's penalty floor as the normalized value and keep its full weight, so the composite collapses toward zero. Use when missing means failure (e.g. a benchmark that timed out / could not complete).

REQUIRE class-attribute instance-attribute #

REQUIRE = 'require'

Suppress the whole compound score for that server if the component is missing. Use when the component is load-bearing for the profile's meaning.

ScoreComponent #

Bases: Json

One component's contribution to a composite workload profile score.

Attributes:

Name Type Description
label str

Human-readable, concise description of what the component measures.
weight float

Relative weight of this component. Weights within a workload sum to 1.0.
weight_share float

The weight of this component as a share of the total weight (0.0 for ignored components).
raw int | float | None

The raw benchmark value.
reference int | float | None

The reference benchmark value, e.g. the fleet median.
normalized float | None

The normalized benchmark value, e.g. the ratio of the raw value to the reference value.
higher_is_better bool

Whether a higher value is better.
note str | None

Optional note about this component.
impact float | None

How much this benchmark component raised or lowered the overall workload score. Values are approximate percentages (positive helps, negative hurts the final score), do not add up to the total score, and actual formula depends on the workload's aggregation and normalization methods.
Source code in sc_crawler/table_fields.py 
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
class ScoreComponent(Json):
    """One component's contribution to a composite workload profile score."""

    label: str
    """Human-readable, concise description of what the component measures."""
    weight: float
    """Relative weight of this component. Weights within a workload sum to 1.0."""
    weight_share: float
    """The weight of this component as a share of the total weight (0.0 for ignored components)."""
    raw: int | float | None = None
    """The raw benchmark value."""
    reference: int | float | None = None
    """The reference benchmark value, e.g. the fleet median."""
    normalized: float | None = None
    """The normalized benchmark value, e.g. the ratio of the raw value to the reference value."""
    higher_is_better: bool = True
    """Whether a higher value is better."""
    note: str | None = None
    """Optional note about this component."""
    impact: float | None = None
    """How much this benchmark component raised or lowered the overall workload score. Values are approximate percentages (positive helps, negative hurts the final score), do not add up to the total score, and actual formula depends on the workload's aggregation and normalization methods."""

label instance-attribute #

label

Human-readable, concise description of what the component measures.

weight instance-attribute #

weight

Relative weight of this component. Weights within a workload sum to 1.0.

weight_share instance-attribute #

weight_share

The weight of this component as a share of the total weight (0.0 for ignored components).

raw class-attribute instance-attribute #

raw = None

The raw benchmark value.

reference class-attribute instance-attribute #

reference = None

The reference benchmark value, e.g. the fleet median.

normalized class-attribute instance-attribute #

normalized = None

The normalized benchmark value, e.g. the ratio of the raw value to the reference value.

higher_is_better class-attribute instance-attribute #

higher_is_better = True

Whether a higher value is better.

note class-attribute instance-attribute #

note = None

Optional note about this component.

impact class-attribute instance-attribute #

impact = None

How much this benchmark component raised or lowered the overall workload score. Values are approximate percentages (positive helps, negative hurts the final score), do not add up to the total score, and actual formula depends on the workload's aggregation and normalization methods.

WorkloadScoreBreakdown #

Bases: Json

Per-server realized calculation of a composite workload profile score.

Attributes:

Name Type Description
aggregation BenchmarkComponentAggregationMethod

How the component benchmark scores are combined into one composite score.
normalization BenchmarkComponentNormalizationMethod

How each raw benchmark value is scaled to be comparable across benchmarks.
coverage float

The total weight of the components.
components list[ScoreComponent]

The components of the workload profile.
Source code in sc_crawler/table_fields.py 
325
326
327
328
329
330
331
332
333
334
335
class WorkloadScoreBreakdown(Json):
    """Per-server realized calculation of a composite workload profile score."""

    aggregation: BenchmarkComponentAggregationMethod
    """How the component benchmark scores are combined into one composite score."""
    normalization: BenchmarkComponentNormalizationMethod
    """How each raw benchmark value is scaled to be comparable across benchmarks."""
    coverage: float
    """The total weight of the components."""
    components: list[ScoreComponent]
    """The components of the workload profile."""

aggregation instance-attribute #

aggregation

How the component benchmark scores are combined into one composite score.

normalization instance-attribute #

normalization

How each raw benchmark value is scaled to be comparable across benchmarks.

coverage instance-attribute #

coverage

The total weight of the components.

components instance-attribute #

components

The components of the workload profile.

Category #

Bases: str, Enum

Workload category for a cloud server type.

Attributes:

Name Type Description
GENERAL_PURPOSE

General-purpose server.
COMPUTE_OPTIMIZED

Compute-optimized server.
MEMORY_OPTIMIZED

Memory-optimized server.
STORAGE_AND_DATABASE

Storage- and database-optimized server.
GPU_ACCELERATED

GPU-accelerated server.
BURSTABLE_AND_BUDGET

Burstable and budget-friendly server.
Source code in sc_crawler/table_fields.py 
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
class Category(str, Enum):
    """Workload category for a cloud server type."""

    GENERAL_PURPOSE = "General Purpose"
    """General-purpose server."""
    COMPUTE_OPTIMIZED = "Compute Optimized"
    """Compute-optimized server."""
    MEMORY_OPTIMIZED = "Memory Optimized"
    """Memory-optimized server."""
    STORAGE_AND_DATABASE = "Storage & Database"
    """Storage- and database-optimized server."""
    GPU_ACCELERATED = "GPU Accelerated"
    """GPU-accelerated server."""
    BURSTABLE_AND_BUDGET = "Burstable & Budget"
    """Burstable and budget-friendly server."""

GENERAL_PURPOSE class-attribute instance-attribute #

GENERAL_PURPOSE = 'General Purpose'

General-purpose server.

COMPUTE_OPTIMIZED class-attribute instance-attribute #

COMPUTE_OPTIMIZED = 'Compute Optimized'

Compute-optimized server.

MEMORY_OPTIMIZED class-attribute instance-attribute #

MEMORY_OPTIMIZED = 'Memory Optimized'

Memory-optimized server.

STORAGE_AND_DATABASE class-attribute instance-attribute #

STORAGE_AND_DATABASE = 'Storage & Database'

Storage- and database-optimized server.

GPU_ACCELERATED class-attribute instance-attribute #

GPU_ACCELERATED = 'GPU Accelerated'

GPU-accelerated server.

BURSTABLE_AND_BUDGET class-attribute instance-attribute #

BURSTABLE_AND_BUDGET = 'Burstable & Budget'

Burstable and budget-friendly server.