valo_api_official.responses package

Submodules

valo_api_official.responses.account module

Classes:

AccountV1(puuid, gameName, tagLine)

class AccountV1(puuid: str, gameName: str, tagLine: str)

Bases: Struct

Attributes:

`puuid`
`gameName`
`tagLine`

puuid: str

gameName: str

tagLine: str

valo_api_official.responses.active_shards module

Classes:

ActiveShardsV1(puuid, game, activeShard)

class ActiveShardsV1(puuid: str, game: str, activeShard: str)

Bases: Struct

Attributes:

`puuid`
`game`
`activeShard`

puuid: str

game: str

activeShard: str

valo_api_official.responses.content module

Classes:

`Entity`(name, id, assetName[, assetPath, ...])
`Act`(id, parentId, type, name, isActive[, ...])
`ContentV1`(version, characters, maps, ...)

class Entity(name: str, id: str, assetName: str, assetPath: str | None = None, localizedNames: Dict[str, str] | None = None)

Bases: Struct

Attributes:

`name`
`id`
`assetName`
`assetPath`
`localizedNames`

name: str

id: str

assetName: str

assetPath: Optional[str]

localizedNames: Optional[Dict[str, str]]

class Act(id: str, parentId: str, type: str, name: str, isActive: bool, localizedNames: Dict[str, str] | None = None)

Bases: Struct

Attributes:

`id`
`parentId`
`type`
`name`
`isActive`
`localizedNames`

id: str

parentId: str

type: str

name: str

isActive: bool

localizedNames: Optional[Dict[str, str]]

class ContentV1(version: str, characters: List[Entity], maps: List[Entity], chromas: List[Entity], skins: List[Entity], skinLevels: List[Entity], equips: List[Entity], gameModes: List[Entity], sprays: List[Entity], sprayLevels: List[Entity], charms: List[Entity], charmLevels: List[Entity], playerCards: List[Entity], playerTitles: List[Entity], acts: List[Act], ceremonies: List[Entity])

Bases: Struct

Attributes:

`version`
`characters`
`maps`
`chromas`
`skins`
`skinLevels`
`equips`
`gameModes`
`sprays`
`sprayLevels`
`charms`
`charmLevels`
`playerCards`
`playerTitles`
`acts`
`ceremonies`

version: str

characters: List[Entity]

maps: List[Entity]

chromas: List[Entity]

skins: List[Entity]

skinLevels: List[Entity]

equips: List[Entity]

gameModes: List[Entity]

sprays: List[Entity]

sprayLevels: List[Entity]

charms: List[Entity]

charmLevels: List[Entity]

playerCards: List[Entity]

playerTitles: List[Entity]

acts: List[Act]

ceremonies: List[Entity]

valo_api_official.responses.error_response module

Classes:

`Error`([message, status_code])
`ErrorResponse`([headers, error])

class Error(message: str | None = None, status_code: int | None = None)

Bases: Struct

Attributes:

`message`
`status_code`

message: Optional[str]

status_code: Optional[int]

class ErrorResponse(headers: dict | None = None, error: Error | None = None)

Bases: Struct

Attributes:

`headers`
`error`

headers: Optional[dict]

error: Optional[Error]

valo_api_official.responses.leaderboard module

Classes:

`LeaderboardPlayerV1`(leaderboardRank, ...[, ...])
`TierDetail`(rankedRatingThreshold, ...)
`LeaderboardV1`(actId, players, totalPlayers, ...)

class LeaderboardPlayerV1(leaderboardRank: int, rankedRating: int, numberOfWins: int, competitiveTier: int, puuid: str | None = None, gameName: str | None = None, tagLine: str | None = None)

Bases: Struct

Attributes:

`leaderboardRank`
`rankedRating`
`numberOfWins`
`competitiveTier`
`puuid`
`gameName`
`tagLine`

leaderboardRank: int

rankedRating: int

numberOfWins: int

competitiveTier: int

puuid: Optional[str]

gameName: Optional[str]

tagLine: Optional[str]

class TierDetail(rankedRatingThreshold: int, startingPage: int, startingIndex: int)

Bases: Struct

Attributes:

`rankedRatingThreshold`
`startingPage`
`startingIndex`

