Module valolyticspy.dtos.riot.match

Classes

class AbilityCastsDto (**data: Any)

Represents the ability casts data for a player in a match.

Attributes

grenadeCasts : int

The number of times the player has casted the grenade ability.

ability1Casts : int

The number of times the player has casted the first ability.

ability2Casts : int

The number of times the player has casted the second ability.

ultimateCasts : int

The number of times the player has casted the ultimate ability.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class AbilityCastsDto(BaseModel):
    """
    Represents the ability casts data for a player in a match.
    
    Attributes:
        grenadeCasts (int): The number of times the player has casted the grenade ability.
        ability1Casts (int): The number of times the player has casted the first ability.
        ability2Casts (int): The number of times the player has casted the second ability.
        ultimateCasts (int): The number of times the player has casted the ultimate ability.
    """
    grenadeCasts: int
    ability1Casts: int
    ability2Casts: int
    ultimateCasts: int

Ancestors

• pydantic.main.BaseModel

Subclasses

• AbilityCastsModel

Class variables

var ability1Casts : int

var ability2Casts : int

var grenadeCasts : int

var model_computed_fields

var model_config

var model_fields

var ultimateCasts : int

class AbilityDto (**data: Any)

Represents the abilities of a character in a match.

Attributes

grenadeEffects : Optional[str]

The effects of the grenade ability.

ability1Effects : Optional[str]

The effects of the first ability.

ability2Effects : Optional[str]

The effects of the second ability.

ultimateEffects : Optional[str]

The effects of the ultimate ability.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class AbilityDto(BaseModel):
    """
    Represents the abilities of a character in a match.

    Attributes:
        grenadeEffects (Optional[str]): The effects of the grenade ability.
        ability1Effects (Optional[str]): The effects of the first ability.
        ability2Effects (Optional[str]): The effects of the second ability.
        ultimateEffects (Optional[str]): The effects of the ultimate ability.
    """
    grenadeEffects: Optional[str] = None
    ability1Effects: Optional[str] = None
    ability2Effects: Optional[str] = None
    ultimateEffects: Optional[str] = None

Ancestors

• pydantic.main.BaseModel

Class variables

var ability1Effects : Optional[str]

var ability2Effects : Optional[str]

var grenadeEffects : Optional[str]

var model_computed_fields

var model_config

var model_fields

var ultimateEffects : Optional[str]

class CoachDto (**data: Any)

Represents a coach in a match.

Attributes

puuid : str

The unique identifier of the coach.

teamId : str

The unique identifier of the team the coach belongs to.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class CoachDto(BaseModel):
    """
    Represents a coach in a match.

    Attributes:
        puuid (str): The unique identifier of the coach.
        teamId (str): The unique identifier of the team the coach belongs to.
    """
    puuid: str
    teamId: str

Ancestors

• pydantic.main.BaseModel

Class variables

var model_computed_fields

var model_config

var model_fields

var puuid : str

var teamId : str

class DamageDto (**data: Any)

Represents the damage information for the damage from a player to a player.

Attributes

receiver : str

The puuid of the receiver.

damage : int

The amount of damage.

legshots : int

The amount of legshots.

bodyshots : int

The ramount of bodyshots.

headshots : int

The amount of headshots.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class DamageDto(BaseModel):
    """
    Represents the damage information for the damage from a player to a player.

    Attributes:
        receiver (str): The puuid of the receiver.
        damage (int): The amount of damage.
        legshots (int): The amount of legshots.
        bodyshots (int): The ramount of bodyshots.
        headshots (int): The amount of headshots.
    """
    receiver:str
    damage:int
    legshots:int
    bodyshots:int
    headshots:int

Ancestors

• pydantic.main.BaseModel

Subclasses

• DamageModel

Class variables

var bodyshots : int

var damage : int

var headshots : int

var legshots : int

var model_computed_fields

var model_config

var model_fields

