Data Transfer Objects

Co2LoadDTO 

class applications.load.dto.load.Co2LoadDTO(*, timestamps: list[str], co2_values: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], resolution: ComputeLoadResolution, running_stats: LoadStats | None = None)

Bases: BaseDTO

Cluster CO₂ footprint timeseries.

Contains estimated carbon footprint values over time.

timestamps

List of timestamp strings in “YYYY-MM-DD HH:MM:SS” format.

Type:: list[str]

co2_values

CO₂ footprint at each timestamp (kgCO₂e).

Type:: list[float]

resolution

Time bucket size.

Type:: applications.ait.enums.ComputeLoadResolution

running_stats

Descriptive statistics over co2_values, or None.

Type:: applications.load.dto.load.LoadStats | None

property avg_co2: float: Average CO₂ per bucket (kgCO₂e).

property max_co2: float: Peak CO₂ in a single bucket (kgCO₂e).

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

property total_co2: float: Total CO₂ footprint across all buckets (kgCO₂e).

CongestionMetricsDTO 

class applications.congestion.dto.congestion.CongestionMetricsDTO(*, dates: list[str], running_pct: list[float], waiting_pct: list[float], max_running_pct: ~typing.Annotated[float, ~annotated_types.Ge(ge=0)], max_waiting_pct: ~typing.Annotated[float, ~annotated_types.Ge(ge=0)], avg_running_pct: ~typing.Annotated[float, ~annotated_types.Ge(ge=0)], avg_waiting_pct: ~typing.Annotated[float, ~annotated_types.Ge(ge=0)], start_date: str, end_date: str, duration_hours: ~typing.Annotated[float, ~annotated_types.Gt(gt=0)], resolution: ~applications.ait.enums.ComputeLoadResolution, data_type: ~applications.ait.enums.DataType, period: list[~applications.congestion.dto.congestion.PeriodEntryDTO], exceed_periods: list[str] = <factory>)

Bases: BaseDTO

Congestion analysis: running vs waiting resource utilization over time.

dates

Date labels for each time bucket.

Type:: list[str]

running_pct

Running utilization percentage per bucket.

Type:: list[float]

waiting_pct

Waiting utilization percentage per bucket.

Type:: list[float]

max_running_pct

Peak running utilization across all buckets.

Type:: float

max_waiting_pct

Peak waiting utilization across all buckets.

Type:: float

avg_running_pct

Mean running utilization across all buckets.

Type:: float

avg_waiting_pct

Mean waiting utilization across all buckets.

Type:: float

start_date

First date in the timeseries (YYYY-MM-DD).

Type:: str

end_date

Last date in the timeseries (YYYY-MM-DD).

Type:: str

duration_hours

Hours per resolution bucket (e.g. 24 for 1day).

Type:: float

resolution

Time bucket size used for the aggregation.

Type:: applications.ait.enums.ComputeLoadResolution

data_type

Resource type: ‘core’ for CPU, ‘GPU’ for GPU.

Type:: applications.ait.enums.DataType

period

Per-bucket breakdown with date and percentages.

Type:: list[applications.congestion.dto.congestion.PeriodEntryDTO]

hardware_mismatch: True when any running percentage exceeds 100%, indicating a hardware config issue.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

CoreLoadDTO 

class applications.load.dto.load.CoreLoadDTO(*, running_timestamps: list[str], waiting_timestamps: list[str], allocated_cores: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], requested_cores: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], total_capacity: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], resolution: ComputeLoadResolution, running_stats: LoadStats | None = None, waiting_stats: LoadStats | None = None)

Bases: BaseDTO

Core load with hardware capacity context.

Contains allocated and requested cores over time, along with hardware capacity information for computing utilization rates.

running_timestamps

Timestamps aligned with allocated_cores and total_capacity.

Type:: list[str]

waiting_timestamps

Timestamps aligned with requested_cores.

Type:: list[str]

allocated_cores

Cores currently allocated at each running timestamp.

Type:: list[float]

requested_cores

Cores requested (waiting) at each waiting timestamp.

Type:: list[float]

total_capacity

Hardware capacity aligned with running_timestamps.

Type:: list[float]

resolution

Time bucket size.

Type:: applications.ait.enums.ComputeLoadResolution

running_stats

Descriptive statistics over allocated_cores, or None.

Type:: applications.load.dto.load.LoadStats | None

waiting_stats

Descriptive statistics over requested_cores, or None.

Type:: applications.load.dto.load.LoadStats | None

Note

compute_load collapses consecutive nulls per state, so the RUNNING and WAITING timelines are not guaranteed to share an index.

property avg_allocated: float: Average allocated cores.

property avg_capacity: float: Average hardware capacity.

property max_allocated: float: Peak allocated cores.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

property utilization_rate: float: Average utilization (allocated / capacity).

property utilization_series: list[float]: Per-running-timestamp utilization (allocated / capacity). 0.0 where capacity is zero.

CorehourLoadDTO 

class applications.load.dto.load.CorehourLoadDTO(*, status: ResultStatus = ResultStatus.OK, running_timestamps: list[str], waiting_timestamps: list[str], allocated_cores: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], requested_cores: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], total_capacity: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], resolution: ComputeLoadResolution, running_stats: LoadStats | None = None, waiting_stats: LoadStats | None = None)

Bases: BaseDTO

Core-hour load timeseries (allocated cores × elapsed time).

Same underlying data as CoreLoadDTO but with computed fields oriented toward core-hour accounting rather than instantaneous utilization.

running_timestamps

Timestamps aligned with allocated_cores and total_capacity.

Type:: list[str]

waiting_timestamps

Timestamps aligned with requested_cores.

Type:: list[str]

allocated_cores

Allocated cores per running timestamp.

Type:: list[float]

requested_cores

Requested (waiting) cores per waiting timestamp.

Type:: list[float]

total_capacity

Hardware capacity per running timestamp.

Type:: list[float]

resolution

Time bucket size.

Type:: applications.ait.enums.ComputeLoadResolution

running_stats

Descriptive statistics over allocated_cores, or None.

Type:: applications.load.dto.load.LoadStats | None

waiting_stats

Descriptive statistics over requested_cores, or None.

Type:: applications.load.dto.load.LoadStats | None

property avg_allocated: float: Average allocated cores.

property avg_capacity: float: Average hardware capacity.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

property total_allocated: float

sum of per-bucket average allocated cores × bucket duration in hours.

Type:: Core-hours

property utilization_rate: float: Average utilization (allocated / capacity).

property utilization_series: list[float]: Per-timestamp utilization (allocated / capacity). 0.0 where capacity is zero.

CoresFlatDistributionDTO 

class applications.resources.dto.cores.CoresFlatDistributionDTO(*, bins: list[~applications.resources.dto.cores.CoreBinStats] = <factory>, extended_stats: ~applications.resources.dto.stats.ExtendedStats | None = None)

