Data Transfer Objects

CarbonFootprintDTO 

class applications.kpi.dto.carbon_footprint.CarbonFootprintDTO(*, status: ResultStatus = ResultStatus.OK, total_carbon_footprint: float = 0)

Bases: BaseDTO

CO2 emissions KPI metric.

status

Query outcome.

Type:: applications.ait.enums.ResultStatus

total_carbon_footprint

Total CO2 emissions in kg.

Type:: float

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

class applications.load.dto.load.Co2LoadDTO(*, status: ResultStatus = ResultStatus.OK, timestamps: list[str], co2_values: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], resolution: Resolution)

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.Resolution

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: Annotated[float, Ge(ge=0)], max_waiting_pct: Annotated[float, Ge(ge=0)], avg_running_pct: Annotated[float, Ge(ge=0)], avg_waiting_pct: Annotated[float, Ge(ge=0)], start_date: str, end_date: str, duration_hours: Annotated[float, Gt(gt=0)], resolution: Resolution, data_type: DataType, period: list[PeriodEntryDTO], hardware_mismatch: bool = False)

Bases: BaseDTO

Congestion analysis: running vs waiting resource utilization over time.

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(*, status: ResultStatus = ResultStatus.OK, 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: Resolution)

Bases: BaseDTO

Core load with hardware capacity context.

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

timestamps

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

Type:: list[str]

allocated_cores

Cores currently allocated at each timestamp.

Type:: list[float]

requested_cores

Cores requested (waiting) at each timestamp.

Type:: list[float]

total_capacity

Hardware capacity at each timestamp.

Type:: list[float]

resolution

Time bucket size.

Type:: applications.ait.enums.Resolution

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-timestamp utilization (allocated / capacity). 0.0 where capacity is zero.

CorehourLoadDTO 

class applications.load.dto.load.CorehourLoadDTO(*, status: ResultStatus = ResultStatus.OK, 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: Resolution)

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.

timestamps

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

Type:: list[str]

allocated_cores

Allocated cores at each timestamp.

Type:: list[float]

requested_cores

Requested (waiting) cores at each timestamp.

Type:: list[float]

total_capacity

Hardware capacity at each timestamp.

Type:: list[float]

resolution

Time bucket size.