rankedRatingThreshold: int

startingPage: int

startingIndex: int

class LeaderboardV1(actId: str, players: List[LeaderboardPlayerV1], totalPlayers: int, immortalStartingPage: int, immortalStartingIndex: int, topTierRRThreshold: int, tierDetails: Dict[int, TierDetail], startIndex: int, query: str, shard: str)

Bases: Struct

Attributes:

`actId`
`players`
`totalPlayers`
`immortalStartingPage`
`immortalStartingIndex`
`topTierRRThreshold`
`tierDetails`
`startIndex`
`query`
`shard`

actId: str

players: List[LeaderboardPlayerV1]

totalPlayers: int

immortalStartingPage: int

immortalStartingIndex: int

topTierRRThreshold: int

tierDetails: Dict[int, TierDetail]

startIndex: int

query: str

shard: str

valo_api_official.responses.match_details module

Classes:

`MatchInfo`(matchId, mapId, gameVersion, ...)
`PlayerAbilityCasts`(grenadeCasts, ...)
`PlayerStats`(score, roundsPlayed, kills, ...)
`MatchPlayers`(puuid, gameName, tagLine, ...)
`MatchTeam`(teamId, won, roundsPlayed, ...)
`Location`(x, y)
`PlayerLocations`(puuid, viewRadians, location)
`KillFinishingDamage`(damageType, damageItem, ...)
`PlayerKills`(timeSinceGameStartMillis, ...)
`PlayerDamage`(receiver, damage, legshots, ...)
`PlayerEconomy`(loadoutValue, weapon, armor, ...)
`PlayerAbilityEffects`(grenadeEffects, ...)
`RoundPlayerStats`(puuid, kills, damage, ...)
`MatchRoundResults`(roundNum, roundResult, ...)
`MatchDetailsV1`(matchInfo, players, coaches, ...)

class MatchInfo(matchId: str, mapId: str, gameVersion: str, gameStartMillis: int, isCompleted: bool, customGameName: str, gameMode: str, isRanked: bool, seasonId: str, queueId: str | None = None, provisioningFlowID: str | None = None, gameLengthMillis: int | None = None)

Bases: Struct

Attributes:

`matchId`
`mapId`
`gameVersion`
`gameStartMillis`
`isCompleted`
`customGameName`
`gameMode`
`isRanked`
`seasonId`
`queueId`
`provisioningFlowID`
`gameLengthMillis`

matchId: str

mapId: str

gameVersion: str

gameStartMillis: int

isCompleted: bool

customGameName: str

gameMode: str

isRanked: bool

seasonId: str

queueId: Optional[str]

provisioningFlowID: Optional[str]

gameLengthMillis: Optional[int]

class PlayerAbilityCasts(grenadeCasts: int, ability1Casts: int, ability2Casts: int, ultimateCasts: int)

Bases: Struct

Attributes:

`grenadeCasts`
`ability1Casts`
`ability2Casts`
`ultimateCasts`

grenadeCasts: int

ability1Casts: int

ability2Casts: int

ultimateCasts: int

class PlayerStats(score: int, roundsPlayed: int, kills: int, deaths: int, assists: int, playtimeMillis: int, abilityCasts: PlayerAbilityCasts | None = None)

Bases: Struct

Attributes:

`score`
`roundsPlayed`
`kills`
`deaths`
`assists`
`playtimeMillis`
`abilityCasts`

score: int

roundsPlayed: int

kills: int

deaths: int

assists: int

playtimeMillis: int

abilityCasts: Optional[PlayerAbilityCasts]

class MatchPlayers(puuid: str, gameName: str, tagLine: str, teamId: str, partyId: str, competitiveTier: int, playerCard: str, playerTitle: str, isObserver: bool | None = None, characterId: str | None = None, stats: PlayerStats | None = None)

Bases: Struct

Attributes:

`puuid`
`gameName`
`tagLine`
`teamId`
`partyId`
`competitiveTier`
`playerCard`
`playerTitle`
`isObserver`
`characterId`
`stats`

puuid: str

gameName: str

tagLine: str

teamId: str

partyId: str

competitiveTier: int

playerCard: str