Bases: BaseDTO

Result of a flat (ungrouped) core allocation distribution query.

bins

Per-bin statistics ordered by bin range.

Type:: list[applications.resources.dto.cores.CoreBinStats]

extended_stats

Descriptive statistics over the full distribution (keys: min, max, mean, count, std).

Type:: applications.resources.dto.stats.ExtendedStats | None

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

CoresGroupedDistributionDTO 

class applications.resources.dto.cores.CoresGroupedDistributionDTO(*, groups: list[~applications.resources.dto.cores.CoresGroupStats] = <factory>, description: dict[str, ~typing.Any] = <factory>)

Bases: BaseDTO

Result of a grouped core allocation distribution query.

groups

One entry per group, each carrying all three metrics.

Type:: list[applications.resources.dto.cores.CoresGroupStats]

description

Grouping summary produced by grouping_resources_description.

Type:: dict[str, Any]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

CoresMemoryFlatMatrixDTO 

class applications.resources.dto.cores_memory.CoresMemoryFlatMatrixDTO(*, core_bin_labels: list[str] = <factory>, bins: list[~applications.resources.dto.cores_memory.CoresMemoryBinStats] = <factory>)

Bases: BaseDTO

Result of an ungrouped cores-vs-memory 2D matrix query.

core_bin_labels

Ordered core-allocation bin labels shared across all memory bins (the Y axis in bar charts).

Type:: list[str]

bins

One entry per memory bin, carrying job counts and core-hours across all core bins.

Type:: list[applications.resources.dto.cores_memory.CoresMemoryBinStats]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

CoresMemoryGroupedMatrixDTO 

class applications.resources.dto.cores_memory.CoresMemoryGroupedMatrixDTO(*, groups: list[~applications.resources.dto.cores_memory.CoresMemoryGroupStats] = <factory>, description: dict[str, ~typing.Any] = <factory>)

Bases: BaseDTO

Result of a grouped cores-vs-memory 2D matrix query.

groups

One entry per group, each carrying a per-memory-bin matrix.

Type:: list[applications.resources.dto.cores_memory.CoresMemoryGroupStats]

description

Grouping summary produced by grouping_resources_description.

Type:: dict[str, Any]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

CoresOccupancyDTO 

class applications.load.dto.occupancy.CoresOccupancyDTO(*, timestamps: list[str], unavailable: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], available: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], allocated: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], not_allocatable: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], powered_down: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], total_occupancy: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], total_capacity: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], resolution: Resolution)

Bases: BaseDTO

Cores occupancy timeseries from the cores_stats index.

timestamps

Timestamp strings after resolution aggregation.

Type:: list[str]

unavailable

Average cores in unavailable nodes per bucket.

Type:: list[float]

available

Average cores available for allocation per bucket.

Type:: list[float]

allocated

Average allocated cores per bucket.

Type:: list[float]

not_allocatable

Average cores in memory-bound nodes per bucket.

Type:: list[float]

powered_down

Average cores in powered-down nodes per bucket.

Type:: list[float]

total_occupancy

Max total occupancy (cores with jobs) per bucket.

Type:: list[float]

total_capacity

Average total hardware cores per bucket.

Type:: list[float]

resolution

Time bucket size.

Type:: applications.ait.enums.Resolution

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

CoresOccupancyGroupEntryDTO 

class applications.load.dto.occupancy.CoresOccupancyGroupEntryDTO(*, group: str, timestamps: list[str], unavailable: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], available: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], allocated: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], not_allocatable: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], powered_down: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], total_occupancy: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], total_capacity: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]])

Bases: BaseDTO

A single group’s cores occupancy timeseries.

group

Group identifier or ‘Others’.

Type:: str

timestamps

Timestamp strings after resolution aggregation.

Type:: list[str]

unavailable

Average cores in unavailable nodes per bucket.

Type:: list[float]

available

Average cores available for allocation per bucket.

Type:: list[float]

allocated

Average allocated cores per bucket.

Type:: list[float]

not_allocatable

Average cores in memory-bound nodes per bucket.

Type:: list[float]

powered_down

Average cores in powered-down nodes per bucket.

Type:: list[float]

total_occupancy

Max total occupancy (cores with jobs) per bucket.

Type:: list[float]

total_capacity

Average total hardware cores per bucket.

Type:: list[float]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

CostLoadDTO 

class applications.load.dto.load.CostLoadDTO(*, timestamps: list[str], cost_values: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], unit: str, resolution: ComputeLoadResolution, running_stats: LoadStats | None = None)

Bases: BaseDTO

Cluster cost load timeseries.

Contains computed cost values over time (currency unit depends on cluster configuration).

timestamps

List of timestamp strings in “YYYY-MM-DD HH:MM:SS” format.

Type:: list[str]

cost_values

Cost at each timestamp (in cluster’s configured currency).

Type:: list[float]

unit

Currency unit string (e.g., “EUR”, “USD”).

Type:: str

resolution

Time bucket size.

Type:: applications.ait.enums.ComputeLoadResolution

running_stats

Descriptive statistics over cost_values, or None.

Type:: applications.load.dto.load.LoadStats | None

property avg_cost: float: Average cost per bucket.

property max_cost: float: Peak cost in a single bucket.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

property total_cost: float: Total cost across all buckets.

DetailStatsBucketDTO 

class applications.consumers.dto.consumers.DetailStatsBucketDTO(*, count: int, data: list[~applications.consumers.dto.consumers.MetricStatsDTO] = <factory>)

Bases: BaseDTO

One filtered bucket of per-field statistics.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

DetailStatsDTO 

class applications.consumers.dto.consumers.DetailStatsDTO(*, currency: str, data: list[~applications.consumers.dto.consumers.DetailStatsBucketDTO] = <factory>)

Bases: BaseDTO

Result of a detail (per-field stats) query.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

EnergyMetricsDTO 

Bases: BaseDTO

Power and energy consumption KPI metrics.

The energy endpoint returns two independent sub-results (power and energy), each of which may succeed or fail independently. When both fail, the overall status is NO_DATA.

avg_power

Average power in watts, or None if unavailable.

Type:: float | None

max_power

Maximum power in watts, or None if unavailable.

Type:: float | None

power_unit

Power unit label (e.g. "watts"), or None.

Type:: str | None

total_energy

Total energy in Wh, or None if unavailable.

Type:: float | None

power_error

Error message from the power sub-query, or None.

Type:: str | None

energy_error

Error message from the energy sub-query, or None.

Type:: str | None

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

ExecTimeDistributionDTO 

class applications.throughput.dto.exec_time.ExecTimeDistributionDTO(*, bin_upper_hours: list[str] = <factory>, job_counts: list[int] = <factory>, resource_hour_sums: list[float] = <factory>, resource_field_available: bool = True)

