async_faceit_api package

Submodules

async_faceit_api.api module

class async_faceit_api.api.FaceitAPI(api_token: str, rate_limit_behaviour: RateLimitBehaviour = RateLimitBehaviour.WAIT_SOME_SEC)

Bases: object

See the faceit data-api docs for more information: https://developers.faceit.com/docs/tools/data-api

async championship(championship_id: str, expanded: Expansion = Expansion.NONE) → Championship

Retrieve championship details

Parameters:

• championship_id (str) – The id of the championship

• expanded (Expansion, optional) – List of entity names to expand in request

Returns:

Championship details

Return type:

:class:.Championship`

async championship_matches(championship_id: str, type_: MatchType = MatchType.ALL, offset: int = 0, limit: int = 20) → Collection[Match]

Retrieve all matches of a championship

Parameters:

• championship_id (str) – The id of the championship

• type (MatchType, optional) – Kind of matches to return. Can be all(default), upcoming, ongoing or past

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Matches list

Return type:

Collection[.Match]

async championship_results(championship_id: str, offset: int = 0, limit: int = 20) → Collection[Result]

Retrieve all results of a championship

Parameters:

• championship_id (str) – The id of the championship

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Championship results

Return type:

Collection[.Result]

async championship_subscriptions(championship_id: str, offset: int = 0, limit: int = 10) → Collection[Subscription]

Retrieve all subscriptions of a championship

Parameters:

• championship_id (str) – The id of the championship

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Subscriptions list

Return type:

Collection[.Subscription]

async championships(game: Game, type_: MatchType = MatchType.ALL, offset: int = 0, limit: int = 10) → Collection[Championship]

Retrieve all championships of a game

Parameters:

• game (Game) – The id of the game

• type (MatchType, optional) – Kind of matches to return. Can be all(default), upcoming, ongoing or past

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Championships collection

Return type:

Collection[.Championship]

async game_details(game: Game) → GameData

Retrieve game details

Parameters:

game (Game) – The id of the game

Returns:

Game detail

Return type:

GameData

async game_parent_details(game: Game) → GameData

Retrieve the details of the parent game, if the game is region-specific

Parameters:

game (Game) – The id of the game

Returns:

Game detail

Return type:

GameData

async games(offset: int = 0, limit: int = 20) → Collection[GameData]

Retrieve details of all games on FACEIT

Parameters:

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Games list

Return type:

Collection[.GameData]

async hub(hub_id: str, expanded: Expansion = Expansion.NONE) → Hub

Retrieve hub details

Parameters:

• hub_id (str) – The id of the hub

• expanded (Expansion) – List of entity names to expand in request

Returns:

Hub details

Return type:

Hub

async hub_matches(hub_id: str, type_: MatchType = MatchType.ALL, offset: int = 0, limit: int = 20) → Collection[Match]

Retrieve all matches of a hub

Parameters:

• hub_id (str) – The id of the hub

• type (MatchType, optional) – Kind of matches to return. Can be all(default), upcoming, ongoing or past

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Matches list

Return type:

Collection[.Match]

async hub_members(hub_id: str, offset: int = 0, limit: int = 20) → Collection[Member]

Retrieve all members of a hub

Parameters:

• hub_id (str) – The id of the hub

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Members list

Return type:

Collection[.Member]

async hub_roles(hub_id: str, offset: int = 0, limit: int = 20) → Collection[Role]

Retrieve all roles members can have in a hub

Parameters:

• hub_id (str) – The id of the hub

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Roles list

Return type:

Collection[.Role]

async hub_rules(hub_id: str) → Rule

Retrieve rules of a hub

Parameters:

hub_id (str) – The id of the hub

Returns:

Rules details

Return type:

Rule

async hub_stats(hub_id: str, offset: int = 0, limit: int = 20) → GameStats

Retrieve statistics of a hub

Parameters:

• hub_id (str) – The id of the hub

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Hub stats

Return type:

GameStats

async leaderboard(leaderboard_id: str, offset: int = 0, limit: int = 20) → ChampionshipRankingCollection[Ranking]

Retrieve ranking from a leaderboard id

Parameters:

• leaderboard_id (str) – The id of the leaderboard

• season (int) – A season of the hub

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Leaderboards list

Return type:

ChampionshipRankingCollection[.Ranking]

async leaderboards_championship(championship_id: str, offset: int = 0, limit: int = 20) → Collection[Leaderboard]

Retrieve all leaderboards of a championship

Parameters:

• championship_id (str) – The id of the championship

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Leaderboards list

Return type:

Collection[.Leaderboard]

async leaderboards_championship_groups(championship_id: str, group: int, offset: int = 0, limit: int = 20) → ChampionshipRankingCollection[Ranking]

Retrieve group ranking of a championship

Parameters:

• championship_id (str) – The id of the championship

• group (int) – A group of the championship

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Leaderboards list

Return type:

ChampionshipRankingCollection[.Ranking]

async leaderboards_hub(hub_id: str, offset: int = 0, limit: int = 20) → Collection[Leaderboard]

Retrieve all leaderboards of a hub

Parameters:

• hub_id (str) – The id of the hub

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Leaderboards list

Return type:

Collection[.Leaderboard]

async leaderboards_hub_general(hub_id: str, offset: int = 0, limit: int = 20) → ChampionshipRankingCollection[Ranking]

Retrieve all time ranking of a hub

Parameters:

• hub_id (str) – The id of the hub

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Leaderboards list

Return type:

ChampionshipRankingCollection[.Ranking]

async leaderboards_hub_season(hub_id: str, season: int, offset: int = 0, limit: int = 20) → ChampionshipRankingCollection[Ranking]

Retrieve seasonal ranking of a hub

Parameters:

• hub_id (str) – The id of the hub

• season (int) – A season of the hub

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Leaderboards list

Return type:

ChampionshipRankingCollection[.Ranking]

async match(match_id: str) → Match

Retrieve match details

Parameters:

match_id (str) – The id of the match

Returns:

Match details

Return type:

Match

async match_stats(match_id: str) → MatchStats

Retrieve statistics of a match

Parameters:

match_id (str) – The id of the match

Returns:

Match details

Return type:

MatchStats

async organizer_by_id(organizer_id: str) → OrganizerData

Retrieve organizer details

Parameters:

organizer_id (str) – The id of the organizer

Returns:

Organizer details

Return type:

OrganizerData

async organizer_by_name(name: str) → OrganizerData

Retrieve organizer details from name

Parameters:

name (str) – The name of the organizer

Returns:

Organizer details

Return type:

OrganizerData

async organizer_championships(organizer_id: str, offset: int = 0, limit: int = 20) → Collection[Championship]

Retrieve all championships of an organizer

Parameters:

• organizer_id (str) – The id of the organizer

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Leaderboards list

Return type:

Collection[.Championship]

async organizer_games(organizer_id: str) → Collection[Hub]

Retrieve all games an organizer is involved with

Parameters:

organizer_id (str) – The id of the organizer

Returns:

Leaderboards list

Return type:

Collection[.Hub]

async organizer_hubs(organizer_id: str, offset: int = 0, limit: int = 20) → Collection[Hub]

Retrieve all hubs of an organizer

Parameters:

• organizer_id (str) – The id of the organizer

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Leaderboards list

Return type:

Collection[.Hub]

async organizer_tournaments(organizer_id: str, type_: MatchType = MatchType.UPCOMING, offset: int = 0, limit: int = 20) → Collection[Tournament]

Retrieve all tournaments of an organizer

Parameters:

• organizer_id (str) – The id of the organizer

• type (MatchType, optional) – Kind of tournament. Can be upcoming(default) or past

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Leaderboards list

Return type:

Collection[.Tournament]

async player_by_game_player_id(game: Game, game_player_id: str) → Player

Retrieve player details

Parameters:

• game (Game) – A game on FACEIT

• game_player_id (str) – The ID of a player on game’s platform

Returns:

Player details

Return type:

Player

async player_by_nickname(nickname: str) → Player

Retrieve player details

Parameters:

nickname (str) – The nickname of the player on FACEIT

Returns:

Player details

Return type:

Player

async player_by_player_id(player_id: str) → Player

Retrieve player details

Parameters:

player_id (str) – The id of the player

Returns:

Player details

Return type:

Player

async player_game_stats(player_id: str, game: Game) → PlayerGameStats

Retrieve statistics of a player

Parameters:

• player_id (str) – The id of the player

• game (Game) – A game on FACEIT

Returns:

Player stats

Return type:

Collection[.Hub]

async player_history(player_id: str, game: Game, from_: int | datetime = None, to: int | datetime = None, offset: int = 0, limit: int = 20) → FromToCollection[PlayerMatch]

Retrieve all matches of a player

Parameters:

• player_id (str) – The id of the player

• game (Game) – A game on FACEIT

• from (Union[int, datetime.datetime], optional) – The timestamp in sec or datetime as lower bound of the query. 1 month ago if not specified

• to (Union[int, datetime.datetime], optional) – The timestamp in sec or datetime as higher bound of the query. Current timestamp if not specified

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Player matches list

Return type:

FromToCollection[.PlayerMatch]

async player_hubs(player_id: str, offset: int = 0, limit: int = 20) → Collection[Hub]

Retrieve all hubs of a player

Parameters:

• player_id (str) – The id of the player

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Hubs list

Return type:

Collection[.Hub]

async player_tournaments(player_id: str, offset: int = 0, limit: int = 20) → Collection[Tournament]

Retrieve all tournaments of a player

Parameters:

• player_id (str) – The id of the player

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Tournaments list

Return type:

Collection[.Tournament]

async ranking(game: Game, region: Region, country: Country = None, offset: int = 0, limit: int = 20) → Collection[Rank]

Retrieve global ranking of a game

Parameters:

• player_id (str) – The id of the player

• region (Region) – A region of a game

• country (Country, optional) – A country code

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Tournaments list

Return type:

Collection[.Rank]

async ranking_of_player(game: Game, region: Region, player_id: str, country: Country = None, limit: int = 20) → RankCollection[Rank]

Retrieve global ranking of a game

Parameters:

• game (str) – The id of the player

• region (Region) – A region of a game

• player_id (str) – The id of a player

• country (Country, optional) – A country code

• limit (int, optional) – The number of items to return

Returns:

Tournaments list

Return type:

RankCollection[.Rank]

async search_championships(name: str, game: Game = None, region: Region = None, type_: MatchType = MatchType.ALL, offset: int = 0, limit: int = 20) → Collection[ChampionshipSearchResult]

Search for championships

Parameters:

• name (str) – The name of a championship on FACEIT

• game (Game, optional) – A game on FACEIT

• region (Region, optional) – A region of a game

• type (MatchType, optional) – Kind of competitions to return

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

List of championship

Return type:

Collection[.ChampionshipSearchResult]

async search_hubs(name: str, game: Game = None, region: Region = None, offset: int = 0, limit: int = 20) → Collection[ChampionshipSearchResult]

List of hub

Parameters:

• name (str) – The name of a hub on FACEIT

• game (Game, optional) – A game on FACEIT

• region (Region, optional) – A region of a game

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

List of hub

Return type:

Collection[.ChampionshipSearchResult]

async search_organizers(name: str, offset: int = 0, limit: int = 20) → Collection[OrganizerSearchResult]

Search for organizers

Parameters:

• name (str) – The name of a organizer on FACEIT

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

List of organizers

Return type:

Collection[.OrganizerSearchResult]

async search_players(nickname: str, game: Game = None, country: Country = None, offset: int = 0, limit: int = 20) → Collection[PlayerSearchResult]

Search for players

Parameters:

• nickname (str) – The nickname of a player on FACEIT

• game (Game, optional) – A game on FACEIT

• country (Country, optional) – A country code

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

List of players

Return type:

Collection[.PlayerSearchResult]

async search_teams(nickname: str, game: Game = None, offset: int = 0, limit: int = 20) → Collection[TeamSearchResult]

Search for teams

Parameters:

• nickname (str) – The nickname of a team on FACEIT

• game (Game, optional) – A game on FACEIT

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

List of teams

Return type:

Collection[.TeamSearchResult]

async search_tournaments(name: str, game: Game = None, region: Region = None, type_: MatchType = MatchType.ALL, offset: int = 0, limit: int = 20) → Collection[TournamentSearchResult]

Search for teams

Parameters:

• name (str) – The name of a tournament on FACEIT

• game (Game, optional) – A game on FACEIT

• region (Region, optional) – A region of a game

• type (MatchType, optional) – Kind of competitions to return

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

List of tournament

Return type:

Collection[.TournamentSearchResult]

async team(team_id: str) → Team

Retrieve team details

Parameters:

team_id (str) – The id of the team

Returns:

Team details

Return type:

Team

async team_game_stats(team_id: str, game: Game) → TeamGameStats

Retrieve statistics of a team

Parameters:

• team_id (str) – The id of the team

• game (Game) – A game on FACEIT

Returns:

Team stats

Return type:

TeamGameStats

async team_tournaments(team_id: str, offset: int = 0, limit: int = 20) → Collection[Tournament]

Retrieve tournaments of a team

Parameters:

• team_id (str) – The id of the team

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Tournaments list

Return type:

Collection[.Tournament]

async tournament(tournament_id: str, expanded: Expansion = Expansion.NONE) → TournamentData

Retrieve tournament details

Parameters:

• tournament_id (str) – The id of the tournament

• expanded (Expansion) – List of entity names to expand in request

Returns:

Tournament details

Return type:

TournamentData

async tournament_brackets(tournament_id: str) → Brackets

Retrieve brackets of a tournament

Parameters:

tournament_id (str) – The id of the tournament

Returns:

Tournament details

Return type:

Brackets

async tournament_matches(tournament_id: str, offset: int = 0, limit: int = 20) → Collection[Match]

Retrieve all matches of a tournament

Parameters:

• tournament_id (str) – The id of the tournament

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Matches list

Return type:

Collection[.Match]

async tournament_teams(tournament_id: str, offset: int = 0, limit: int = 20) → TournamentTeams

Retrieve all teams of a tournament

Parameters:

• tournament_id (str) – The id of the tournament

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Matches list

Return type:

TournamentTeams

async tournaments(game: Game = None, region: Region = None, offset: int = 0, limit: int = 20) → Collection[Tournament]

Retrieve tournaments v1 (no longer used)

Parameters:

• game (Game, optional) – A game on FACEIT

• region (Region, optional) – A region of a game

• offset (int, optional) – The starting item position

• limit (int, optional) – The number of items to return

Returns:

Tournaments list

Return type:

Collection[.Tournament]

async_faceit_api.dataclasses module

class async_faceit_api.dataclasses.Assets(cover: str = None, featured_img_l: str = None, featured_img_m: str = None, featured_img_s: str = None, flag_img_icon: str = None, flag_img_l: str = None, flag_img_m: str = None, flag_img_s: str = None, landing_page: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Bounds(left: int = None, right: int = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.BracketMatch(faceit_url: str = None, match_id: str = None, position: int = None, results: dict = None, round: int = None, state: str = None, teams: dict = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Brackets(game: str = None, matches: list = None, name: str = None, rounds: list = None, status: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Championship(anticheat_required: bool = None, avatar: str = None, background_image: str = None, championship_id: str = None, championship_start: int = None, checkin_clear: int = None, checkin_enabled: bool = None, checkin_start: int = None, cover_image: str = None, current_subscriptions: int = None, description: str = None, faceit_url: str = None, featured: bool = None, full: bool = None, game_id: str = None, id: str = None, join_checks: dict = None, name: str = None, organizer_id: str = None, prizes: list = None, region: str = None, rules_id: str = None, schedule: dict = None, seeding_strategy: str = None, slots: int = None, status: str = None, stream: dict = None, subscription_end: int = None, subscription_start: int = None, subscriptions_locked: bool = None, substitution_configuration: dict = None, total_groups: int = None, total_prizes: int = None, total_rounds: int = None, type: str = None, game_data: dict | None = None, organizer_data: dict | None = None, screening: dict | None = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.ChampionshipRankingCollection(end: int = None, items: List[T] = None, start: int = None, leaderboard: dict = None, **kwargs)

Bases: Collection, Generic[T]

class async_faceit_api.dataclasses.ChampionshipSearchResult(competition_id: str = None, competition_type: str = None, game: str = None, name: str = None, number_of_members: int = None, organizer_id: str = None, organizer_name: str = None, organizer_type: str = None, players_checkedin: int = None, players_joined: int = None, prize_type: str = None, region: str = None, slots: int = None, started_at: int = None, status: str = None, total_prize: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Collection(end: int = None, items: List[T] = None, start: int = None, **kwargs)

Bases: FaceitApiResponse, Generic[T]

class async_faceit_api.dataclasses.FaceitApiError(message: str = 'Bad Request', status_code: int = 400, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.FaceitApiRateLimitError(message: str = 'Too many requests', status_code: int = 429, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.FaceitApiResponse(success: bool = True, **kwargs)

Bases: object

class async_faceit_api.dataclasses.FromToCollection(end: int = None, items: list = None, start: int = None, from_: int = None, to: int = None, **kwargs)

Bases: Collection, Generic[T]

class async_faceit_api.dataclasses.GameData(assets: dict, game_id: str = None, long_label: str = None, order: int = None, parent_game_id: str = None, platforms: List[str] = None, regions: List[str] = None, short_label: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.GamePlayerStats(nickname: str = None, player_id: str = None, stats: dict = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.GameSearchResult(name: str = None, skill_level: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.GameStats(game_id: str = None, players: list = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Hub(avatar: str = None, faceit_url: str = None, game_id: str = None, hub_id: str = None, name: str = None, organizer_id: str = None, background_image: str = None, chat_room_id: str = None, cover_image: str = None, description: str = None, game_data: dict = None, join_permission: str = None, max_skill_level: int = None, min_skill_level: int = None, organizer_data: dict = None, players_joined: int = None, region: str = None, rule_id: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.JoinChecks(allowed_team_types: List[str] = None, blacklist_geo_countries: List[str] = None, join_policy: str = None, max_skill_level: int = None, membership_type: str = None, min_skill_level: int = None, whitelist_geo_countries: List[str] = None, whitelist_geo_countries_min_players: int = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Leaderboard(competition_id: str = None, competition_type: str = None, end_date: int = None, game_id: str = None, leaderboard_id: str = None, leaderboard_mode: str = None, leaderboard_name: str = None, leaderboard_type: str = None, min_matches: int = None, points_per_draw: int = None, points_per_loss: int = None, points_per_win: int = None, points_type: str = None, ranking_boost: int = None, ranking_type: str = None, region: str = None, start_date: int = None, starting_points: int = None, status: str = None, group: int = None, round: int = None, season: int = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Match(best_of: int = None, calculate_elo: bool = None, chat_room_id: str = None, competition_id: str = None, competition_name: str = None, competition_type: str = None, faceit_url: str = None, game: str = None, match_id: str = None, organizer_id: str = None, region: str = None, status: str = None, teams: dict = None, version: int = None, broadcast_start_time: int = None, broadcast_start_time_label: str = None, configured_at: int = None, demo_url: List[str] = None, finished_at: int = None, group: int = None, results: dict = None, round: int = None, scheduled_at: int = None, started_at: int = None, voting: dict = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.MatchStats(rounds: list, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Member(avatar: str = None, faceit_url: str = None, nickname: str = None, roles: List[str] = None, user_id: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.OrganizerData(avatar: str = None, cover: str = None, description: str = None, facebook: str = None, faceit_url: str = None, followers_count: int = None, name: str = None, organizer_id: str = None, twitch: str = None, twitter: str = None, type: str = None, vk: str = None, website: str = None, youtube: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.OrganizerSearchResult(active: bool = None, avatar: str = None, countries: List[str] = None, games: List[str] = None, name: str = None, organizer_id: str = None, partner: bool = None, regions: List[str] = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Placement(id: str = None, name: str = None, type: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Player(avatar: str = None, country: str = None, cover_featured_image: str = None, cover_image: str = None, faceit_url: str = None, friends_ids: List[str] = None, games: dict = None, infractions: dict = None, membership_type: str = None, memberships: List[str] = None, new_steam_id: str = None, nickname: str = None, platforms: dict = None, player_id: str = None, settings: dict = None, steam_id_64: str = None, steam_nickname: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.PlayerGameStats(game_id: str = None, lifetime: dict = None, player_id: str = None, segments: list = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.PlayerMatch(competition_id: str = None, competition_name: str = None, competition_type: str = None, faceit_url: str = None, finished_at: int = None, game_id: str = None, game_mode: str = None, match_id: str = None, match_type: str = None, max_players: int = None, organizer_id: str = None, playing_players: List[str] = None, region: str = None, results: dict = None, started_at: int = None, status: str = None, teams: dict = None, teams_size: int = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.PlayerSearchResult(avatar: str = None, country: str = None, games: list = None, nickname: str = None, player_id: str = None, status: str = None, verified: bool = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.PlayerStats(nickname: str = None, player_id: str = None, player_stats: dict = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Prize(faceit_points: int = None, rank: int = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Rank(country: str = None, faceit_elo: int = None, game_skill_level: int = None, nickname: str = None, player_id: str = None, position: int = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.RankCollection(end: int = None, items: List[T] = None, start: int = None, position: int = None, **kwargs)

Bases: Collection, Generic[T]

class async_faceit_api.dataclasses.Ranking(current_streak: int = None, draw: int = None, lost: int = None, played: int = None, player: dict = None, points: int = None, position: int = None, win_rate: int = None, won: int = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Result(bounds: dict = None, placements: list = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Results(score: dict = None, winner: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Role(color: str = None, name: str = None, ranking: int = None, role_id: str = None, visible_on_chat: bool = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Round(best_of: int = None, label: str = None, matches: int = None, round: int = None, start_time: int = None, starts_asap: bool = None, substitution_time: int = None, substitutions_allowed: bool = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.RoundStats(best_of: dict, competition_id: dict, game_id: dict, game_mode: dict, match_id: dict, match_round: dict, played: dict, round_stats: dict, teams: list, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Rule(body: str = None, game: str = None, name: str = None, organizer: str = None, rule_id: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Stream(active: bool = None, platform: str = None, source: str = None, title: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Subscription(coach: str = None, coleader: str = None, group: int = None, leader: str = None, roster: List[str] = None, status: str = None, substitutes: List[str] = None, team: dict = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.SubstitutionConfiguration(max_substitutes: int = None, max_substitutions: int = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Team(avatar: str = None, chat_room_id: str = None, cover_image: str = None, description: str = None, facebook: str = None, faceit_url: str = None, game: str = None, leader: str = None, members: list = None, name: str = None, nickname: str = None, team_id: str = None, team_type: str = None, twitter: str = None, website: str = None, youtube: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.TeamGameStats(game_id: str = None, lifetime: dict = None, segments: list = None, team_id: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.TeamMember(avatar: str = None, country: str = None, faceit_url: str = None, nickname: str = None, user_id: str = None, membership_type: str = None, memberships: List[str] = None, skill_level: int = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.TeamSearchResult(avatar: str = None, chat_room_id: str = None, faceit_url: str = None, game: str = None, name: str = None, team_id: str = None, verified: bool = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.TeamStats(players: list, premade: dict, team_id: dict, team_stats: dict, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.Tournament(anticheat_required: bool = None, custom: bool = None, faceit_url: str = None, featured_image: str = None, game_id: str = None, invite_type: str = None, match_type: str = None, max_skill: int = None, membership_type: str = None, min_skill: int = None, name: str = None, number_of_players: int = None, number_of_players_checkedin: int = None, number_of_players_joined: int = None, number_of_players_participants: int = None, organizer_id: str = None, prize_type: str = None, region: str = None, started_at: int = None, status: str = None, subscriptions_count: int = None, team_size: int = None, total_prize: dict = None, tournament_id: str = None, whitelist_countries: list = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.TournamentData(anticheat_required: bool = None, best_of: dict = None, calculate_elo: bool = None, competition_id: str = None, cover_image: str = None, custom: bool = None, description: str = None, faceit_url: str = None, featured_image: str = None, game_data: dict = None, game_id: str = None, invite_type: str = None, match_type: str = None, max_skill: int = None, membership_type: str = None, min_skill: int = None, name: str = None, number_of_players: int = None, number_of_players_checkedin: int = None, number_of_players_joined: int = None, number_of_players_participants: int = None, organizer_data: dict = None, organizer_id: str = None, prize_type: str = None, region: str = None, rounds: list = None, rule: str = None, started_at: int = None, status: str = None, substitutes_allowed: int = None, substitutions_allowed: int = None, team_size: int = None, total_prize: dict = None, tournament_id: str = None, voting: dict = None, whitelist_countries: list = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.TournamentSearchResult(competition_id: str = None, competition_type: str = None, game: str = None, name: str = None, number_of_members: int = None, organizer_id: str = None, organizer_name: str = None, organizer_type: str = None, players_checkedin: int = None, players_joined: int = None, prize_type: str = None, region: str = None, slots: int = None, started_at: int = None, status: str = None, total_prize: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.TournamentTeam(nickname: str = None, skill_level: int = None, subs_done: int = None, team_id: str = None, team_leader: str = None, team_type: str = None, **kwargs)

Bases: FaceitApiResponse

class async_faceit_api.dataclasses.TournamentTeams(checked_in: list, finished: list, joined: list, started: list, **kwargs)

Bases: FaceitApiResponse

async_faceit_api.enums module

class async_faceit_api.enums.Country(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

AFGHANISTAN = 'AF'

ALAND_ISLANDS = 'AX'

ALBANIA = 'AL'

ALGERIA = 'DZ'

AMERICAN_SAMOA = 'AS'

ANDORRA = 'AD'

ANGOLA = 'AO'

ANGUILLA = 'AI'

ANTARCTICA = 'AQ'

ANTIGUA_AND_BARBUDA = 'AG'

ARGENTINA = 'AR'

ARMENIA = 'AM'

ARUBA = 'AW'

AUSTRALIA = 'AU'

AUSTRIA = 'AT'

AZERBAIJAN = 'AZ'

BAHAMAS = 'BS'

BAHRAIN = 'BH'

BANGLADESH = 'BD'

BARBADOS = 'BB'

BELARUS = 'BY'

BELGIUM = 'BE'

BELIZE = 'BZ'

BENIN = 'BJ'

BERMUDA = 'BM'

BHUTAN = 'BT'

BOLIVIA = 'BO'

BONAIRE = 'BQ'

BOSNIA_AND_HERZEGOVINA = 'BA'

BOTSWANA = 'BW'

BOUVET_ISLAND = 'BV'

BRAZIL = 'BR'

BRITISH_INDIAN_OCEAN_TERRITORY = 'IO'

BRUNEI_DARUSSALAM = 'BN'

BULGARIA = 'BG'

BURKINA_FASO = 'BF'

BURUNDI = 'BI'

CABO_VERDE = 'CV'

CAMBODIA = 'KH'

CAMEROON = 'CM'

CANADA = 'CA'

CAYMAN_ISLANDS = 'KY'

CENTRAL_AFRICAN_REPUBLIC = 'CF'

CHAD = 'TD'

CHILE = 'CL'

CHINA = 'CN'

CHRISTMAS_ISLAND = 'CX'

COCOS_ISLANDS = 'CC'

COLOMBIA = 'CO'

COMOROS = 'KM'

CONGO = 'CG'

COOK_ISLANDS = 'CK'

COSTA_RICA = 'CR'

COTE_D_IVOIRE = 'CI'

CROATIA = 'HR'

CUBA = 'CU'

CURACAO = 'CW'

CYPRUS = 'CY'

CZECH_REPUBLIC = 'CZ'

DEMOCRATIC_PEOPLES_REPUBLIC_OF_KOREA = 'KP'

DEMOCRATIC_REPUBLIC_OF_THE_CONGO = 'CD'

DENMARK = 'DK'

DJIBOUTI = 'DJ'

DOMINICA = 'DM'

DOMINICAN_REPUBLIC = 'DO'

ECUADOR = 'EC'

EGYPT = 'EG'

EL_SALVADOR = 'SV'

EQUATORIAL_GUINEA = 'GQ'

ERITREA = 'ER'

ESTONIA = 'EE'

ETHIOPIA = 'ET'

FALKLAND_ISLANDS = 'FK'

FAROE_ISLANDS = 'FO'

FIJI = 'FJ'

FINLAND = 'FI'

FRANCE = 'FR'

FRENCH_GUIANA = 'GF'

FRENCH_POLYNESIA = 'PF'

FRENCH_SOUTHERN_TERRITORIES = 'TF'

GABON = 'GA'

GAMBIA = 'GM'

GEORGIA = 'GE'

GERMANY = 'DE'

GHANA = 'GH'

GIBRALTAR = 'GI'

GREECE = 'GR'

GREENLAND = 'GL'

GRENADA = 'GD'

GUADELOUPE = 'GP'

GUAM = 'GU'

GUATEMALA = 'GT'

GUERNSEY = 'GG'

GUINEA = 'GN'

GUINEA_BISSAU = 'GW'

GUYANA = 'GY'

HAITI = 'HT'

HEARD_ISLAND_AND_MCDONALD_ISLANDS = 'HM'

HOLY_SEE = 'VA'

HONDURAS = 'HN'

HONG_KONG = 'HK'

HUNGARY = 'HU'

ICELAND = 'IS'

INDIA = 'IN'

INDONESIA = 'ID'

IRAN = 'IR'

IRAQ = 'IQ'

IRELAND = 'IE'

ISLE_OF_MAN = 'IM'

ISRAEL = 'IL'

ITALY = 'IT'

JAMAICA = 'JM'

JAPAN = 'JP'

JERSEY = 'JE'

JORDAN = 'JO'

KAZAKHSTAN = 'KZ'

KENYA = 'KE'

KIRIBATI = 'KI'

KUWAIT = 'KW'

KYRGYZSTAN = 'KG'

LAO_PEOPLES_DEMOCRATIC_REPUBLIC = 'LA'

LATVIA = 'LV'

LEBANON = 'LB'

LESOTHO = 'LS'

LIBERIA = 'LR'

LIBYA = 'LY'

LIECHTENSTEIN = 'LI'

LITHUANIA = 'LT'

LUXEMBOURG = 'LU'

MACAO = 'MO'

MACEDONIA = 'MK'

MADAGASCAR = 'MG'

MALAWI = 'MW'

MALAYSIA = 'MY'

MALDIVES = 'MV'

MALI = 'ML'

MALTA = 'MT'

MARSHALL_ISLANDS = 'MH'

MARTINIQUE = 'MQ'

MAURITANIA = 'MR'

MAURITIUS = 'MU'

MAYOTTE = 'YT'

MEXICO = 'MX'

MICRONESIA = 'FM'

MOLDOVA = 'MD'

MONACO = 'MC'

MONGOLIA = 'MN'

MONTENEGRO = 'ME'

MONTSERRAT = 'MS'

MOROCCO = 'MA'

MOZAMBIQUE = 'MZ'

MYANMAR = 'MM'

NAMIBIA = 'NA'

NAURU = 'NR'

NEPAL = 'NP'

NETHERLANDS = 'NL'

NEW_CALEDONIA = 'NC'

NEW_ZEALAND = 'NZ'

NICARAGUA = 'NI'

NIGER = 'NE'

NIGERIA = 'NG'

NIUE = 'NU'

NORFOLK_ISLAND = 'NF'

NORTHERN_MARIANA_ISLANDS = 'MP'

NORWAY = 'NO'

OMAN = 'OM'

PAKISTAN = 'PK'

PALAU = 'PW'

PANAMA = 'PA'

PAPUA_NEW_GUINEA = 'PG'

PARAGUAY = 'PY'

PERU = 'PE'

PHILIPPINES = 'PH'

PITCAIRN = 'PN'

POLAND = 'PL'

PORTUGAL = 'PT'

PUERTO_RICO = 'PR'

QATAR = 'QA'

REPUBLIC_OF_KOREA = 'KR'

REUNION = 'RE'

ROMANIA = 'RO'

RUSSIAN_FEDERATION = 'RU'

RWANDA = 'RW'

SAINT_BARTHELEMY = 'BL'

SAINT_HELENA_ASCENSION_AND_TRISTAN_DA_CUNHA = 'SH'

SAINT_KITTS_AND_NEVIS = 'KN'

SAINT_LUCIA = 'LC'

SAINT_MARTIN_FENCH = 'MF'

SAINT_PIERRE_AND_MIQUELON = 'PM'

SAINT_VINCENT_AND_THE_GRENADINES = 'VC'

SAMOA = 'WS'

SAN_MARINO = 'SM'

SAO_TOME_AND_PRINCIPE = 'ST'

SAUDI_ARABIA = 'SA'

SENEGAL = 'SN'

SERBIA = 'RS'

SEYCHELLES = 'SC'

SIERRA_LEONE = 'SL'

SINGAPORE = 'SG'

SINT_MAARTEN_DUTCH = 'SX'

SLOVAKIA = 'SK'

SLOVENIA = 'SI'

SOLOMON_ISLANDS = 'SB'

SOMALIA = 'SO'

SOUTH_AFRICA = 'ZA'

SOUTH_GEORGIA_AND_THE_SOUTH_SANDWICH_ISLANDS = 'GS'

SOUTH_SUDAN = 'SS'

SPAIN = 'ES'

SRI_LANKA = 'LK'

STATE_OF_PALESTINE = 'PS'

SUDAN = 'SD'

SURINAME = 'SR'

SVALBARD_AND_JAN_MAYEN = 'SJ'

SWAZILAND = 'SZ'

SWEDEN = 'SE'

SWITZERLAND = 'CH'

SYRIAN_ARAB_REPUBLIC = 'SY'

TAIWAN = 'TW'

TAJIKISTAN = 'TJ'

TANZANIA = 'TZ'

THAILAND = 'TH'

TIMOR_LESTE = 'TL'

TOGO = 'TG'

TOKELAU = 'TK'

TONGA = 'TO'

TRINIDAD_AND_TOBAGO = 'TT'

TUNISIA = 'TN'

TURKEY = 'TR'

TURKMENISTAN = 'TM'

TURKS_AND_CAICOS_ISLANDS = 'TC'

TUVALU = 'TV'

UGANDA = 'UG'

UKRAINE = 'UA'

UNITED_ARAB_EMIRATES = 'AE'

UNITED_KINGDOM_OF_GREAT_BRITAIN_AND_NORTHERN_IRELAND = 'GB'

UNITED_STATES_MINOR_OUTLYING_ISLANDS = 'UM'

UNITED_STATES_OF_AMERICA = 'US'

URUGUAY = 'UY'

UZBEKISTAN = 'UZ'

VANUATU = 'VU'

VENEZUELA = 'VE'

VIET_NAM = 'VN'

VIRGIN_ISLANDS_BRITISH = 'VG'

VIRGIN_ISLANDS_US = 'VI'

WALLIS_AND_FUTUNA = 'WF'

WESTERN_SAHARA = 'EH'

YEMEN = 'YE'

ZAMBIA = 'ZM'

ZIMBABWE = 'ZW'

class async_faceit_api.enums.Expansion(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

GAME = 'game'

NONE = ''

ORGANIZER = 'organizer'

class async_faceit_api.enums.Game(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

APEX = 'apex'

BRAWL_STARS = 'brawl_stars'

BRAWL_STARS_AUTO = 'brawl_stars_auto'

CLASH_ROYALE = 'clash_royale'

CLASH_ROYALE_AUTO = 'clash_royale_auto'

CS2 = 'cs2'

CS_DZ = 'csdz'

CS_GO = 'csgo'

DESTINY_2 = 'destiny2_parent'

DESTINY_2_PC = 'destiny2'

DESTINY_2_PS4 = 'destiny2_ps4'

DESTINY_2_XBOX = 'destiny2_xbox'

DIRTY_BOMB = 'dirtybomb'

DOTA_2 = 'dota2'

FALLGUYS = 'fallguys'

FIFA20 = 'fifa20'

FIFA22 = 'fifa22'

HALO_3 = 'halo_3'

HALO_5_XBOX = 'halo_5'

HALO_INFINITE = 'halo_infinite'

HALO_MCC = 'halo_mcc'

HEARTHSTONE = 'hearthstone'

HS_BATTLEGROUNDS = 'hearthstone-battlegrounds'

KRUNKER = 'krunker'

LOL = 'Wild'

LOL_BR = 'lol_BR'

LOL_EUN = 'lol_EUN'

LOL_EUW = 'lol_EUW'

LOL_LAN = 'lol_LAN'

LOL_LAS = 'lol_LAS'

LOL_NA = 'lol_NA'

LOL_OCE = 'lol_OCE'

LOL_PARENT = 'lol_parent'

LOL_TR = 'lol_TR'

MINION_MASTERS = 'minion_masters'

NEW_STATE_MOBILE = 'newstate'

NHL_18_PS4 = 'nhl_18_PS4'

NHL_18_XBOX = 'nhl_18_XBOX'

NHL_19 = 'nhl_19'

NHL_19_PS4 = 'nhl_19_PS4'

NHL_19_XBOX = 'nhl_19_XBOX'

NHL_20 = 'nhl_20_parent'

NHL_20_PS4 = 'nhl_20_ps4'

NHL_20_XBOX = 'nhl_20_xbox'

OVERWATCH = 'overwatch'

OVERWATCH_EU = 'overwatch_EU'

OVERWATCH_KR = 'overwatch_KR'

OVERWATCH_US = 'overwatch_US'

PUBG = 'pubg'

PUBG_MOBILE = 'pubgmobile'

QUAKE_CHAMPIONS = 'quake_champions'

RAINBOW6S = 'rainbow_6'

RAINBOW6S_PC = 'gs_rainbow_6'

RAINBOW6S_PS4 = 'gs_rainbow_6_ps4'

RAINBOW6S_XBOX = 'gs_rainbow_6_xbox'

RIFT = 'wildrift'

RING_OF_ELYSIUM = 'ring_of_elysium'

RL_XBOX_PC = 'rl_XBOX_PC'

ROCKET_LEAGUE = 'rocket_league'

SMITE = 'smite'

SMITE_XBOX = 'smite_xbox'

TEAMFIGHT_TACTICS = 'teamfight_tactics'

TEMPERIA = 'temperia'

TF2 = 'tf2'

TRACKMANIA = 'trackmania'

VALORANT = 'valorant'

WARFACE = 'warface'

WARFACE_ALPHA = 'warface_alpha'

WARFACE_EU = 'warface_eu'

WARFACE_NA = 'warface_na'

WARFACE_PARENT = 'warface_parent'

WOT_EU = 'wot_EU'

WOT_NA = 'wot_NA'

WOT_RU = 'wot_RU'

WOT_XBOX = 'wot_xbox'

WOW = 'wow'

class async_faceit_api.enums.MatchType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

ALL = 'all'

ONGOING = 'ongoing'

PAST = 'past'

UPCOMING = 'upcoming'

class async_faceit_api.enums.RateLimitBehaviour(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

ALWAYS_WAIT = 1

NEVER_WAIT = 0

WAIT_SOME_SEC = 2

class async_faceit_api.enums.Region(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: Enum

EU = 'EU'

OCEANIA = 'Oceania'

SA = 'SA'

SEA = 'SEA'

US = 'US'

Module contents