var receiver : str

class EconomyDto (**data: Any)

Represents the economy information for a match.

Attributes

loadoutValue : int

The value of the loadout.

weapon : Optional[str]

The weapon used. Defaults to None.

armor : Optional[str]

The armor used. Defaults to None.

remaining : int

The remaining amount.

spent : int

The amount spent.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class EconomyDto(BaseModel):
    """
    Represents the economy information for a match.

    Attributes:
        loadoutValue (int): The value of the loadout.
        weapon (Optional[str]): The weapon used. Defaults to None.
        armor (Optional[str]): The armor used. Defaults to None.
        remaining (int): The remaining amount.
        spent (int): The amount spent.
    """
    loadoutValue: int
    weapon: Optional[str] = None
    armor: Optional[str] = None
    remaining: int
    spent: int

Ancestors

• pydantic.main.BaseModel

Subclasses

• EconomyModel

Class variables

var armor : Optional[str]

var loadoutValue : int

var model_computed_fields

var model_config

var model_fields

var remaining : int

var spent : int

var weapon : Optional[str]

class FinishingDamageDto (**data: Any)

Represents the finishing damage information for a match.

Attributes

damageType : str

The type of damage.

damageItem : Optional[str]

The item used to deal the damage (optional).

isSecondaryFireMode : bool

Indicates if the damage was dealt using the secondary fire mode.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class FinishingDamageDto(BaseModel):
    """
    Represents the finishing damage information for a match.
    
    Attributes:
        damageType (str): The type of damage.
        damageItem (Optional[str]): The item used to deal the damage (optional).
        isSecondaryFireMode (bool): Indicates if the damage was dealt using the secondary fire mode.
    """
    damageType: str
    damageItem: Optional[str] = None
    isSecondaryFireMode: bool

Ancestors

• pydantic.main.BaseModel

Subclasses

• FinishingDamageModel

Class variables

var damageItem : Optional[str]

var damageType : str

var isSecondaryFireMode : bool

var model_computed_fields

var model_config

var model_fields

class KillDto (**data: Any)

Represents a kill event in a game.

Attributes

timeSinceGameStartMillis : int

The time in milliseconds since the start of the game.

timeSinceRoundStartMillis : int

The time in milliseconds since the start of the round.

killer : str

The name of the player who made the kill.

victim : str

The name of the player who was killed.

victimLocation : LocationDto

The location of the victim at the time of the kill.

assistants : List[str]

A list of names of players who assisted in the kill.

playerLocations : List[PlayerLocationsDto]

A list of player locations at the time of the kill.

finishingDamage : FinishingDamageDto

The finishing damage information for the kill.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class KillDto(BaseModel):
    """
    Represents a kill event in a game.
    
    Attributes:
        timeSinceGameStartMillis (int): The time in milliseconds since the start of the game.
        timeSinceRoundStartMillis (int): The time in milliseconds since the start of the round.
        killer (str): The name of the player who made the kill.
        victim (str): The name of the player who was killed.
        victimLocation (LocationDto): The location of the victim at the time of the kill.
        assistants (List[str]): A list of names of players who assisted in the kill.
        playerLocations (List[PlayerLocationsDto]): A list of player locations at the time of the kill.
        finishingDamage (FinishingDamageDto): The finishing damage information for the kill.
    """
    timeSinceGameStartMillis: int
    timeSinceRoundStartMillis: int
    killer: str
    victim: str
    victimLocation: LocationDto
    assistants: List[str]
    playerLocations: List[PlayerLocationsDto]
    finishingDamage: FinishingDamageDto

Ancestors

• pydantic.main.BaseModel

Subclasses

• KillModel

Class variables

var assistants : List[str]

var finishingDamage : FinishingDamageDto

var killer : str

var model_computed_fields

var model_config

var model_fields

var playerLocations : List[PlayerLocationsDto]

var timeSinceGameStartMillis : int