Bases: BaseDTO

Execution time distribution histogram result.

bin_upper_hours

Upper bound of each bin in hours.

Type:: list[str]

job_counts

Number of jobs per bin.

Type:: list[int]

resource_hour_sums

Sum of resource-hours per bin.

Type:: list[float]

resource_field_available

Whether the resource-hours field exists in the index.

Type:: bool

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

ExecTimeVsTimelimitConfig 

class applications.throughput.dto.exec_time.ExecTimeVsTimelimitConfig(*, filters: ~applications.throughput.dto.exec_time.ExecTimeFilterConfig = <factory>, thresholds: list[~applications.throughput.dto.exec_time.CategoryThreshold] = <factory>)

Bases: BaseDTO

Full configuration for the execution time vs timelimit analysis.

Loaded from UIConfiguration when not overridden by the caller. Passed to compute_exec_time_vs_timelimit() and saved via save_exec_time_vs_timelimit_config().

filters

State-inclusion settings controlling which jobs are analysed.

Type:: applications.throughput.dto.exec_time.ExecTimeFilterConfig

thresholds

Ordered list of ratio range categories shown in the sunburst.

Type:: list[applications.throughput.dto.exec_time.CategoryThreshold]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

ExecTimeVsTimelimitDTO 

class applications.throughput.dto.exec_time.ExecTimeVsTimelimitDTO(*, categories: list[~applications.throughput.dto.exec_time.RatioCategoryDTO] = <factory>, total_jobs: int = 0, no_limit_jobs: int = 0)

Bases: BaseDTO

Execution time vs timelimit ratio result.

categories

Per-category job counts.

Type:: list[applications.throughput.dto.exec_time.RatioCategoryDTO]

total_jobs

Sum of all category counts.

Type:: int

no_limit_jobs

Number of jobs without a timelimit.

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GpuFlatDistributionDTO 

class applications.resources.dto.gpu.GpuFlatDistributionDTO(*, bins: list[~applications.resources.dto.gpu.GpuBinStats] = <factory>, extended_stats: ~applications.resources.dto.stats.ExtendedStats | None = None)

Bases: BaseDTO

Result of a flat (ungrouped) GPU distribution query.

bins

Per-bin statistics ordered by bin range.

Type:: list[applications.resources.dto.gpu.GpuBinStats]

extended_stats

Descriptive statistics over the full distribution (keys: min, max, mean, count, std).

Type:: applications.resources.dto.stats.ExtendedStats | None

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GpuGroupedDistributionDTO 

class applications.resources.dto.gpu.GpuGroupedDistributionDTO(*, groups: list[~applications.resources.dto.gpu.GpuGroupStats] = <factory>, description: dict[str, ~typing.Any] = <factory>)

Bases: BaseDTO

Result of a grouped GPU distribution query.

groups

One entry per group, each carrying all metrics.

Type:: list[applications.resources.dto.gpu.GpuGroupStats]

description

Grouping summary produced by grouping_resources_description.

Type:: dict[str, Any]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GpuLoadDTO 

class applications.load.dto.load.GpuLoadDTO(*, running_timestamps: list[str], waiting_timestamps: list[str], allocated_gpus: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], requested_gpus: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], total_capacity: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], resolution: ComputeLoadResolution, running_stats: LoadStats | None = None, waiting_stats: LoadStats | None = None)

Bases: BaseDTO

GPU load with hardware capacity context.

Contains allocated and requested GPUs over time, along with hardware capacity information for computing utilization rates.

running_timestamps

Timestamps aligned with allocated_gpus and total_capacity.

Type:: list[str]

waiting_timestamps

Timestamps aligned with requested_gpus.

Type:: list[str]

allocated_gpus

GPUs currently allocated at each running timestamp.

Type:: list[float]

requested_gpus

GPUs requested (waiting) at each waiting timestamp.

Type:: list[float]

total_capacity

Hardware capacity aligned with running_timestamps.

Type:: list[float]

resolution

Time bucket size.

Type:: applications.ait.enums.ComputeLoadResolution

running_stats

Descriptive statistics over allocated_gpus, or None.

Type:: applications.load.dto.load.LoadStats | None

waiting_stats

Descriptive statistics over requested_gpus, or None.

Type:: applications.load.dto.load.LoadStats | None

Note

compute_load collapses consecutive nulls per state, so the RUNNING and WAITING timelines are not guaranteed to share an index.

property avg_allocated: float: Average allocated GPUs.

property avg_capacity: float: Average hardware capacity.

property max_allocated: float: Peak allocated GPUs.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

property utilization_rate: float: Average utilization (allocated / capacity).

property utilization_series: list[float]: Per-timestamp utilization (allocated / capacity). 0.0 where capacity is zero.

GpuhourLoadDTO 

class applications.load.dto.load.GpuhourLoadDTO(*, running_timestamps: list[str], waiting_timestamps: list[str], allocated_gpus: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], requested_gpus: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], total_capacity: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], resolution: ComputeLoadResolution)

Bases: BaseDTO

GPU-hour load timeseries (allocated GPUs × elapsed time).

Same underlying data as GpuLoadDTO but with computed fields oriented toward GPU-hour accounting rather than instantaneous utilization.

running_timestamps

Timestamps aligned with allocated_gpus and total_capacity.

Type:: list[str]

waiting_timestamps

Timestamps aligned with requested_gpus.

Type:: list[str]

allocated_gpus

Allocated GPUs per running timestamp.

Type:: list[float]

requested_gpus

Requested (waiting) GPUs per waiting timestamp.

Type:: list[float]

total_capacity

Hardware GPU capacity per running timestamp.

Type:: list[float]

resolution

Time bucket size.

Type:: applications.ait.enums.ComputeLoadResolution

property avg_allocated: float: Average allocated GPUs.

property avg_capacity: float: Average hardware GPU capacity.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

property total_allocated: float: Sum of allocated GPUs across all buckets (proxy for GPU-hours).

property utilization_rate: float: Average utilization (allocated / capacity).

property utilization_series: list[float]: Per-timestamp utilization (allocated / capacity). 0.0 where capacity is zero.

GroupAggregationDTO 

class applications.consumers.dto.consumers.GroupAggregationDTO(*, global_summary: ~applications.consumers.dto.consumers.GroupGlobalDTO, data: list[~applications.consumers.dto.consumers.GroupRowDTO] = <factory>, cost_configured: bool = False, energy_configured: bool = False, co2_configured: bool = False)

Bases: BaseDTO

Result of a group-aggregation query.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupEntryDTO 

class applications.load.dto.load.GroupEntryDTO(*, group: str, running_timestamps: list[str], waiting_timestamps: list[str] | None = None, running_values: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], waiting_values: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]] | None = None, avg_running: float, max_running: float, running_stats: LoadStats | None = None, waiting_stats: LoadStats | None = None)