Type:: applications.ait.enums.Resolution

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 allocated cores across all buckets (proxy for 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.

CoresOccupancyDTO 

class applications.load.dto.occupancy.CoresOccupancyDTO(*, status: ResultStatus = ResultStatus.OK, 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.

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(*, status: ResultStatus = ResultStatus.OK, timestamps: list[str], cost_values: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], unit: str, resolution: Resolution)

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.Resolution

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.

CostMetricsDTO 

class applications.kpi.dto.cost.CostMetricsDTO(*, status: ResultStatus = ResultStatus.OK, total_cost: float = 0.0)

Bases: BaseDTO

Total cost KPI metric.

status

Query outcome.

Type:: applications.ait.enums.ResultStatus

total_cost

Total cost.

Type:: float

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

EnergyMetricsDTO 

class applications.kpi.dto.energy.EnergyMetricsDTO(*, status: ResultStatus = ResultStatus.OK, avg_power: float | None = None, max_power: float | None = None, power_unit: str | None = None, total_energy: float | None = None, power_error: str | None = None, energy_error: str | None = None)

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 set to NO_DATA.

status

Overall query outcome.

Type:: applications.ait.enums.ResultStatus

avg_power

Average power as a string, or None if unavailable.

Type:: float | None

max_power

Maximum power as a string, 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 as a string, 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(*, status: ~applications.ait.enums.ResultStatus = ResultStatus.OK, 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.

status

Query outcome.

Type:: applications.ait.enums.ResultStatus

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].

ExecTimeVsTimelimitDTO 

class applications.throughput.dto.exec_time.ExecTimeVsTimelimitDTO(*, status: ~applications.ait.enums.ResultStatus = ResultStatus.OK, 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.

status

Query outcome.

Type:: applications.ait.enums.ResultStatus

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].

GpuLoadDTO 

class applications.load.dto.load.GpuLoadDTO(*, status: ResultStatus = ResultStatus.OK, 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: Resolution)

Bases: BaseDTO

GPU load with hardware capacity context.

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

timestamps

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

Type:: list[str]

allocated_gpus

GPUs currently allocated at each timestamp.

Type:: list[float]

requested_gpus

GPUs requested (waiting) at each timestamp.

Type:: list[float]

total_capacity

Hardware capacity at each timestamp.

Type:: list[float]

resolution

Time bucket size.

Type:: applications.ait.enums.Resolution

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(*, status: ResultStatus = ResultStatus.OK, 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: Resolution)

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.

timestamps

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

Type:: list[str]

allocated_gpus

Allocated GPUs at each timestamp.

Type:: list[float]

requested_gpus

Requested (waiting) GPUs at each timestamp.

Type:: list[float]

total_capacity

Hardware GPU capacity at each timestamp.

Type:: list[float]

resolution

Time bucket size.

Type:: applications.ait.enums.Resolution

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.

GroupEntryDTO 

class applications.load.dto.load.GroupEntryDTO(*, group: str, timestamps: list[str], 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)

Bases: BaseDTO

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

group

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

Type:: str

timestamps

Timestamp strings for this group’s series.

Type:: list[str]

running_values

Primary metric values (RUNNING state) per timestamp.

Type:: list[float]

waiting_values

Secondary metric values (WAITING state) per timestamp, 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

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: Resolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

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

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(*, status: ResultStatus = ResultStatus.OK, groups: list[GroupEntryDTO], resolution: Resolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

Grouped core load — one GroupEntryDTO per group.

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(*, status: ResultStatus = ResultStatus.OK, groups: list[CoresOccupancyGroupEntryDTO], resolution: Resolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

Grouped cores occupancy — one CoresOccupancyGroupEntryDTO per group.

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: Resolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

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

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(*, status: ResultStatus = ResultStatus.OK, groups: list[GroupEntryDTO], resolution: Resolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

Grouped GPU load — one GroupEntryDTO per group.

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(*, status: ResultStatus = ResultStatus.OK, groups: list[GroupEntryDTO], resolution: Resolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

Grouped job count load — one GroupEntryDTO per group.

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(*, status: ~applications.ait.enums.ResultStatus = ResultStatus.OK, 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). When status is not OK, data is empty.

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(*, status: ~applications.ait.enums.ResultStatus = ResultStatus.OK, 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. Each group contains a full month-by-month breakdown with per-state counts. When status is not OK, groups is empty.

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(*, status: ResultStatus = ResultStatus.OK, groups: list[NodesOccupancyGroupEntryDTO], resolution: Resolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

Grouped nodes occupancy — one NodesOccupancyGroupEntryDTO per group.

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: Resolution, grouping_key: str, grouping_size: Annotated[int, Ge(ge=1)])

Bases: BaseDTO

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

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, 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.

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.

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

InterArrivalDTO 

class applications.throughput.dto.job_freq.InterArrivalDTO(*, status: ~applications.ait.enums.ResultStatus = ResultStatus.OK, inter_arrival: dict = <factory>)

Bases: BaseDTO

Interarrival time statistics result.

Contains descriptive statistics of time intervals between consecutive job submissions.

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.

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.

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(*, status: ~applications.ait.enums.ResultStatus = ResultStatus.OK, 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.

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(*, status: ResultStatus = ResultStatus.OK, 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: Resolution)

Bases: BaseDTO

Job load timeseries with key statistics.

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

timestamps

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

Type:: list[str]

running_jobs

Jobs currently running at each timestamp.

Type:: list[int]

waiting_jobs

Jobs waiting to run at each timestamp.

Type:: list[int]

resolution

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

Type:: applications.ait.enums.Resolution

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.

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(*, status: ~applications.ait.enums.ResultStatus = ResultStatus.OK, 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. Each entry maps a state name to its aggregated metric value. When status is not OK, the data fields are empty (zero total, empty lists) and status explains why.

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(*, status: ~applications.ait.enums.ResultStatus = ResultStatus.OK, 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. Contains one YmsEntryDTO per month, ordered chronologically. When status is not OK, the data fields are empty.

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(*, status: ~applications.ait.enums.ResultStatus = ResultStatus.OK, 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.

status

Query outcome.

Type:: applications.ait.enums.ResultStatus

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].

NodesJobCountDTO 

class applications.load.dto.nodes_load.NodesJobCountDTO(*, status: ResultStatus = ResultStatus.OK, node_counts: dict[str, Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], nodes_per_line_display: int)

Bases: BaseDTO

Job count per node (snapshot, not timeseries).

node_counts

Mapping of node name to number of jobs touching that node.

Type:: dict[str, int]

nodes_per_line_display

UI display hint for grid layout (10–20 range).

Type:: int

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(*, status: ResultStatus = ResultStatus.OK, 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.

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.

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(*, status: ResultStatus = ResultStatus.OK, timestamps: list[str], power_values: list[Annotated[float, FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0)])]], resolution: Resolution)

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.Resolution

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].

SlowdownDistributionDTO 

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

Bases: BaseDTO

Slowdown PDF/CDF distribution result.

status

Query outcome.

Type:: applications.ait.enums.ResultStatus

slowdown

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

error: Error message when status is not OK.

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(*, status: ~applications.ait.enums.ResultStatus = ResultStatus.OK, description: dict = <factory>, datetime_col: ~applications.throughput.dto.common.SubmissionDatetimeCol = SubmissionDatetimeCol.SUBMIT)

Bases: BaseDTO

Slowdown descriptive statistics result.

status

Query outcome.

Type:: applications.ait.enums.ResultStatus

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

error: Error message when status is not OK.

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.

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, 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.

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(*, status: ~applications.ait.enums.ResultStatus = ResultStatus.OK, submit_hour: list = <factory>, submit_hour_count: list = <factory>)

Bases: BaseDTO

Hour-of-day submission histogram.

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(*, status: ~applications.ait.enums.ResultStatus = ResultStatus.OK, submit_weekday: list[str] = <factory>, submit_weekday_count: list = <factory>)

Bases: BaseDTO

Day-of-week submission histogram.

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(*, status: ResultStatus = ResultStatus.OK, wait_time: DataFrame | None = None, datetime_col: SubmissionDatetimeCol = SubmissionDatetimeCol.SUBMIT)

Bases: BaseDTO

Wait time PDF/CDF distribution result.

status

Query outcome.

Type:: applications.ait.enums.ResultStatus

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

error: Error message when status is not OK.

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(*, status: ~applications.ait.enums.ResultStatus = ResultStatus.OK, description: dict = <factory>, datetime_col: ~applications.throughput.dto.common.SubmissionDatetimeCol = SubmissionDatetimeCol.SUBMIT)

Bases: BaseDTO

Wait time descriptive statistics result.

status

Query outcome.

Type:: applications.ait.enums.ResultStatus

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

error: Error message when status is not OK.

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.

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.

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