var timeSinceRoundStartMillis : int

var victim : str

var victimLocation : LocationDto

class LocationDto (**data: Any)

Represents the location data for a specific object.

Attributes

x : int

The x-coordinate of the location.

y : int

The y-coordinate of the location.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class LocationDto(BaseModel):
    """
    Represents the location data for a specific object.
    
    Attributes:
        x (int): The x-coordinate of the location.
        y (int): The y-coordinate of the location.
    """
    x: int
    y: int

Ancestors

• pydantic.main.BaseModel

Class variables

var model_computed_fields

var model_config

var model_fields

var x : int

var y : int

class MatchDto (**data: Any)

Represents a match in the game.

Attributes

matchInfo : MatchInfoDto

Information about the match.

players : List[PlayerDto]

List of players in the match.

coaches : List[CoachDto]

List of coaches in the match.

teams : List[TeamDto]

List of teams in the match.

roundResults : List[RoundResultDto]

List of round results in the match.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class MatchDto(BaseModel):
    """
    Represents a match in the game.
    
    Attributes:
        matchInfo (MatchInfoDto): Information about the match.
        players (List[PlayerDto]): List of players in the match.
        coaches (List[CoachDto]): List of coaches in the match.
        teams (List[TeamDto]): List of teams in the match.
        roundResults (List[RoundResultDto]): List of round results in the match.
    """
    matchInfo: MatchInfoDto
    players: List[PlayerDto]
    coaches: List[CoachDto]
    teams: List[TeamDto]
    roundResults: List[RoundResultDto]

Ancestors

• pydantic.main.BaseModel

Subclasses

• MatchModel

Class variables

var coaches : List[CoachDto]

var matchInfo : MatchInfoDto

var model_computed_fields

var model_config

var model_fields

var players : List[PlayerDto]

var roundResults : List[RoundResultDto]

var teams : List[TeamDto]

class MatchInfoDto (**data: Any)

Represents the information of a match.

Attributes

matchId : str

The ID of the match.

mapId : str

The ID of the map.

gameLengthMillis : int

The length of the game in milliseconds.

gameStartMillis : int

The start time of the game in milliseconds.

provisioningFlowId : str

The ID of the provisioning flow.

isCompleted : bool

Indicates if the match is completed.

customGameName : str

The name of the custom game.

queueId : str

The ID of the queue.

gameMode : str

The game mode.

isRanked : bool

Indicates if the match is ranked.

seasonId : str

The ID of the season.

premierMatchInfo : Optional[PremierMatchInfoDto]

Additional information about the premier match.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class MatchInfoDto(BaseModel):
    """
    Represents the information of a match.

    Attributes:
        matchId (str): The ID of the match.
        mapId (str): The ID of the map.
        gameLengthMillis (int): The length of the game in milliseconds.
        gameStartMillis (int): The start time of the game in milliseconds.
        provisioningFlowId (str): The ID of the provisioning flow.
        isCompleted (bool): Indicates if the match is completed.
        customGameName (str): The name of the custom game.
        queueId (str): The ID of the queue.
        gameMode (str): The game mode.
        isRanked (bool): Indicates if the match is ranked.
        seasonId (str): The ID of the season.
        premierMatchInfo (Optional[PremierMatchInfoDto]): Additional information about the premier match.
    """
    matchId:str
    mapId:str
    gameLengthMillis:int
    gameStartMillis:int
    provisioningFlowId:str
    isCompleted:bool
    customGameName:str
    queueId:str
    gameMode:str
    isRanked:bool
    seasonId:str
    premierMatchInfo:Optional[PremierMatchInfoDto] = None

Ancestors

• pydantic.main.BaseModel

Subclasses

• MatchInfoModel

Class variables

var customGameName : str

var gameLengthMillis : int

var gameMode : str

var gameStartMillis : int

var isCompleted : bool

var isRanked : bool

var mapId : str