Bases: BaseDTO

A single group’s timeseries data within a grouped load result.

group

Group identifier (e.g., “project_alpha”, “Others”).

Type:: str

running_timestamps

Timestamps aligned with running_values.

Type:: list[str]

waiting_timestamps

Timestamps aligned with waiting_values, or None for metrics that only have a RUNNING state (cost, CO₂, power).

Type:: list[str] | None

running_values

Primary metric values (RUNNING state).

Type:: list[float]

waiting_values

Secondary metric values (WAITING state), or None for metrics that only have a RUNNING state (e.g., cost, CO₂, power).

Type:: list[float] | None

avg_running

Average of running_values.

Type:: float

max_running

Peak value in running_values.

Type:: float

running_stats

Descriptive statistics over running_values, or None.

Type:: applications.load.dto.load.LoadStats | None

waiting_stats

Descriptive statistics over waiting_values, or None.

Type:: applications.load.dto.load.LoadStats | None

Note

compute_load collapses consecutive nulls per state, so the RUNNING and WAITING timelines are not guaranteed to share an index.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupGlobalDTO 

class applications.consumers.dto.consumers.GroupGlobalDTO(*, total_count: int = 0, total_core_hours: float | None = None, total_gpu_hours: float | None = None, total_cost: float | None = None, total_energy: float | None = None, total_co2: float | None = None, groups: list[str] = <factory>)

Bases: BaseDTO

Aggregated totals across all group rows.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupRowDTO 

Bases: BaseDTO

A single row in the group-aggregation result.

Numeric fields are raw values from ES (or None when the metric was not configured for the cluster). Presentation rules (rounding, null placeholders) are applied by the view layer.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupedCo2LoadDTO 