playerTitle: str

isObserver: Optional[bool]

characterId: Optional[str]

stats: Optional[PlayerStats]

class MatchTeam(teamId: str, won: bool, roundsPlayed: int, roundsWon: int, numPoints: int)

Bases: Struct

Attributes:

`teamId`
`won`
`roundsPlayed`
`roundsWon`
`numPoints`

teamId: str

won: bool

roundsPlayed: int

roundsWon: int

numPoints: int

class Location(x: int, y: int)

Bases: Struct

Attributes:

`x`
`y`

x: int

y: int

class PlayerLocations(puuid: str, viewRadians: float, location: Location)

Bases: Struct

Attributes:

`puuid`
`viewRadians`
`location`

puuid: str

viewRadians: float

location: Location

class KillFinishingDamage(damageType: str, damageItem: str, isSecondaryFireMode: bool)

Bases: Struct

Attributes:

`damageType`
`damageItem`
`isSecondaryFireMode`

damageType: str

damageItem: str

isSecondaryFireMode: bool

class PlayerKills(timeSinceGameStartMillis: int, timeSinceRoundStartMillis: int, killer: str, victim: str, victimLocation: Location, assistants: List[str], playerLocations: List[PlayerLocations], finishingDamage: KillFinishingDamage)

Bases: Struct

Attributes:

`timeSinceGameStartMillis`
`timeSinceRoundStartMillis`
`killer`
`victim`
`victimLocation`
`assistants`
`playerLocations`
`finishingDamage`

timeSinceGameStartMillis: int

timeSinceRoundStartMillis: int

killer: str

victim: str

victimLocation: Location

assistants: List[str]

playerLocations: List[PlayerLocations]

finishingDamage: KillFinishingDamage

class PlayerDamage(receiver: str, damage: int, legshots: int, bodyshots: int, headshots: int)

Bases: Struct

Attributes:

`receiver`
`damage`
`legshots`
`bodyshots`
`headshots`

receiver: str

damage: int

legshots: int

bodyshots: int

headshots: int

class PlayerEconomy(loadoutValue: int, weapon: str, armor: str, remaining: int, spent: int)

Bases: Struct

Attributes:

`loadoutValue`
`weapon`
`armor`
`remaining`
`spent`

loadoutValue: int

weapon: str

armor: str

remaining: int

spent: int

class PlayerAbilityEffects(grenadeEffects: dict | None, ability1Effects: dict | None, ability2Effects: dict | None, ultimateEffects: dict | None)

Bases: Struct

Attributes:

`grenadeEffects`
`ability1Effects`
`ability2Effects`
`ultimateEffects`

grenadeEffects: Optional[dict]

ability1Effects: Optional[dict]

ability2Effects: Optional[dict]

ultimateEffects: Optional[dict]

class RoundPlayerStats(puuid: str, kills: List[PlayerKills], damage: List[PlayerDamage], score: int, economy: PlayerEconomy, ability: PlayerAbilityEffects)

Bases: Struct

Attributes:

`puuid`
`kills`
`damage`
`score`
`economy`
`ability`

puuid: str

kills: List[PlayerKills]

damage: List[PlayerDamage]

score: int

economy: PlayerEconomy

ability: PlayerAbilityEffects

class MatchRoundResults(roundNum: int, roundResult: str, roundCeremony: str, winningTeam: str, plantRoundTime: int, plantLocation: Location, plantSite: str, defuseRoundTime: int, defuseLocation: Location, playerStats: List[RoundPlayerStats], roundResultCode: str, bombPlanter: str | None = None, bombDefuser: str | None = None, plantPlayerLocations: List[PlayerLocations] | None = None, defusePlayerLocations: List[PlayerLocations] | None = None)

Bases: Struct

Attributes:

`roundNum`
`roundResult`
`roundCeremony`
`winningTeam`
`plantRoundTime`
`plantLocation`
`plantSite`
`defuseRoundTime`
`defuseLocation`
`playerStats`
`roundResultCode`
`bombPlanter`
`bombDefuser`
`plantPlayerLocations`
`defusePlayerLocations`

roundNum: int

roundResult: str

roundCeremony: str

winningTeam: str