var matchId : str

var model_computed_fields

var model_config

var model_fields

var premierMatchInfo : Optional[PremierMatchInfoDto]

var provisioningFlowId : str

var queueId : str

var seasonId : str

class PlayerDto (**data: Any)

Represents a player in a match.

Attributes

puuid : str

The unique identifier for the player.

gameName : str

The in-game name of the player.

tagLine : str

The tagline associated with the player's game name.

teamId : str

The identifier of the team the player belongs to.

partyId : str

The identifier of the party the player belongs to.

characterId : str, optional

The identifier of the character selected by the player. Defaults to None.

stats : PlayerStatsDto, optional

The statistics of the player in the match. Defaults to None.

competitiveTier : int

The competitive tier of the player.

playerCard : str

The player's selected card.

playerTitle : str

The player's selected title.

accountLevel : int, optional

The level of the player's account. Defaults to None.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class PlayerDto(BaseModel):
    """
    Represents a player in a match.

    Attributes:
        puuid (str): The unique identifier for the player.
        gameName (str): The in-game name of the player.
        tagLine (str): The tagline associated with the player's game name.
        teamId (str): The identifier of the team the player belongs to.
        partyId (str): The identifier of the party the player belongs to.
        characterId (str, optional): The identifier of the character selected by the player. Defaults to None.
        stats (PlayerStatsDto, optional): The statistics of the player in the match. Defaults to None.
        competitiveTier (int): The competitive tier of the player.
        playerCard (str): The player's selected card.
        playerTitle (str): The player's selected title.
        accountLevel (int, optional): The level of the player's account. Defaults to None.
    """
    puuid: str
    gameName: str
    tagLine: str
    teamId: str
    partyId: str
    characterId: Optional[str] = None
    stats: Optional[PlayerStatsDto] = None
    competitiveTier: int
    playerCard: str
    playerTitle: str
    accountLevel: Optional[int] = None

Ancestors

• pydantic.main.BaseModel

Subclasses

• PlayerModel

Class variables

var accountLevel : Optional[int]

var characterId : Optional[str]

var competitiveTier : int

var gameName : str

var model_computed_fields

var model_config

var model_fields

var partyId : str

var playerCard : str

var playerTitle : str

var puuid : str

var stats : Optional[PlayerStatsDto]

var tagLine : str

var teamId : str

class PlayerLocationsDto (**data: Any)

Represents the player locations data transfer object.

Attributes

puuid : str

The unique identifier for the player.

viewRadians : float

The view radians of the player.

location : LocationDto

The location of the player.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class PlayerLocationsDto(BaseModel):
    """
    Represents the player locations data transfer object.
    
    Attributes:
        puuid (str): The unique identifier for the player.
        viewRadians (float): The view radians of the player.
        location (LocationDto): The location of the player.
    """
    puuid: str
    viewRadians: float
    location: LocationDto

Ancestors

• pydantic.main.BaseModel

Class variables

var location : LocationDto

var model_computed_fields

var model_config

var model_fields

var puuid : str

var viewRadians : float

class PlayerRoundStatsDto (**data: Any)

Represents the statistics of a player in a round.

Attributes

puuid : str

The unique identifier of the player.

kills : List[KillDto]

The list of kills made by the player.

damage : List[DamageDto]

The list of damage dealt by the player.

score : int

The score earned by the player in the round.

economy : EconomyDto

The economy statistics of the player.

ability : AbilityDto

The ability usage statistics of the player.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class PlayerRoundStatsDto(BaseModel):
    """
    Represents the statistics of a player in a round.

    Attributes:
        puuid (str): The unique identifier of the player.
        kills (List[KillDto]): The list of kills made by the player.
        damage (List[DamageDto]): The list of damage dealt by the player.
        score (int): The score earned by the player in the round.
        economy (EconomyDto): The economy statistics of the player.
        ability (AbilityDto): The ability usage statistics of the player.
    """
    puuid: str
    kills: List[KillDto]
    damage: List[DamageDto]
    score: int
    economy: EconomyDto
    ability: AbilityDto