class applications.load.dto.load.GroupedCo2LoadDTO(*, status: ResultStatus = ResultStatus.OK, groups: list[GroupEntryDTO], resolution: ComputeLoadResolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

Grouped CO₂ load — one GroupEntryDTO per group (waiting_values is None).

status

Query outcome — OK if data is present, otherwise the reason.

Type:: applications.ait.enums.ResultStatus

groups

Per-group CO₂ timeseries.

Type:: list[applications.load.dto.load.GroupEntryDTO]

resolution

Time bucket resolution.

Type:: applications.ait.enums.ComputeLoadResolution

grouping_key

Field used for grouping.

Type:: str

grouping_size

Max groups returned (excluding Others).

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupedCoreLoadDTO 

class applications.load.dto.load.GroupedCoreLoadDTO(*, groups: list[GroupEntryDTO], resolution: ComputeLoadResolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

Grouped core load — one GroupEntryDTO per group.

groups

Per-group core load timeseries.

Type:: list[applications.load.dto.load.GroupEntryDTO]

resolution

Time bucket resolution.

Type:: applications.ait.enums.ComputeLoadResolution

grouping_key

Field used for grouping.

Type:: str

grouping_size

Max groups returned (excluding Others).

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupedCoresOccupancyDTO 

class applications.load.dto.occupancy.GroupedCoresOccupancyDTO(*, groups: list[CoresOccupancyGroupEntryDTO], resolution: Resolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

Grouped cores occupancy — one CoresOccupancyGroupEntryDTO per group.

groups

Per-group cores occupancy timeseries.

Type:: list[applications.load.dto.occupancy.CoresOccupancyGroupEntryDTO]

resolution

Time bucket resolution.

Type:: applications.ait.enums.Resolution

grouping_key

Field used for grouping.

Type:: str

grouping_size

Max groups returned (excluding Others).

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupedCostLoadDTO 

class applications.load.dto.load.GroupedCostLoadDTO(*, status: ResultStatus = ResultStatus.OK, groups: list[GroupEntryDTO], unit: str, resolution: ComputeLoadResolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

Grouped cost load — one GroupEntryDTO per group (waiting_values is None).

status

Query outcome — OK if data is present, otherwise the reason.

Type:: applications.ait.enums.ResultStatus

groups

Per-group cost timeseries.

Type:: list[applications.load.dto.load.GroupEntryDTO]

unit

Currency unit (e.g. ‘EUR’, ‘USD’).

Type:: str

resolution

Time bucket resolution.

Type:: applications.ait.enums.ComputeLoadResolution

grouping_key

Field used for grouping.

Type:: str

grouping_size

Max groups returned (excluding Others).

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupedExecTimeEntryDTO 

class applications.throughput.dto.exec_time.GroupedExecTimeEntryDTO(*, grouping: str, group_type: str, bin_upper_hours: list[str], job_counts: list[int], resource_hour_sums: list[float], resource_field_available: bool = True)

Bases: BaseDTO

One group’s execution time distribution histogram.

grouping

ES field used for grouping (e.g. "Account", "UID").

Type:: str

group_type

The group value (e.g. "physics"), or "Others" for the overflow bucket.

Type:: str

bin_upper_hours

Upper bound of each bin in hours (as strings).

Type:: list[str]

job_counts

Number of jobs per bin.

Type:: list[int]

resource_hour_sums

Sum of resource-hours (core or GPU) per bin.

Type:: list[float]

resource_field_available

False when the resource-hours field is absent from the index — callers should omit the resource chart in that case.

Type:: bool

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupedExecTimeVsTimelimitEntryDTO 

class applications.throughput.dto.exec_time.GroupedExecTimeVsTimelimitEntryDTO(*, grouping: str, group_type: str, categories: list[RatioCategoryDTO])

Bases: BaseDTO

One group’s exec-time vs timelimit ratio breakdown.

grouping

ES field used for grouping (e.g. "Account").

Type:: str

group_type

The group value (e.g. "physics"), or "Others" for the overflow bucket.

Type:: str

categories

Per-threshold job counts, including an optional "No Limit" entry for jobs without a timelimit.

Type:: list[applications.throughput.dto.exec_time.RatioCategoryDTO]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupedGpuLoadDTO 

class applications.load.dto.load.GroupedGpuLoadDTO(*, groups: list[GroupEntryDTO], resolution: ComputeLoadResolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

Grouped GPU load — one GroupEntryDTO per group.

groups

Per-group GPU load timeseries.

Type:: list[applications.load.dto.load.GroupEntryDTO]

resolution

Time bucket resolution.

Type:: applications.ait.enums.ComputeLoadResolution

grouping_key

Field used for grouping.

Type:: str

grouping_size

Max groups returned (excluding Others).

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupedJobLoadDTO 

class applications.load.dto.load.GroupedJobLoadDTO(*, groups: list[GroupEntryDTO], resolution: ComputeLoadResolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

Grouped job count load — one GroupEntryDTO per group.

groups

Per-group job load timeseries.

Type:: list[applications.load.dto.load.GroupEntryDTO]

resolution

Time bucket resolution.

Type:: applications.ait.enums.ComputeLoadResolution

grouping_key

Field used for grouping.

Type:: str

grouping_size

Max groups returned (excluding Others).

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupedJobsStatusDTO 

class applications.state.dto.state.GroupedJobsStatusDTO(*, data: dict[~applications.ait.enums.JobState, list[~applications.state.dto.state.StateGroupEntryDTO]] = <factory>)

Bases: BaseDTO

Grouped job status result, keyed by state name.

Each key is a job state (e.g. COMPLETED), and the value is a list of StateGroupEntryDTO — one per group (e.g. per user account). Returned as part of a tuple[GroupedJobsStatusDTO | None, ResultStatus].

data

Groups keyed by state name (e.g. COMPLETED -> [group1, group2]).

Type:: dict[applications.ait.enums.JobState, list[applications.state.dto.state.StateGroupEntryDTO]]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupedJobsStatusYmsDTO 

class applications.state.dto.state.GroupedJobsStatusYmsDTO(*, groups: list[~applications.state.dto.state.GroupedYmsEntryDTO] = <factory>)

Bases: BaseDTO

Grouped year-month status result: one entry per group.

Returned by compute_jobs_status_yms_grouped as part of a tuple[GroupedJobsStatusYmsDTO | None, ResultStatus]. Each group contains a full month-by-month breakdown with per-state counts.

groups

Per-group year-month data.

Type:: list[applications.state.dto.state.GroupedYmsEntryDTO]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupedNodesOccupancyDTO 

class applications.load.dto.occupancy.GroupedNodesOccupancyDTO(*, groups: list[NodesOccupancyGroupEntryDTO], resolution: Resolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

Grouped nodes occupancy — one NodesOccupancyGroupEntryDTO per group.

groups

Per-group nodes occupancy timeseries.

Type:: list[applications.load.dto.occupancy.NodesOccupancyGroupEntryDTO]

resolution

Time bucket resolution.

Type:: applications.ait.enums.Resolution

grouping_key

Field used for grouping.

Type:: str

grouping_size

Max groups returned (excluding Others).

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupedPowerLoadDTO 

class applications.load.dto.load.GroupedPowerLoadDTO(*, status: ResultStatus = ResultStatus.OK, groups: list[GroupEntryDTO], resolution: ComputeLoadResolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

Grouped power load — one GroupEntryDTO per group (waiting_values is None).

status

Query outcome — OK if data is present, otherwise the reason.

Type:: applications.ait.enums.ResultStatus

groups

Per-group power timeseries.

Type:: list[applications.load.dto.load.GroupEntryDTO]

resolution

Time bucket resolution.

Type:: applications.ait.enums.ComputeLoadResolution

grouping_key

Field used for grouping.

Type:: str

grouping_size

Max groups returned (excluding Others).

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

GroupedYmsEntryDTO 

class applications.state.dto.state.GroupedYmsEntryDTO(*, group_name: str | int, total_count: ~typing.Annotated[float, ~annotated_types.Ge(ge=0)], states: list[~applications.ait.enums.JobState] = <factory>, year_months: list[str] = <factory>, entries: list[~applications.state.dto.state.YmsEntryDTO] = <factory>)

Bases: BaseDTO

One group’s complete year-month data in a grouped YMS query.

Contains the same structure as JobsStatusYmsDTO but scoped to a single group value (e.g. all months for user “alice”). Groups beyond grouping_size are aggregated into an “Others” entry.

group_name

Group identifier (e.g. user name, account, ‘Others’).

Type:: str | int

total_count

Sum across all months in this group.

Type:: float

states

Unique state names in this group.

Type:: list[applications.ait.enums.JobState]

year_months

Ordered YYYY-MM labels.

Type:: list[str]

entries

Per-month data with state breakdowns.

Type:: list[applications.state.dto.state.YmsEntryDTO]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

HardwareStatsDTO 

class applications.kpi.dto.logs.HardwareStatsDTO(*, min_value: int | None = None, max_value: int | None = None, avg_value: int = 0)

Bases: BaseDTO

Min/max/avg hardware counts over a time range.

min_value

Minimum hardware count in the period, or None if unavailable.

Type:: int | None

max_value

Maximum hardware count in the period, or None if unavailable.

Type:: int | None

avg_value

Average hardware count in the period.

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

JobCountDTO 

class applications.ait.dto.jobs.JobCountDTO(*, total_jobs_count: Annotated[int, Ge(ge=0)])

Bases: BaseDTO

Total count of jobs matching the current filters.

total_jobs_count

Number of jobs matching the current filters.

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

JobFieldsDTO 

class applications.ait.dto.jobs.JobFieldsDTO(*, fields: list[str], total_available: Annotated[int, Ge(ge=0)])

Bases: BaseDTO

Available fields from the Elasticsearch mapping, priority-ordered.

fields

Priority-ordered list of available field names.

Type:: list[str]

total_available

Total number of fields in the mapping.

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

JobFrequencyDTO 

class applications.throughput.dto.job_freq.JobFrequencyDTO(*, job_count: ~pandas.core.series.Series | None = None, date: ~pandas.core.indexes.base.Index | None = None, description: dict = <factory>, resolution: ~applications.ait.enums.Resolution | None = None, datetime_col: ~applications.throughput.dto.common.ThroughputDatetimeCol = ThroughputDatetimeCol.SUBMIT)

Bases: BaseDTO

Job frequency timeseries result.

Contains job counts per time bucket with descriptive statistics.

job_count

Job counts per time bucket, or None when the query returned no data.

Type:: pandas.core.series.Series | None

date

Formatted date strings for each time bucket, or None when no data.

Type:: pandas.core.indexes.base.Index | None

description

Descriptive statistics dict with keys: data, columns.

Type:: dict

resolution

Time bucket size used for aggregation, or None when no data.

Type:: applications.ait.enums.Resolution | None

datetime_col

Timestamp column used for bucketing.

Type:: applications.throughput.dto.common.ThroughputDatetimeCol

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

JobLoadDTO 

class applications.load.dto.load.JobLoadDTO(*, running_timestamps: list[str], waiting_timestamps: list[str], running_jobs: list[Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], waiting_jobs: list[Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], resolution: ComputeLoadResolution, running_stats: LoadStats | None = None, waiting_stats: LoadStats | None = None)

Bases: BaseDTO

Job load timeseries with key statistics.

Contains running and waiting job counts over time, along with computed statistics like averages and maximums.

running_timestamps

Timestamps aligned with running_jobs.

Type:: list[str]

waiting_timestamps

Timestamps aligned with waiting_jobs.

Type:: list[str]

running_jobs

Jobs currently running at each running timestamp.

Type:: list[int]

waiting_jobs

Jobs waiting to run at each waiting timestamp.

Type:: list[int]

resolution

Time bucket size (e.g., “1hour”, “1day”).

Type:: applications.ait.enums.ComputeLoadResolution

running_stats

Descriptive statistics over running_jobs, or None.

Type:: applications.load.dto.load.LoadStats | None

waiting_stats

Descriptive statistics over waiting_jobs, or None.

Type:: applications.load.dto.load.LoadStats | None

Note

compute_load collapses consecutive nulls per state, so the RUNNING and WAITING timelines are not guaranteed to share an index. Always pair running_jobs with running_timestamps and waiting_jobs with waiting_timestamps.

property avg_running: float: Average number of running jobs.

property avg_waiting: float: Average number of waiting jobs.

property max_running: int: Maximum running jobs at any point.

property max_waiting: int: Maximum waiting jobs at any point.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

JobsPageDTO 

class applications.ait.dto.jobs.JobsPageDTO(*, jobs: list[dict[str, Any]], total_count: Annotated[int, Ge(ge=0)], navigable_count: Annotated[int, Ge(ge=0)], offset: Annotated[int, Ge(ge=0)], limit: Annotated[int, Ge(ge=1)], truncated: bool = False)

Bases: BaseDTO

A page of job records with pagination metadata.

jobs

Job records for the current page.

Type:: list[dict[str, Any]]

total_count

True total number of matching jobs.

Type:: int

navigable_count

Capped at 10k for Elasticsearch pagination.

Type:: int

offset

Starting index of this page.

Type:: int

limit

Maximum number of jobs per page.

Type:: int

truncated

True when total_count exceeds the 10k ES pagination window.

Type:: bool

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

JobsStatusDTO 

class applications.state.dto.state.JobsStatusDTO(*, total_count: ~typing.Annotated[float, ~annotated_types.Ge(ge=0)] = 0, states: list[~applications.ait.enums.JobState] = <factory>, entries: list[~applications.state.dto.state.StateCountDTO] = <factory>)

Bases: BaseDTO

Flat job status aggregation: one entry per scheduler state.

Returned by compute_jobs_status as part of a tuple[JobsStatusDTO | None, ResultStatus].

total_count

Sum of all state counts.

Type:: float

states

Ordered list of state names.

Type:: list[applications.ait.enums.JobState]

entries

Per-state counts.

Type:: list[applications.state.dto.state.StateCountDTO]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

JobsStatusYmsDTO 

class applications.state.dto.state.JobsStatusYmsDTO(*, total_count: ~typing.Annotated[float, ~annotated_types.Ge(ge=0)] = 0, states: list[~applications.ait.enums.JobState] = <factory>, year_months: list[str] = <factory>, entries: list[~applications.state.dto.state.YmsEntryDTO] = <factory>)

Bases: BaseDTO

Flat year-month status aggregation.

Returned by compute_jobs_status_yms as part of a tuple[JobsStatusYmsDTO | None, ResultStatus]. Contains one YmsEntryDTO per month, ordered chronologically.

total_count

Sum across all months.

Type:: float

states

Unique state names across all months.

Type:: list[applications.ait.enums.JobState]

year_months

Ordered YYYY-MM labels.

Type:: list[str]

entries

Per-month data with state breakdowns.

Type:: list[applications.state.dto.state.YmsEntryDTO]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

LogsMetricsDTO 

class applications.kpi.dto.logs.LogsMetricsDTO(*, date_from: str = 'forever', date_to: str = 'the end of time', job_count: int = 0, total_core_hours: float = 0, total_gpu_hours: float | None = None, cluster_usage: float = 0, gpu_usage: float = 0, core_stats: ~applications.kpi.dto.logs.HardwareStatsDTO = <factory>, gpu_stats: ~applications.kpi.dto.logs.HardwareStatsDTO = <factory>, user_count: int = 0)

Bases: BaseDTO

Job-level KPI metrics: counts, resource hours, usage, hardware info.

date_from

Start of the date range (formatted string).

Type:: str

date_to

End of the date range (formatted string).

Type:: str

job_count

Total number of jobs.

Type:: int

total_core_hours

Sum of core-hours across all jobs.

Type:: float

total_gpu_hours

Sum of GPU-hours, or None if the field is absent.

Type:: float | None

cluster_usage

Cluster CPU usage percentage.

Type:: float

gpu_usage

Cluster GPU usage percentage.

Type:: float

core_stats

Core count statistics (min/max/avg).

Type:: applications.kpi.dto.logs.HardwareStatsDTO

gpu_stats

GPU count statistics (min/max/avg).

Type:: applications.kpi.dto.logs.HardwareStatsDTO

user_count

Number of unique users.

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

MemoryFlatDistributionDTO 

class applications.resources.dto.memory.MemoryFlatDistributionDTO(*, bins: list[~applications.resources.dto.memory.MemoryBinStats] = <factory>, extended_stats: ~applications.resources.dto.stats.ExtendedStats | None = None)

Bases: BaseDTO

Result of a flat (ungrouped) memory distribution query.

bins

Per-bin job counts ordered by memory range.

Type:: list[applications.resources.dto.memory.MemoryBinStats]

extended_stats

Rounded descriptive statistics over the full distribution (keys: min, max, mean, count, std).

Type:: applications.resources.dto.stats.ExtendedStats | None

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

MemoryGroupedDistributionDTO 

class applications.resources.dto.memory.MemoryGroupedDistributionDTO(*, groups: list[~applications.resources.dto.memory.MemoryGroupStats] = <factory>, description: dict[str, ~typing.Any] = <factory>)

Bases: BaseDTO

Result of a grouped memory distribution query.

groups

One entry per group, each carrying per-bin job counts.

Type:: list[applications.resources.dto.memory.MemoryGroupStats]

description

Grouping summary produced by grouping_resources_description.

Type:: dict[str, Any]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

MemoryRatioFlatDistributionDTO 

class applications.resources.dto.consumed_vs_requested_memory.MemoryRatioFlatDistributionDTO(*, bins: list[~applications.resources.dto.consumed_vs_requested_memory.MemoryRatioBinStats] = <factory>, extended_stats: ~applications.resources.dto.stats.ExtendedStats | None = None)

Bases: BaseDTO

Flat (ungrouped) memory ratio distribution query result.

bins

Per-bin job counts ordered by percentage range.

Type:: list[applications.resources.dto.consumed_vs_requested_memory.MemoryRatioBinStats]

extended_stats

Rounded descriptive statistics over the full distribution (keys: min, max, mean, count, std).

Type:: applications.resources.dto.stats.ExtendedStats | None

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

MemoryRatioGroupedDistributionDTO 

class applications.resources.dto.consumed_vs_requested_memory.MemoryRatioGroupedDistributionDTO(*, groups: list[~applications.resources.dto.consumed_vs_requested_memory.MemoryRatioGroupStats] = <factory>, description: dict[str, ~typing.Any] = <factory>)

Bases: BaseDTO

Grouped memory ratio distribution query result.

groups

One entry per group, each carrying per-bin job counts.

Type:: list[applications.resources.dto.consumed_vs_requested_memory.MemoryRatioGroupStats]

description

Grouping summary produced by grouping_resources_description.

Type:: dict[str, Any]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

MetricStatsDTO 

class applications.consumers.dto.consumers.MetricStatsDTO(*, name: str, count: int, min: float | None = None, max: float | None = None, avg: float | None = None, sum: float | None = None)

Bases: BaseDTO

One ES stats aggregation result for a single metric field.

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

NodesFlatDistributionDTO 

class applications.resources.dto.nodes.NodesFlatDistributionDTO(*, bins: list[~applications.resources.dto.nodes.NodesBinStats] = <factory>, extended_stats: ~applications.resources.dto.stats.ExtendedStats | None = None)

Bases: BaseDTO

Result of a flat (ungrouped) node allocation distribution query.

bins

Per-bin job counts ordered by node range.

Type:: list[applications.resources.dto.nodes.NodesBinStats]

extended_stats

Rounded descriptive statistics over the full distribution (keys: min, max, mean, count, std).

Type:: applications.resources.dto.stats.ExtendedStats | None

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

NodesGroupedDistributionDTO 

class applications.resources.dto.nodes.NodesGroupedDistributionDTO(*, groups: list[~applications.resources.dto.nodes.NodesGroupStats] = <factory>, description: dict[str, ~typing.Any] = <factory>)

Bases: BaseDTO

Result of a grouped node allocation distribution query.

groups

One entry per group, each carrying per-bin job counts.

Type:: list[applications.resources.dto.nodes.NodesGroupStats]

description

Grouping summary produced by grouping_resources_description.

Type:: dict[str, Any]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

NodesOccupancyDTO 

class applications.load.dto.occupancy.NodesOccupancyDTO(*, timestamps: list[str], unavailable: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], available: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], partially_available: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], fully_occupied: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], memory_bound: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], compute_bound: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], powered_down: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], total: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], resolution: Resolution)