plantRoundTime: int

plantLocation: Location

plantSite: str

defuseRoundTime: int

defuseLocation: Location

playerStats: List[RoundPlayerStats]

roundResultCode: str

bombPlanter: Optional[str]

bombDefuser: Optional[str]

plantPlayerLocations: Optional[List[PlayerLocations]]

defusePlayerLocations: Optional[List[PlayerLocations]]

class MatchDetailsV1(matchInfo: MatchInfo, players: List[MatchPlayers], coaches: List[dict], teams: List[MatchTeam], roundResults: List[MatchRoundResults] | None)

Bases: Struct

Attributes:

`matchInfo`
`players`
`coaches`
`teams`
`roundResults`

matchInfo: MatchInfo

players: List[MatchPlayers]

coaches: List[dict]

teams: List[MatchTeam]

roundResults: Optional[List[MatchRoundResults]]

valo_api_official.responses.match_history module

Classes:

`MatchRaw`(matchId, gameStartTimeMillis, queueId)
`MatchHistoryV1`(puuid, history)

class MatchRaw(matchId: str, gameStartTimeMillis: int, queueId: str)

Bases: Struct

Attributes:

`matchId`
`gameStartTimeMillis`
`queueId`

matchId: str

gameStartTimeMillis: int

queueId: str

class MatchHistoryV1(puuid: str, history: List[MatchRaw])

Bases: Struct

Attributes:

`puuid`
`history`

puuid: str

history: List[MatchRaw]

valo_api_official.responses.recent_matches module

Classes:

RecentMatchesV1(currentTime, matchIds)

class RecentMatchesV1(currentTime: int, matchIds: List[str])

Bases: Struct

Attributes:

`currentTime`
`matchIds`

currentTime: int

matchIds: List[str]

valo_api_official.responses.status module

Classes:

`MaintenanceStatusTitleV1`(locale, content)
`MaintenanceUpdateV1`(publish_locations, ...)
`MaintenancePointV1`(updated_at, created_at, ...)
`StatusV1`(id, name, locales, maintenances, ...)

class MaintenanceStatusTitleV1(locale: str, content: str)

Bases: Struct

Attributes:

`locale`
`content`

locale: str

content: str

class MaintenanceUpdateV1(publish_locations: List[str], updated_at: str, created_at: str, id: int, publish: bool, translations: List[MaintenanceStatusTitleV1], author: str | None = None)

Bases: Struct

Attributes:

`publish_locations`
`updated_at`
`created_at`
`id`
`publish`
`translations`
`author`

publish_locations: List[str]

updated_at: str

created_at: str

id: int

publish: bool

translations: List[MaintenanceStatusTitleV1]

author: Optional[str]

class MaintenancePointV1(updated_at: str | None, created_at: str | None, archive_at: str | None, titles: List[MaintenanceStatusTitleV1], maintenance_status: str, id: int, incident_severity: str | None, updates: List[MaintenanceUpdateV1], platforms: List[str])

Bases: Struct

Attributes:

`updated_at`
`created_at`
`archive_at`
`titles`
`maintenance_status`
`id`
`incident_severity`
`updates`
`platforms`

updated_at: Optional[str]

created_at: Optional[str]

archive_at: Optional[str]

titles: List[MaintenanceStatusTitleV1]

maintenance_status: str

id: int

incident_severity: Optional[str]

updates: List[MaintenanceUpdateV1]

platforms: List[str]

class StatusV1(id: str, name: str, locales: List[str], maintenances: List[MaintenancePointV1], incidents: List[MaintenancePointV1])

Bases: Struct

Attributes:

`id`
`name`
`locales`
`maintenances`
`incidents`

id: str

name: str

locales: List[str]

maintenances: List[MaintenancePointV1]

incidents: List[MaintenancePointV1]

valo_api_official.responses package

Submodules

valo_api_official.responses.account module

valo_api_official.responses.active_shards module

valo_api_official.responses.content module

valo_api_official.responses.error_response module

valo_api_official.responses.leaderboard module

valo_api_official.responses.match_details module

valo_api_official.responses.match_history module

valo_api_official.responses.recent_matches module

valo_api_official.responses.status module

Module contents