Ancestors

• pydantic.main.BaseModel

Subclasses

• PlayerRoundStatsModel

Class variables

var ability : AbilityDto

var damage : List[DamageDto]

var economy : EconomyDto

var kills : List[KillDto]

var model_computed_fields

var model_config

var model_fields

var puuid : str

var score : int

class PlayerStatsDto (**data: Any)

Represents the statistics of a player in a match.

Attributes

score : int

The player's score in the match.

roundsPlayed : int

The number of rounds played by the player.

kills : int

The number of kills made by the player.

deaths : int

The number of deaths of the player.

assists : int

The number of assists made by the player.

playtimeMillis : int

The total playtime of the player in milliseconds.

abilityCasts : Optional[AbilityCastsDto]

The ability casts of the player (optional).

vlrRating : Optional[float]

The VLR rating of the player (optional).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class PlayerStatsDto(BaseModel):
    """
    Represents the statistics of a player in a match.
    
    Attributes:
        score (int): The player's score in the match.
        roundsPlayed (int): The number of rounds played by the player.
        kills (int): The number of kills made by the player.
        deaths (int): The number of deaths of the player.
        assists (int): The number of assists made by the player.
        playtimeMillis (int): The total playtime of the player in milliseconds.
        abilityCasts (Optional[AbilityCastsDto]): The ability casts of the player (optional).
        vlrRating (Optional[float]): The VLR rating of the player (optional).
    """
    score: int
    roundsPlayed: int
    kills: int
    deaths: int
    assists: int
    playtimeMillis: int
    abilityCasts: Optional[AbilityCastsDto] = None
    vlrRating: Optional[float] = None

Ancestors

• pydantic.main.BaseModel

Class variables

var abilityCasts : Optional[AbilityCastsDto]

var assists : int

var deaths : int

var kills : int

var model_computed_fields

var model_config

var model_fields

var playtimeMillis : int

var roundsPlayed : int

var score : int

var vlrRating : Optional[float]

class PremierMatchInfoDto (**data: Any)

Represents the premier match information.

Attributes

premierSeasonId : Optional[str]

The ID of the premier season.

premierEventId : Optional[str]

The ID of the premier event.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class PremierMatchInfoDto(BaseModel):
    """
    Represents the premier match information.

    Attributes:
        premierSeasonId (Optional[str]): The ID of the premier season.
        premierEventId (Optional[str]): The ID of the premier event.
    """
    premierSeasonId: Optional[str] = None
    premierEventId: Optional[str] = None

Ancestors

• pydantic.main.BaseModel

Class variables

var model_computed_fields

var model_config

var model_fields

var premierEventId : Optional[str]

var premierSeasonId : Optional[str]

class RoundResultDto (**data: Any)

Represents the result of a round in a match.

Attributes

roundNum : int

The number of the round.

roundResult : str

The result of the round.

roundCeremony : str

The ceremony associated with the round.

winningTeam : str

The team that won the round.

bombPlanter : Optional[str]

The player who planted the bomb (if applicable).

bombDefuser : Optional[str]

The player who defused the bomb (if applicable).

plantRoundTime : Optional[int]

The time at which the bomb was planted (if applicable).

plantPlayerLocations : Optional[List[PlayerLocationsDto]]

The locations of the players when the bomb was planted (if applicable).

plantLocation : Optional[LocationDto]

The location where the bomb was planted (if applicable).

plantSite : Optional[str]

The site where the bomb was planted (if applicable).

defuseRoundTime : Optional[int]

The time at which the bomb was defused (if applicable).

defusePlayerLocations : Optional[List[PlayerLocationsDto]]

The locations of the players when the bomb was defused (if applicable).

defuseLocation : Optional[LocationDto]