Bases: BaseDTO

Nodes occupancy timeseries from the cores_stats index.

timestamps

Timestamp strings after resolution aggregation.

Type:: list[str]

unavailable

Average unavailable nodes per bucket.

Type:: list[float]

available

Average fully available nodes per bucket.

Type:: list[float]

partially_available

Average partially available nodes per bucket.

Type:: list[float]

fully_occupied

Average fully occupied nodes per bucket.

Type:: list[float]

memory_bound

Average memory-bound nodes per bucket.

Type:: list[float]

compute_bound

Average compute-bound nodes per bucket.

Type:: list[float]

powered_down

Average powered-down nodes per bucket.

Type:: list[float]

total

Average total node count per bucket.

Type:: list[float]

resolution

Time bucket size.

Type:: applications.ait.enums.Resolution

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

NodesOccupancyGroupEntryDTO 

class applications.load.dto.occupancy.NodesOccupancyGroupEntryDTO(*, group: str, timestamps: list[str], unavailable: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], available: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], partially_available: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], fully_occupied: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], memory_bound: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], compute_bound: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], powered_down: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], total: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]])

Bases: BaseDTO

A single group’s nodes occupancy timeseries.

group

Group identifier or ‘Others’.

Type:: str

timestamps

Timestamp strings after resolution aggregation.

Type:: list[str]

unavailable

Average unavailable nodes per bucket.

Type:: list[float]

available

Average fully available nodes per bucket.

Type:: list[float]

partially_available

Average partially available nodes per bucket.

Type:: list[float]

fully_occupied

Average fully occupied nodes per bucket.

Type:: list[float]

memory_bound

Average memory-bound nodes per bucket.

Type:: list[float]

compute_bound

Average compute-bound nodes per bucket.

Type:: list[float]

powered_down

Average powered-down nodes per bucket.

Type:: list[float]

total

Average total node count per bucket.

Type:: list[float]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

PeriodEntryDTO 

class applications.congestion.dto.congestion.PeriodEntryDTO(*, date: str, running_pct: Annotated[float, Ge(ge=0)], waiting_pct: Annotated[float, Ge(ge=0)])

Bases: BaseDTO

Single time bucket with running/waiting percentages.

date

Date label for the bucket (YYYY-MM-DD).

Type:: str

running_pct

Running resource utilization as a percentage.

Type:: float

waiting_pct

Waiting resource utilization as a percentage.

Type:: float

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

PowerLoadDTO 

class applications.load.dto.load.PowerLoadDTO(*, timestamps: list[str], power_values: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], resolution: ComputeLoadResolution, running_stats: LoadStats | None = None)

Bases: BaseDTO

Cluster power consumption timeseries.

Contains power draw values over time (in watts).

timestamps

List of timestamp strings in “YYYY-MM-DD HH:MM:SS” format.

Type:: list[str]

power_values

Power consumption at each timestamp (watts).

Type:: list[float]

resolution

Time bucket size.

Type:: applications.ait.enums.ComputeLoadResolution

running_stats

Descriptive statistics over power_values, or None.

Type:: applications.load.dto.load.LoadStats | None

property avg_power: float: Average power draw (watts).

property max_power: float: Peak power draw (watts).

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

RatioCategoryDTO 

class applications.throughput.dto.exec_time.RatioCategoryDTO(*, name: str, count: int)

Bases: BaseDTO

A single category bucket from the exec-time / timelimit ratio aggregation.

name

Category display name (e.g. "Optimal", "No Limit").

Type:: str

count

Number of jobs in this category.

Type:: int

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

RunningAndWaitingUsersDTO 

class applications.concusers.dto.concurrent_users.RunningAndWaitingUsersDTO(*, resolution: ComputeLoadResolution, dates: list[str] = [], user_counts: list[int] = [], stats: UserCountStats | None = None)

Bases: BaseDTO

Result of a run-and-wait concurrent users query.

resolution

Time resolution for bucketing (subset of full Resolution enum).

Type:: applications.ait.enums.ComputeLoadResolution

dates

Formatted timestamps, one per time bucket.

Type:: list[str]

user_counts

Distinct user count per time bucket.

Type:: list[int]

stats

Descriptive statistics over the user-count series, or None.

Type:: applications.concusers.dto.concurrent_users.UserCountStats | None

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

SlowdownDistributionDTO 

class applications.throughput.dto.slowdown.SlowdownDistributionDTO(*, slowdown: DataFrame | None = None, datetime_col: SubmissionDatetimeCol = SubmissionDatetimeCol.SUBMIT)

Bases: BaseDTO

Slowdown PDF/CDF distribution result.

slowdown

DataFrame with columns [value, frequency, cdf].

Type:: pandas.core.frame.DataFrame | None

datetime_col

The timestamp column used (Submit or Eligible).

Type:: applications.throughput.dto.common.SubmissionDatetimeCol

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