The location where the bomb was defused (if applicable).

playerStats : List[PlayerRoundStatsDto]

The statistics of the players in the round.

roundResultCode : str

The code representing the result of the round.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class RoundResultDto(BaseModel):
    """
    Represents the result of a round in a match.

    Attributes:
        roundNum (int): The number of the round.
        roundResult (str): The result of the round.
        roundCeremony (str): The ceremony associated with the round.
        winningTeam (str): The team that won the round.
        bombPlanter (Optional[str]): The player who planted the bomb (if applicable).
        bombDefuser (Optional[str]): The player who defused the bomb (if applicable).
        plantRoundTime (Optional[int]): The time at which the bomb was planted (if applicable).
        plantPlayerLocations (Optional[List[PlayerLocationsDto]]): The locations of the players when the bomb was planted (if applicable).
        plantLocation (Optional[LocationDto]): The location where the bomb was planted (if applicable).
        plantSite (Optional[str]): The site where the bomb was planted (if applicable).
        defuseRoundTime (Optional[int]): The time at which the bomb was defused (if applicable).
        defusePlayerLocations (Optional[List[PlayerLocationsDto]]): The locations of the players when the bomb was defused (if applicable).
        defuseLocation (Optional[LocationDto]): The location where the bomb was defused (if applicable).
        playerStats (List[PlayerRoundStatsDto]): The statistics of the players in the round.
        roundResultCode (str): The code representing the result of the round.
    """
    roundNum: int
    roundResult: str
    roundCeremony: str
    winningTeam: str
    bombPlanter:Optional[str] = None
    bombDefuser:Optional[str] = None
    plantRoundTime: Optional[int] = None
    plantPlayerLocations: Optional[List[PlayerLocationsDto]] = None
    plantLocation: Optional[LocationDto] = None
    plantSite: Optional[str] = None
    defuseRoundTime: Optional[int] = None
    defusePlayerLocations: Optional[List[PlayerLocationsDto]] = None
    defuseLocation: Optional[LocationDto] = None
    playerStats: List[PlayerRoundStatsDto]
    roundResultCode: str

Ancestors

• pydantic.main.BaseModel

Subclasses

• RoundResultModel

Class variables

var bombDefuser : Optional[str]

var bombPlanter : Optional[str]

var defuseLocation : Optional[LocationDto]

var defusePlayerLocations : Optional[List[PlayerLocationsDto]]

var defuseRoundTime : Optional[int]

var model_computed_fields

var model_config

var model_fields

var plantLocation : Optional[LocationDto]

var plantPlayerLocations : Optional[List[PlayerLocationsDto]]

var plantRoundTime : Optional[int]

var plantSite : Optional[str]

var playerStats : List[PlayerRoundStatsDto]

var roundCeremony : str

var roundNum : int

var roundResult : str

var roundResultCode : str

var winningTeam : str

class TeamDto (**data: Any)

Represents a team in a match.

Attributes

teamId : str

The ID of the team.

won : bool

Indicates whether the team won the match.

roundsPlayed : int

The number of rounds played by the team.

roundsWon : int

The number of rounds won by the team.

numPoints : int

The number of points earned by the team.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Expand source code

class TeamDto(BaseModel):
    """
    Represents a team in a match.

    Attributes:
        teamId (str): The ID of the team.
        won (bool): Indicates whether the team won the match.
        roundsPlayed (int): The number of rounds played by the team.
        roundsWon (int): The number of rounds won by the team.
        numPoints (int): The number of points earned by the team.
    """
    teamId: str
    won: bool
    roundsPlayed: int
    roundsWon: int
    numPoints: int

Ancestors

• pydantic.main.BaseModel

Subclasses

• TeamModel

Class variables

var model_computed_fields

var model_config

var model_fields

var numPoints : int

var roundsPlayed : int

var roundsWon : int

var teamId : str

var won : bool