SlowdownStatsDTO 

class applications.throughput.dto.slowdown.SlowdownStatsDTO(*, description: dict = <factory>, datetime_col: ~applications.throughput.dto.common.SubmissionDatetimeCol = SubmissionDatetimeCol.SUBMIT)

Bases: BaseDTO

Slowdown descriptive statistics result.

description

Descriptive statistics dict with keys: data, columns, median.

Type:: dict

datetime_col

The timestamp column used (Submit or Eligible).

Type:: applications.throughput.dto.common.SubmissionDatetimeCol

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

StateCountDTO 

class applications.state.dto.state.StateCountDTO(*, state: JobState, count: Annotated[float, Ge(ge=0)])

Bases: BaseDTO

Aggregated metric value for a single job state.

Used as a building block in both flat and grouped results. The count field holds whatever metric was requested — job count when the category is STATE, or core-hours / cost / energy when a metric category is selected.

state

Job state (e.g. COMPLETED, FAILED, CANCELLED).

Type:: applications.ait.enums.JobState

count

Aggregated value for this state (jobs, core-hours, cost, etc.).

Type:: float

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

StateGroupEntryDTO 

class applications.state.dto.state.StateGroupEntryDTO(*, group_name: str | int, grouping_type: ~applications.state.dto.state.GroupingField | str, total_count: ~typing.Annotated[float, ~annotated_types.Ge(ge=0)], states: list[~applications.ait.enums.JobState] = <factory>, entries: list[~applications.state.dto.state.StateCountDTO])

Bases: BaseDTO

One group’s contribution to a single state in a grouped status query.

When jobs are grouped by a field (e.g. Account, UID), each state (COMPLETED, FAILED, …) contains a list of these entries — one per group value (e.g. “user1”, “user2”, “Others”).

entries lists the per-state counts within this group, while total_count is their sum.

group_name

Group identifier (e.g. user name, account, ‘Others’).

Type:: str | int

grouping_type

Grouping field used (e.g. ‘Account’, ‘UID’, ‘GID’).

Type:: applications.state.dto.state.GroupingField | str

total_count

Sum of all state counts in this group.

Type:: float

states

State names present in this group.

Type:: list[applications.ait.enums.JobState]

entries

Per-state counts within this group.

Type:: list[applications.state.dto.state.StateCountDTO]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

SubmitHourDTO 

class applications.throughput.dto.submit_date.SubmitHourDTO(*, submit_hour: list = <factory>, submit_hour_count: list = <factory>)

Bases: BaseDTO

Hour-of-day submission histogram.

submit_hour

Hour values (0–23).

Type:: list

submit_hour_count

Job counts per hour.

Type:: list

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

SubmitUserCountsDTO 

class applications.concusers.dto.concurrent_users.SubmitUserCountsDTO(*, resolution: ComputeLoadResolution, dates: list[str] = [], user_counts: list[int] = [], stats: UserCountStats | None = None)

Bases: BaseDTO

Result of a submit-based concurrent users query.

resolution

Time resolution for bucketing (subset of full Resolution enum).

Type:: applications.ait.enums.ComputeLoadResolution

dates

Formatted timestamps, one per time bucket.

Type:: list[str]

user_counts

Distinct user count per time bucket.

Type:: list[int]

stats

Descriptive statistics over the user-count series, or None.

Type:: applications.concusers.dto.concurrent_users.UserCountStats | None

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

SubmitWeekdayDTO 

class applications.throughput.dto.submit_date.SubmitWeekdayDTO(*, submit_weekday: list[str] = <factory>, submit_weekday_count: list = <factory>)

Bases: BaseDTO

Day-of-week submission histogram.

submit_weekday

Weekday names (Monday–Sunday).

Type:: list[str]

submit_weekday_count

Job counts per weekday.

Type:: list

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

UserCountStats 

Bases: BaseDTO

Descriptive statistics for a user-count series.

All values are rounded to one decimal place. A field is None when the underlying value is NaN (e.g. empty input series).

mean

Arithmetic mean of user counts.

Type:: float | None

std

Standard deviation.

Type:: float | None

min

Minimum observed count.

Type:: float | None

p10

10th percentile.

Type:: float | None

p20

20th percentile.

Type:: float | None

p30

30th percentile.

Type:: float | None

p40

40th percentile.

Type:: float | None

median

50th percentile (median).

Type:: float | None

p60

60th percentile.

Type:: float | None

p70

70th percentile.

Type:: float | None

p80

80th percentile.

Type:: float | None

p90

90th percentile.

Type:: float | None

max

Maximum observed count.

Type:: float | None

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

WaitTimeDistributionDTO 

class applications.throughput.dto.wait_time.WaitTimeDistributionDTO(*, wait_time: DataFrame | None = None, datetime_col: SubmissionDatetimeCol = SubmissionDatetimeCol.SUBMIT)

Bases: BaseDTO

Wait time PDF/CDF distribution result.

wait_time

DataFrame with columns [value, frequency, cdf], or None.

Type:: pandas.core.frame.DataFrame | None

datetime_col

The timestamp column used (Submit or Eligible).

Type:: applications.throughput.dto.common.SubmissionDatetimeCol

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

WaitTimeStatsDTO 

class applications.throughput.dto.wait_time.WaitTimeStatsDTO(*, description: dict = <factory>, datetime_col: ~applications.throughput.dto.common.SubmissionDatetimeCol = SubmissionDatetimeCol.SUBMIT)

Bases: BaseDTO

Wait time descriptive statistics result.

description

Descriptive statistics dict with keys: data, columns, median.

Type:: dict

datetime_col

The timestamp column used (Submit or Eligible).

Type:: applications.throughput.dto.common.SubmissionDatetimeCol

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True, 'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

YmsEntryDTO 

class applications.state.dto.state.YmsEntryDTO(*, year_month: str, count: Annotated[float, Ge(ge=0)], state_counts: list[YmsStateCountDTO])

Bases: BaseDTO

A single year-month bucket with its per-state breakdown.

Represents one month’s worth of data. count is the month total, and state_counts breaks it down by scheduler state.

year_month

Year-month label (YYYY-MM).

Type:: str

count

Total count for this month.

Type:: float

state_counts

Per-state breakdown within this month.

Type:: list[applications.state.dto.state.YmsStateCountDTO]

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

YmsStateCountDTO 

class applications.state.dto.state.YmsStateCountDTO(*, state: JobState, count: Annotated[float, Ge(ge=0)])

Bases: BaseDTO

Aggregated metric value for a single state within a year-month bucket.

Similar to StateCountDTO but used in the YMS (year-month-status) context where results are further bucketed by month.

state

Job state.

Type:: applications.ait.enums.JobState

count

Aggregated value for this state in this month.

Type:: float

model_config: ClassVar[ConfigDict] = {'frozen': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].