Models¶

Common¶

This module contains models for miscellaneous objects.

class aiosu.models.common.Achievement(*, id: int, name: str, slug: str, description: str, grouping: str, icon_url: str, ordering: int, mode: Gamemode | None = None, instructions: str | None = None)¶

id: int¶

name: str¶

slug: str¶

description: str¶

grouping: str¶

icon_url: str¶

ordering: int¶

mode: Gamemode | None¶

instructions: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'description': FieldInfo(annotation=str, required=True), 'grouping': FieldInfo(annotation=str, required=True), 'icon_url': FieldInfo(annotation=str, required=True), 'id': FieldInfo(annotation=int, required=True), 'instructions': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'mode': FieldInfo(annotation=Union[Gamemode, NoneType], required=False, default=None), 'name': FieldInfo(annotation=str, required=True), 'ordering': FieldInfo(annotation=int, required=True), 'slug': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.common.Country(*, code: str, name: str)¶

code: str¶

name: str¶

property flag_emoji: str¶

Emoji for the flag.

Returns:: Unicode emoji representation of the country’s flag
Return type:: str

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {'flag_emoji': ComputedFieldInfo(wrapped_property=<functools.cached_property object>, return_type=<class 'str'>, alias=None, alias_priority=None, title=None, description="Emoji for the flag.\n\n:return: Unicode emoji representation of the country's flag\n:rtype: str", deprecated=None, examples=None, json_schema_extra=None, repr=True)}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'code': FieldInfo(annotation=str, required=True), 'name': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

can_beatmap_update_owner: bool | None¶

can_delete: bool | None¶

can_edit_metadata: bool | None¶

can_edit_tags: bool | None¶

can_hype: bool | None¶

can_hype_reason: str | None¶

can_love: bool | None¶

can_remove_from_loved: bool | None¶

is_watching: bool | None¶

new_hype_time: datetime | None¶

nomination_modes: list[Gamemode] | None¶

remaining_hype: int | None¶

can_destroy: bool | None¶

can_reopen: bool | None¶

can_moderate_kudosu: bool | None¶

can_resolve: bool | None¶

vote_score: int | None¶

can_message: bool | None¶

can_message_error: str | None¶

last_read_id: int | None¶

can_new_comment: bool | None¶

can_new_comment_reason: str | None¶

pin: PinAttributes | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'can_beatmap_update_owner': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'can_delete': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'can_destroy': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'can_edit_metadata': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'can_edit_tags': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'can_hype': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'can_hype_reason': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'can_love': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'can_message': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'can_message_error': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'can_moderate_kudosu': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'can_new_comment': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'can_new_comment_reason': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'can_remove_from_loved': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'can_reopen': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'can_resolve': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'is_watching': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'last_read_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'new_hype_time': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'nomination_modes': FieldInfo(annotation=Union[list[Gamemode], NoneType], required=False, default=None), 'pin': FieldInfo(annotation=Union[PinAttributes, NoneType], required=False, default=None), 'remaining_hype': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'vote_score': FieldInfo(annotation=Union[int, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.common.CursorModel(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None)¶

NOTE: This model is not serializable by orjson directly.

Use the provided .model_dump_json() or .model_dump() methods instead.

cursor_string: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

class aiosu.models.common.HTMLBody(*, html: str, raw: str | None = None, bbcode: str | None = None)¶

html: str¶

raw: str | None¶

bbcode: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'bbcode': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'html': FieldInfo(annotation=str, required=True), 'raw': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.common.TimestampedCount(*, start_date: datetime, count: int)¶

start_date: datetime¶

count: int¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'count': FieldInfo(annotation=int, required=True), 'start_date': FieldInfo(annotation=datetime, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

aiosu.models.common.SortType¶: alias of Literal[‘id_asc’, ‘id_desc’]

aiosu.models.common.ScoreType¶: alias of Literal[‘solo_score’, ‘score_best_osu’, ‘score_best_taiko’, ‘score_best_fruits’, ‘score_best_mania’, ‘score_osu’, ‘score_taiko’, ‘score_fruits’, ‘score_mania’, ‘legacy_match_score’]

aiosu.models.common.BeatmapScoreboardType¶: alias of Literal[‘global’, ‘country’, ‘friend’]

Rankings¶

This module contains models for rankings.

class aiosu.models.rankings.Rankings(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None, ranking: list[UserStats], total: int | None = None, spotlight: Spotlight | None = None, beatmapsets: list[Beatmapset] | None = None)¶

ranking: list[UserStats]¶

total: int | None¶

spotlight: Spotlight | None¶

beatmapsets: list[Beatmapset] | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'beatmapsets': FieldInfo(annotation=Union[list[Beatmapset], NoneType], required=False, default=None), 'cursor_string': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'next': FieldInfo(annotation=Union[partial[Coroutine[object, object, CursorModel]], NoneType], required=False, default=None, exclude=True), 'ranking': FieldInfo(annotation=list[UserStats], required=True), 'spotlight': FieldInfo(annotation=Union[Spotlight, NoneType], required=False, default=None), 'total': FieldInfo(annotation=Union[int, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

aiosu.models.rankings.RankingType¶: alias of Literal[‘performance’, ‘score’, ‘country’, ‘charts’]

aiosu.models.rankings.RankingFilter¶: alias of Literal[‘all’, ‘friends’]

aiosu.models.rankings.RankingVariant¶: alias of Literal[‘4k’, ‘7k’]

User¶

This module contains models for User objects.

avatar_url: str¶

country_code: str¶

id: int¶

username: str¶

default_group: str | None¶

is_active: bool | None¶

is_bot: bool | None¶

is_online: bool | None¶

is_supporter: bool | None¶

pm_friends_only: bool | None¶

profile_colour: str | None¶

is_deleted: bool | None¶

last_visit: datetime | None¶

discord: str | None¶

has_supported: bool | None¶

interests: str | None¶

join_date: datetime | None¶

kudosu: UserKudosu | None¶

location: str | None¶

max_blocks: int | None¶

max_friends: int | None¶

occupation: str | None¶

playmode: Gamemode | None¶

playstyle: list[str] | None¶

post_count: int | None¶

profile_order: list[str] | None¶

title: str | None¶

twitter: str | None¶

website: str | None¶

country: Country | None¶

cover: UserProfileCover | None¶

is_restricted: bool | None¶

account_history: list[UserAccountHistory] | None¶

active_tournament_banners: list[UserProfileTournamentBanner] | None¶

badges: list[UserBadge] | None¶

beatmap_playcounts_count: int | None¶

favourite_beatmapset_count: int | None¶

follow_user_mapping: list[int] | None¶

follower_count: int | None¶

friends: list[UserRelation] | None¶

graveyard_beatmapset_count: int | None¶

groups: list[UserGroup] | None¶

loved_beatmapset_count: int | None¶

mapping_follower_count: int | None¶

monthly_playcounts: list[TimestampedCount] | None¶

page: HTMLBody | None¶

pending_beatmapset_count: int | None¶

previous_usernames: list[str] | None¶

rank_highest: UserRankHighest | None¶

rank_history: UserRankHistoryElement | None¶

ranked_beatmapset_count: int | None¶

replays_watched_counts: list[TimestampedCount] | None¶

scores_best_count: int | None¶

scores_first_count: int | None¶

scores_recent_count: int | None¶

statistics: UserStats | None¶

statistics_rulesets: UserStatsRulesets | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {'url': ComputedFieldInfo(wrapped_property=<property object>, return_type=<class 'str'>, alias=None, alias_priority=None, title=None, description=None, deprecated=None, examples=None, json_schema_extra=None, repr=True)}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'account_history': FieldInfo(annotation=Union[list[UserAccountHistory], NoneType], required=False, default=None), 'active_tournament_banners': FieldInfo(annotation=Union[list[UserProfileTournamentBanner], NoneType], required=False, default=None), 'avatar_url': FieldInfo(annotation=str, required=True), 'badges': FieldInfo(annotation=Union[list[UserBadge], NoneType], required=False, default=None), 'beatmap_playcounts_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'country': FieldInfo(annotation=Union[Country, NoneType], required=False, default=None), 'country_code': FieldInfo(annotation=str, required=True), 'cover': FieldInfo(annotation=Union[UserProfileCover, NoneType], required=False, default=None), 'default_group': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'discord': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'favourite_beatmapset_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'follow_user_mapping': FieldInfo(annotation=Union[list[int], NoneType], required=False, default=None), 'follower_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'friends': FieldInfo(annotation=Union[list[UserRelation], NoneType], required=False, default=None), 'graveyard_beatmapset_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'groups': FieldInfo(annotation=Union[list[UserGroup], NoneType], required=False, default=None), 'has_supported': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'interests': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'is_active': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'is_bot': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'is_deleted': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'is_online': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'is_restricted': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'is_supporter': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'join_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'kudosu': FieldInfo(annotation=Union[UserKudosu, NoneType], required=False, default=None), 'last_visit': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'location': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'loved_beatmapset_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'mapping_follower_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'max_blocks': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'max_friends': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'monthly_playcounts': FieldInfo(annotation=Union[list[TimestampedCount], NoneType], required=False, default=None), 'occupation': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'page': FieldInfo(annotation=Union[HTMLBody, NoneType], required=False, default=None), 'pending_beatmapset_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'playmode': FieldInfo(annotation=Union[Gamemode, NoneType], required=False, default=None), 'playstyle': FieldInfo(annotation=Union[list[str], NoneType], required=False, default=None), 'pm_friends_only': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'post_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'previous_usernames': FieldInfo(annotation=Union[list[str], NoneType], required=False, default=None), 'profile_colour': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'profile_order': FieldInfo(annotation=Union[list[str], NoneType], required=False, default=None), 'rank_highest': FieldInfo(annotation=Union[UserRankHighest, NoneType], required=False, default=None), 'rank_history': FieldInfo(annotation=Union[UserRankHistoryElement, NoneType], required=False, default=None), 'ranked_beatmapset_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'replays_watched_counts': FieldInfo(annotation=Union[list[TimestampedCount], NoneType], required=False, default=None), 'scores_best_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'scores_first_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'scores_recent_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'statistics': FieldInfo(annotation=Union[UserStats, NoneType], required=False, default=None), 'statistics_rulesets': FieldInfo(annotation=Union[UserStatsRulesets, NoneType], required=False, default=None), 'support_level': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'twitter': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'unread_pm_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'user_achievements': FieldInfo(annotation=Union[list[UserAchievmement], NoneType], required=False, default=None), 'username': FieldInfo(annotation=str, required=True), 'website': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

support_level: int | None¶

unread_pm_count: int | None¶

user_achievements: list[UserAchievmement] | None¶

property url: str¶

class aiosu.models.user.UserAccountHistory(*, id: int, timestamp: datetime, length: int, permanent: bool, type: Literal['note', 'restriction', 'silence', 'tournament_ban'], description: str | None = None)¶

id: int¶

timestamp: datetime¶

length: int¶

permanent: bool¶

type: UserAccountHistoryType¶

description: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'length': FieldInfo(annotation=int, required=True), 'permanent': FieldInfo(annotation=bool, required=True), 'timestamp': FieldInfo(annotation=datetime, required=True), 'type': FieldInfo(annotation=Literal['note', 'restriction', 'silence', 'tournament_ban'], required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.user.UserBadge(*, awarded_at: datetime, description: str, image_url: str, image_2x_url: str, url: str)¶

awarded_at: datetime¶

description: str¶

image_url: str¶

image_2x_url: str¶

url: str¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'awarded_at': FieldInfo(annotation=datetime, required=True), 'description': FieldInfo(annotation=str, required=True), 'image_2x_url': FieldInfo(annotation=str, required=True, alias='image@2x_url', alias_priority=2), 'image_url': FieldInfo(annotation=str, required=True), 'url': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.user.UserGradeCounts(*, ssh: int, ss: int, sh: int, s: int, a: int)¶

ssh: int¶: Number of Silver SS ranks achieved.

ss: int¶: Number of SS ranks achieved.

sh: int¶: Number of Silver S ranks achieved.

s: int¶: Number of S ranks achieved.

a: int¶: Number of A ranks achieved.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'a': FieldInfo(annotation=int, required=True), 's': FieldInfo(annotation=int, required=True), 'sh': FieldInfo(annotation=int, required=True), 'ss': FieldInfo(annotation=int, required=True), 'ssh': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.user.UserGroup(*, id: int, identifier: str, name: str, short_name: str, has_listing: bool, has_playmodes: bool, is_probationary: bool, colour: str | None = None, playmodes: list[Gamemode] | None = None, description: str | None = None)¶

id: int¶

identifier: str¶

name: str¶

short_name: str¶

has_listing: bool¶

has_playmodes: bool¶

is_probationary: bool¶

colour: str | None¶

playmodes: list[Gamemode] | None¶

description: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'colour': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'has_listing': FieldInfo(annotation=bool, required=True), 'has_playmodes': FieldInfo(annotation=bool, required=True), 'id': FieldInfo(annotation=int, required=True), 'identifier': FieldInfo(annotation=str, required=True), 'is_probationary': FieldInfo(annotation=bool, required=True), 'name': FieldInfo(annotation=str, required=True), 'playmodes': FieldInfo(annotation=Union[list[Gamemode], NoneType], required=False, default=None), 'short_name': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.user.UserKudosu(*, total: int, available: int)¶

total: int¶

available: int¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'available': FieldInfo(annotation=int, required=True), 'total': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.user.UserLevel(*, current: int, progress: int)¶

current: int¶

progress: int¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'current': FieldInfo(annotation=int, required=True), 'progress': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.user.UserProfileCover(*, url: str, custom_url: str | None = None, id: str | None = None)¶

url: str¶

custom_url: str | None¶

id: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'custom_url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'id': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'url': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.user.UserProfileTournamentBanner(*, tournament_id: int, id: int | None = None, image: str | None = None, image_2_x: str | None = None)¶

tournament_id: int¶

id: int | None¶

image: str | None¶

image_2_x: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'image': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'image_2_x': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='image@2x', alias_priority=2), 'tournament_id': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.user.UserQueryType(value)¶

An enumeration.

ID = 'id'¶

USERNAME = 'username'¶

property old_api_name: str¶

property new_api_name: str¶

class aiosu.models.user.UserRankHighest(*, rank: int, updated_at: datetime)¶

rank: int¶

updated_at: datetime¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'rank': FieldInfo(annotation=int, required=True), 'updated_at': FieldInfo(annotation=datetime, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.user.UserRankHistoryElement(*, mode: str, data: list[int])¶

mode: str¶

data: list[int]¶

property average_gain: float¶

Average rank gain.

Returns:: Average rank gain for a user
Return type:: float

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {'average_gain': ComputedFieldInfo(wrapped_property=<functools.cached_property object>, return_type=<class 'float'>, alias=None, alias_priority=None, title=None, description='Average rank gain.\n\n:return: Average rank gain for a user\n:rtype: float', deprecated=None, examples=None, json_schema_extra=None, repr=True)}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'data': FieldInfo(annotation=list[int], required=True), 'mode': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.user.UserRelation¶

target_id: int¶

relation_type: str¶

mutual: bool¶

target: User | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'mutual': FieldInfo(annotation=bool, required=True), 'relation_type': FieldInfo(annotation=str, required=True), 'target': FieldInfo(annotation=Union[User, NoneType], required=False, default=None), 'target_id': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.user.UserStats¶

Fields are marked as optional since they might be missing from rankings other than performance.

ranked_score: int | None¶

play_count: int | None¶

grade_counts: UserGradeCounts | None¶

total_hits: int | None¶

is_ranked: bool | None¶

total_score: int | None¶

level: UserLevel | None¶

hit_accuracy: float | None¶

play_time: int | None¶

pp: float | None¶

pp_exp: float | None¶

replays_watched_by_others: int | None¶

maximum_combo: int | None¶

global_rank: int | None¶

global_rank_exp: int | None¶

country_rank: int | None¶

user: User | None¶

count_300: int | None¶

count_100: int | None¶

count_50: int | None¶

count_miss: int | None¶

variants: list[UserStatsVariant] | None¶

property pp_per_playtime: float¶

PP per playtime.

Returns:: PP per playtime
Return type:: float

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {'pp_per_playtime': ComputedFieldInfo(wrapped_property=<functools.cached_property object>, return_type=PydanticUndefined, alias=None, alias_priority=None, title=None, description='PP per playtime.\n\n:return: PP per playtime\n:rtype: float', deprecated=None, examples=None, json_schema_extra=None, repr=True)}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'count_100': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'count_300': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'count_50': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'count_miss': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'country_rank': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'global_rank': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'global_rank_exp': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'grade_counts': FieldInfo(annotation=Union[UserGradeCounts, NoneType], required=False, default=None), 'hit_accuracy': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'is_ranked': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'level': FieldInfo(annotation=Union[UserLevel, NoneType], required=False, default=None), 'maximum_combo': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'play_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'play_time': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'pp': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'pp_exp': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'ranked_score': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'replays_watched_by_others': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'total_hits': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'total_score': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'user': FieldInfo(annotation=Union[User, NoneType], required=False, default=None), 'variants': FieldInfo(annotation=Union[list[UserStatsVariant], NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.user.UserStatsRulesets¶

osu: UserStats | None¶

taiko: UserStats | None¶

fruits: UserStats | None¶

mania: UserStats | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'fruits': FieldInfo(annotation=Union[UserStats, NoneType], required=False, default=None), 'mania': FieldInfo(annotation=Union[UserStats, NoneType], required=False, default=None), 'osu': FieldInfo(annotation=Union[UserStats, NoneType], required=False, default=None), 'taiko': FieldInfo(annotation=Union[UserStats, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.user.UserStatsVariant(*, mode: Gamemode, variant: str, pp: float, country_rank: int | None = None, global_rank: int | None = None)¶

mode: Gamemode¶

variant: str¶

pp: float¶

country_rank: int | None¶

global_rank: int | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'country_rank': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'global_rank': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'mode': FieldInfo(annotation=Gamemode, required=True), 'pp': FieldInfo(annotation=float, required=True), 'variant': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

Beatmap¶

This module contains models for Beatmap objects.

class aiosu.models.beatmap.Beatmap¶

id: int¶

url: str¶

mode: Gamemode¶

beatmapset_id: int¶

difficulty_rating: float¶

status: BeatmapRankStatus¶

total_length: int¶

user_id: int¶

version: str¶

accuracy: float | None¶

ar: float | None¶

cs: float | None¶

bpm: float | None¶

convert: bool | None¶

count_circles: int | None¶

count_sliders: int | None¶

count_spinners: int | None¶

deleted_at: datetime | None¶

drain: float | None¶

hit_length: int | None¶

is_scoreable: bool | None¶

last_updated: datetime | None¶

passcount: int | None¶

play_count: int | None¶

checksum: str | None¶

max_combo: int | None¶

beatmapset: Beatmapset | None¶

failtimes: BeatmapFailtimes | None¶

property discussion_url: str¶

property count_objects: int | None¶

Total count of the objects.

Returns:: Sum of counts of all objects. None if no object count information.
Return type:: Optional[int]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {'count_objects': ComputedFieldInfo(wrapped_property=<functools.cached_property object>, return_type=PydanticUndefined, alias=None, alias_priority=None, title=None, description='Total count of the objects.\n\n:return: Sum of counts of all objects. None if no object count information.\n:rtype: Optional[int]', deprecated=None, examples=None, json_schema_extra=None, repr=True)}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'accuracy': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'ar': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'beatmapset': FieldInfo(annotation=Union[Beatmapset, NoneType], required=False, default=None), 'beatmapset_id': FieldInfo(annotation=int, required=True), 'bpm': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'checksum': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'convert': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'count_circles': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'count_sliders': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'count_spinners': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'cs': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'deleted_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'difficulty_rating': FieldInfo(annotation=float, required=True), 'drain': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'failtimes': FieldInfo(annotation=Union[BeatmapFailtimes, NoneType], required=False, default=None), 'hit_length': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'is_scoreable': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'last_updated': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'max_combo': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'mode': FieldInfo(annotation=Gamemode, required=True), 'passcount': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'play_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None, alias='playcount', alias_priority=2), 'status': FieldInfo(annotation=BeatmapRankStatus, required=True), 'total_length': FieldInfo(annotation=int, required=True), 'url': FieldInfo(annotation=str, required=True), 'user_id': FieldInfo(annotation=int, required=True), 'version': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapAvailability(*, more_information: str | None = None, download_disabled: bool | None = None)¶

more_information: str | None¶

download_disabled: bool | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'download_disabled': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'more_information': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapCovers(*, cover: str, card: str, list: str, slimcover: str, cover_2_x: str | None = None, card_2_x: str | None = None, list_2_x: str | None = None, slimcover_2_x: str | None = None)¶

cover: str¶

card: str¶

list: str¶

slimcover: str¶

cover_2_x: str | None¶

card_2_x: str | None¶

list_2_x: str | None¶

slimcover_2_x: str | None¶

classmethod from_beatmapset_id(beatmapset_id: int) → BeatmapCovers¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'card': FieldInfo(annotation=str, required=True), 'card_2_x': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='card@2x', alias_priority=2), 'cover': FieldInfo(annotation=str, required=True), 'cover_2_x': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='cover@2x', alias_priority=2), 'list': FieldInfo(annotation=str, required=True), 'list_2_x': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='list@2x', alias_priority=2), 'slimcover': FieldInfo(annotation=str, required=True), 'slimcover_2_x': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='slimcover@2x', alias_priority=2)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapDescription(*, bbcode: str | None = None, description: str | None = None)¶

bbcode: str | None¶

description: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'bbcode': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapDifficultyAttributes(*, max_combo: int, star_rating: float, aim_difficulty: float | None = None, approach_rate: float | None = None, flashlight_difficulty: float | None = None, overall_difficulty: float | None = None, slider_factor: float | None = None, speed_difficulty: float | None = None, speed_note_count: float | None = None, stamina_difficulty: float | None = None, rhythm_difficulty: float | None = None, colour_difficulty: float | None = None, great_hit_window: float | None = None, score_multiplier: float | None = None)¶

max_combo: int¶

star_rating: float¶

aim_difficulty: float | None¶

approach_rate: float | None¶

flashlight_difficulty: float | None¶

overall_difficulty: float | None¶

slider_factor: float | None¶

speed_difficulty: float | None¶

speed_note_count: float | None¶

stamina_difficulty: float | None¶

rhythm_difficulty: float | None¶

colour_difficulty: float | None¶

great_hit_window: float | None¶

score_multiplier: float | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'aim_difficulty': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'approach_rate': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'colour_difficulty': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'flashlight_difficulty': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'great_hit_window': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'max_combo': FieldInfo(annotation=int, required=True), 'overall_difficulty': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'rhythm_difficulty': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'score_multiplier': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'slider_factor': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'speed_difficulty': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'speed_note_count': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'stamina_difficulty': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'star_rating': FieldInfo(annotation=float, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapFailtimes(*, exit: list[int] | None = None, fail: list[int] | None = None)¶

exit: list[int] | None¶

fail: list[int] | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'exit': FieldInfo(annotation=Union[list[int], NoneType], required=False, default=None), 'fail': FieldInfo(annotation=Union[list[int], NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapGenre(*, name: str, id: int | None = None)¶

name: str¶

id: int | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'name': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapHype(*, current: int, required: int)¶

current: int¶

required: int¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'current': FieldInfo(annotation=int, required=True), 'required': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapLanguage(*, name: str, id: int | None = None)¶

name: str¶

id: int | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'name': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapNominations(*, current: int | None = None, required: int | None = None)¶

current: int | None¶

required: int | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'current': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'required': FieldInfo(annotation=Union[int, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapPack(*, author: str, date: datetime, name: str, no_diff_reduction: bool, tag: str, url: str, ruleset_id: int | None = None, beatmapsets: list[Beatmapset] | None = None, user_completion_data: BeatmapPackUserCompletion | None = None)¶

author: str¶

date: datetime¶

name: str¶

no_diff_reduction: bool¶

tag: str¶

url: str¶

ruleset_id: int | None¶

beatmapsets: list[Beatmapset] | None¶

user_completion_data: BeatmapPackUserCompletion | None¶

property mode: Gamemode | None¶

property pack_type: BeatmapPackType¶

property id: int¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'author': FieldInfo(annotation=str, required=True), 'beatmapsets': FieldInfo(annotation=Union[list[Beatmapset], NoneType], required=False, default=None), 'date': FieldInfo(annotation=datetime, required=True), 'name': FieldInfo(annotation=str, required=True), 'no_diff_reduction': FieldInfo(annotation=bool, required=True), 'ruleset_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'tag': FieldInfo(annotation=str, required=True), 'url': FieldInfo(annotation=str, required=True), 'user_completion_data': FieldInfo(annotation=Union[BeatmapPackUserCompletion, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapPackType(value)¶

An enumeration.

STANDARD = ('S', 'Standard')¶

FEATURED = ('F', 'Featured Artist')¶

TOURNAMENT = ('P', 'Tournament')¶

LOVED = ('L', 'Project Loved')¶

CHART = ('R', 'Spotlights')¶

THEME = ('T', 'Theme')¶

ARTIST = ('A', 'Artist/Album')¶

classmethod from_tag(tag: str) → BeatmapPackType¶

class aiosu.models.beatmap.BeatmapPackUserCompletion(*, beatmapset_ids: list[int], completed: bool)¶

beatmapset_ids: list[int]¶

completed: bool¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'beatmapset_ids': FieldInfo(annotation=list[int], required=True), 'completed': FieldInfo(annotation=bool, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapPacksResponse(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None, beatmap_packs: list[BeatmapPack])¶

beatmap_packs: list[BeatmapPack]¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'beatmap_packs': FieldInfo(annotation=list[BeatmapPack], required=True), 'cursor_string': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'next': FieldInfo(annotation=Union[partial[Coroutine[object, object, CursorModel]], NoneType], required=False, default=None, exclude=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

class aiosu.models.beatmap.BeatmapRankStatus(value)¶

An enumeration.

GRAVEYARD = -2¶

WIP = -1¶

PENDING = 0¶

RANKED = 1¶

APPROVED = 2¶

QUALIFIED = 3¶

LOVED = 4¶

property id: int¶

property name_api: str¶

class aiosu.models.beatmap.BeatmapUserPlaycount¶

count: int¶

beatmap_id: int¶

beatmap: Beatmap | None¶

beatmapset: Beatmapset | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.Beatmapset¶

id: int¶

artist: str¶

artist_unicode: str¶

covers: BeatmapCovers¶

creator: str¶

favourite_count: int¶

play_count: int¶

preview_url: str¶

source: str¶

status: BeatmapRankStatus¶

title: str¶

title_unicode: str¶

user_id: int¶

video: bool¶

nsfw: bool | None¶

hype: BeatmapHype | None¶

availability: BeatmapAvailability | None¶

bpm: float | None¶

can_be_hyped: bool | None¶

discussion_enabled: bool | None¶

discussion_locked: bool | None¶

is_scoreable: bool | None¶

last_updated: datetime | None¶

legacy_thread_url: str | None¶

nominations: BeatmapNominations | None¶

current_nominations: list[BeatmapNomination] | None¶

ranked_date: datetime | None¶

storyboard: bool | None¶

submitted_date: datetime | None¶

tags: str | None¶

pack_tags: list[str] | None¶

track_id: int | None¶

user: User | None¶

related_users: list[User] | None¶

current_user_attributes: CurrentUserAttributes | None¶

description: BeatmapDescription | None¶

genre: BeatmapGenre | None¶

language: BeatmapLanguage | None¶

ratings: list[int] | None¶

recent_favourites: list[User] | None¶

discussions: list[BeatmapsetDiscussion] | None¶

events: list[BeatmapsetEvent] | None¶

has_favourited: bool | None¶

beatmaps: list[Beatmap] | None¶

converts: list[Beatmap] | None¶

property url: str¶

property discussion_url: str¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {'discussion_url': ComputedFieldInfo(wrapped_property=<property object>, return_type=PydanticUndefined, alias=None, alias_priority=None, title=None, description=None, deprecated=None, examples=None, json_schema_extra=None, repr=True), 'url': ComputedFieldInfo(wrapped_property=<property object>, return_type=PydanticUndefined, alias=None, alias_priority=None, title=None, description=None, deprecated=None, examples=None, json_schema_extra=None, repr=True)}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'artist': FieldInfo(annotation=str, required=True), 'artist_unicode': FieldInfo(annotation=str, required=True), 'availability': FieldInfo(annotation=Union[BeatmapAvailability, NoneType], required=False, default=None), 'beatmaps': FieldInfo(annotation=Union[list[Beatmap], NoneType], required=False, default=None), 'bpm': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'can_be_hyped': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'converts': FieldInfo(annotation=Union[list[Beatmap], NoneType], required=False, default=None), 'covers': FieldInfo(annotation=BeatmapCovers, required=True), 'creator': FieldInfo(annotation=str, required=True), 'current_nominations': FieldInfo(annotation=Union[list[BeatmapNomination], NoneType], required=False, default=None), 'current_user_attributes': FieldInfo(annotation=Union[CurrentUserAttributes, NoneType], required=False, default=None), 'description': FieldInfo(annotation=Union[BeatmapDescription, NoneType], required=False, default=None), 'discussion_enabled': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'discussion_locked': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'discussions': FieldInfo(annotation=Union[list[BeatmapsetDiscussion], NoneType], required=False, default=None), 'events': FieldInfo(annotation=Union[list[BeatmapsetEvent], NoneType], required=False, default=None), 'favourite_count': FieldInfo(annotation=int, required=True), 'genre': FieldInfo(annotation=Union[BeatmapGenre, NoneType], required=False, default=None), 'has_favourited': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'hype': FieldInfo(annotation=Union[BeatmapHype, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'is_scoreable': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'language': FieldInfo(annotation=Union[BeatmapLanguage, NoneType], required=False, default=None), 'last_updated': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'legacy_thread_url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'nominations': FieldInfo(annotation=Union[BeatmapNominations, NoneType], required=False, default=None), 'nsfw': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'pack_tags': FieldInfo(annotation=Union[list[str], NoneType], required=False, default=None), 'play_count': FieldInfo(annotation=int, required=True, alias='playcount', alias_priority=2), 'preview_url': FieldInfo(annotation=str, required=True), 'ranked_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'ratings': FieldInfo(annotation=Union[list[int], NoneType], required=False, default=None), 'recent_favourites': FieldInfo(annotation=Union[list[User], NoneType], required=False, default=None), 'related_users': FieldInfo(annotation=Union[list[User], NoneType], required=False, default=None), 'source': FieldInfo(annotation=str, required=True), 'status': FieldInfo(annotation=BeatmapRankStatus, required=True), 'storyboard': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'submitted_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'tags': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'title': FieldInfo(annotation=str, required=True), 'title_unicode': FieldInfo(annotation=str, required=True), 'track_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'user': FieldInfo(annotation=Union[User, NoneType], required=False, default=None), 'user_id': FieldInfo(annotation=int, required=True), 'video': FieldInfo(annotation=bool, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapsetDiscussion(*, id: int, beatmapset_id: int, user_id: int, message_type: Literal['hype', 'praise', 'problem', 'review', 'suggestion', 'mapper_note'], resolved: bool, can_be_resolved: bool, can_grant_kudosu: bool, created_at: datetime, beatmap_id: int | None = None, deleted_by_id: int | None = None, parent_id: int | None = None, timestamp: int | None = None, updated_at: datetime | None = None, deleted_at: datetime | None = None, last_post_at: datetime | None = None, kudosu_denied: bool | None = None, starting_post: BeatmapsetDiscussionPost | None = None)¶

id: int¶

beatmapset_id: int¶

user_id: int¶

message_type: BeatmapsetDisscussionType¶

resolved: bool¶

can_be_resolved: bool¶

can_grant_kudosu: bool¶

created_at: datetime¶

beatmap_id: int | None¶

deleted_by_id: int | None¶

parent_id: int | None¶

timestamp: int | None¶

updated_at: datetime | None¶

deleted_at: datetime | None¶

last_post_at: datetime | None¶

kudosu_denied: bool | None¶

starting_post: BeatmapsetDiscussionPost | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'beatmap_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'beatmapset_id': FieldInfo(annotation=int, required=True), 'can_be_resolved': FieldInfo(annotation=bool, required=True), 'can_grant_kudosu': FieldInfo(annotation=bool, required=True), 'created_at': FieldInfo(annotation=datetime, required=True), 'deleted_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'deleted_by_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'kudosu_denied': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'last_post_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'message_type': FieldInfo(annotation=Literal['hype', 'praise', 'problem', 'review', 'suggestion', 'mapper_note'], required=True), 'parent_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'resolved': FieldInfo(annotation=bool, required=True), 'starting_post': FieldInfo(annotation=Union[BeatmapsetDiscussionPost, NoneType], required=False, default=None), 'timestamp': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'updated_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'user_id': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapsetDiscussionPost(*, id: int, user_id: int, system: bool, message: str, created_at: datetime, beatmap_discussion_id: int | None = None, last_editor_id: int | None = None, deleted_by_id: int | None = None, updated_at: datetime | None = None, deleted_at: datetime | None = None)¶

id: int¶

user_id: int¶

system: bool¶

message: str¶

created_at: datetime¶

beatmap_discussion_id: int | None¶

last_editor_id: int | None¶

deleted_by_id: int | None¶

updated_at: datetime | None¶

deleted_at: datetime | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'beatmap_discussion_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'created_at': FieldInfo(annotation=datetime, required=True), 'deleted_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'deleted_by_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'last_editor_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'message': FieldInfo(annotation=str, required=True), 'system': FieldInfo(annotation=bool, required=True), 'updated_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'user_id': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapsetDiscussionPostResponse(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None, beatmapsets: list[Beatmapset], posts: list[BeatmapsetDiscussionPost], users: list[User])¶

beatmapsets: list[Beatmapset]¶

posts: list[BeatmapsetDiscussionPost]¶

users: list[User]¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'beatmapsets': FieldInfo(annotation=list[Beatmapset], required=True), 'cursor_string': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'next': FieldInfo(annotation=Union[partial[Coroutine[object, object, CursorModel]], NoneType], required=False, default=None, exclude=True), 'posts': FieldInfo(annotation=list[BeatmapsetDiscussionPost], required=True), 'users': FieldInfo(annotation=list[User], required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

class aiosu.models.beatmap.BeatmapsetDiscussionResponse(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None, beatmaps: list[Beatmap], discussions: list[BeatmapsetDiscussion], included_discussions: list[BeatmapsetDiscussion], users: list[User], max_blocks: int)¶

beatmaps: list[Beatmap]¶

discussions: list[BeatmapsetDiscussion]¶

included_discussions: list[BeatmapsetDiscussion]¶

users: list[User]¶

max_blocks: int¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'beatmaps': FieldInfo(annotation=list[Beatmap], required=True), 'cursor_string': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'discussions': FieldInfo(annotation=list[BeatmapsetDiscussion], required=True), 'included_discussions': FieldInfo(annotation=list[BeatmapsetDiscussion], required=True), 'max_blocks': FieldInfo(annotation=int, required=True), 'next': FieldInfo(annotation=Union[partial[Coroutine[object, object, CursorModel]], NoneType], required=False, default=None, exclude=True), 'users': FieldInfo(annotation=list[User], required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

class aiosu.models.beatmap.BeatmapsetDiscussionVoteResponse(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None, votes: list[BeatmapsetVoteEvent], discussions: list[BeatmapsetDiscussion], users: list[User])¶

votes: list[BeatmapsetVoteEvent]¶

discussions: list[BeatmapsetDiscussion]¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'cursor_string': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'discussions': FieldInfo(annotation=list[BeatmapsetDiscussion], required=True), 'next': FieldInfo(annotation=Union[partial[Coroutine[object, object, CursorModel]], NoneType], required=False, default=None, exclude=True), 'users': FieldInfo(annotation=list[User], required=True), 'votes': FieldInfo(annotation=list[BeatmapsetVoteEvent], required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

users: list[User]¶

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

class aiosu.models.beatmap.BeatmapsetEvent(*, id: int, type: Literal['approve', 'beatmap_owner_change', 'discussion_delete', 'discussion_post_delete', 'discussion_post_restore', 'discussion_restore', 'discussion_lock', 'discussion_unlock', 'disqualify', 'genre_edit', 'issue_reopen', 'issue_resolve', 'kudosu_allow', 'kudosu_deny', 'kudosu_gain', 'kudosu_lost', 'kudosu_recalculate', 'language_edit', 'love', 'nominate', 'nomination_reset', 'nomination_reset_received', 'nsfw_toggle', 'offset_edit', 'qualify', 'rank', 'remove_from_loved'], created_at: datetime, user_id: int | None = None, beatmapset: Beatmapset | None = None, discussion: BeatmapsetDiscussion | None = None, comment: dict | None = None)¶

id: int¶

type: BeatmapsetEventType¶: Information on types: https://github.com/ppy/osu-web/blob/master/resources/js/interfaces/beatmapset-event-json.ts

created_at: datetime¶

user_id: int | None¶

beatmapset: Beatmapset | None¶

discussion: BeatmapsetDiscussion | None¶

comment: dict | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'beatmapset': FieldInfo(annotation=Union[Beatmapset, NoneType], required=False, default=None), 'comment': FieldInfo(annotation=Union[dict, NoneType], required=False, default=None), 'created_at': FieldInfo(annotation=datetime, required=True), 'discussion': FieldInfo(annotation=Union[BeatmapsetDiscussion, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'type': FieldInfo(annotation=Literal['approve', 'beatmap_owner_change', 'discussion_delete', 'discussion_post_delete', 'discussion_post_restore', 'discussion_restore', 'discussion_lock', 'discussion_unlock', 'disqualify', 'genre_edit', 'issue_reopen', 'issue_resolve', 'kudosu_allow', 'kudosu_deny', 'kudosu_gain', 'kudosu_lost', 'kudosu_recalculate', 'language_edit', 'love', 'nominate', 'nomination_reset', 'nomination_reset_received', 'nsfw_toggle', 'offset_edit', 'qualify', 'rank', 'remove_from_loved'], required=True), 'user_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

beatmap_discussion_id: int | None¶

beatmap_discussion_post_id: int | None¶

new_vote: BeatmapsetVoteEvent | None¶

votes: list[BeatmapsetVoteEvent] | None¶

mode: Gamemode | None¶

reason: str | None¶

source_user_id: int | None¶

source_user_username: str | None¶

nominator_ids: list[int] | None¶

new: str | None¶

old: str | None¶

new_user_id: int | None¶

new_user_username: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'beatmap_discussion_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'beatmap_discussion_post_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'mode': FieldInfo(annotation=Union[Gamemode, NoneType], required=False, default=None), 'new': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'new_user_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'new_user_username': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'new_vote': FieldInfo(annotation=Union[BeatmapsetVoteEvent, NoneType], required=False, default=None), 'nominator_ids': FieldInfo(annotation=Union[list[int], NoneType], required=False, default=None), 'old': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'reason': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'source_user_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'source_user_username': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'votes': FieldInfo(annotation=Union[list[BeatmapsetVoteEvent], NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.beatmap.BeatmapsetGenre(value)¶

An enumeration.

UNSPECIFIED = 1¶

VIDEO_GAME = 2¶

ANIME = 3¶

ROCK = 4¶

POP = 5¶

OTHER = 6¶

NOVELTY = 7¶

HIP_HOP = 9¶

ELECTRONIC = 10¶

METAL = 11¶

CLASSICAL = 12¶

FOLK = 13¶

JAZZ = 14¶

class aiosu.models.beatmap.BeatmapsetLanguage(value)¶

An enumeration.

UNSPECIFIED = 1¶

ENGLISH = 2¶

JAPANESE = 3¶

CHINESE = 4¶

INSTRUMENTAL = 5¶

KOREAN = 6¶

FRENCH = 7¶

GERMAN = 8¶

SWEDISH = 9¶

SPANISH = 10¶

ITALIAN = 11¶

RUSSIAN = 12¶

POLISH = 13¶

OTHER = 14¶

class aiosu.models.beatmap.BeatmapsetSearchResponse(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None)¶

beatmapsets: list[Beatmapset]¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

class aiosu.models.beatmap.BeatmapsetVoteEvent(*, score: int, user_id: int, id: int | None = None, created_at: datetime | None = None, updated_at: datetime | None = None, beatmapset_discussion_id: int | None = None)¶

score: int¶

user_id: int¶

id: int | None¶

created_at: datetime | None¶

updated_at: datetime | None¶

beatmapset_discussion_id: int | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'beatmapset_discussion_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'created_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'score': FieldInfo(annotation=int, required=True), 'updated_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'user_id': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

aiosu.models.beatmap.BeatmapsetCategory¶: alias of Literal[‘any’, ‘leaderboard’, ‘ranked’, ‘qualified’, ‘loved’, ‘favourites’, ‘pending’, ‘wip’, ‘graveyard’, ‘mine’]

aiosu.models.beatmap.BeatmapsetDisscussionType¶: alias of Literal[‘hype’, ‘praise’, ‘problem’, ‘review’, ‘suggestion’, ‘mapper_note’]

aiosu.models.beatmap.BeatmapsetEventType¶: alias of Literal[‘approve’, ‘beatmap_owner_change’, ‘discussion_delete’, ‘discussion_post_delete’, ‘discussion_post_restore’, ‘discussion_restore’, ‘discussion_lock’, ‘discussion_unlock’, ‘disqualify’, ‘genre_edit’, ‘issue_reopen’, ‘issue_resolve’, ‘kudosu_allow’, ‘kudosu_deny’, ‘kudosu_gain’, ‘kudosu_lost’, ‘kudosu_recalculate’, ‘language_edit’, ‘love’, ‘nominate’, ‘nomination_reset’, ‘nomination_reset_received’, ‘nsfw_toggle’, ‘offset_edit’, ‘qualify’, ‘rank’, ‘remove_from_loved’]

aiosu.models.beatmap.BeatmapsetRequestStatus¶: alias of Literal[‘all’, ‘ranked’, ‘qualified’, ‘disqualified’, ‘never_ranked’]

aiosu.models.beatmap.BeatmapsetBundleFilterType¶: alias of Literal[‘any’, ‘currently’, ‘previously’, ‘never’]

aiosu.models.beatmap.BeatmapsetSortType¶: alias of Literal[‘title_asc’, ‘title_desc’, ‘artist_asc’, ‘artist_desc’, ‘difficulty_asc’, ‘difficulty_desc’, ‘ranked_asc’, ‘ranked_desc’, ‘rating_asc’, ‘rating_desc’, ‘plays_asc’, ‘plays_desc’, ‘favourites_asc’, ‘favourites_desc’]

aiosu.models.beatmap.BeatmapsetGenre = <enum 'BeatmapsetGenre'>¶: An enumeration.

aiosu.models.beatmap.BeatmapsetLanguage = <enum 'BeatmapsetLanguage'>¶: An enumeration.

aiosu.models.beatmap.BeatmapsetDiscussionVoteScoreType¶: alias of Literal[‘1’, ‘-1’]

aiosu.models.beatmap.UserBeatmapType¶: alias of Literal[‘favourite’, ‘graveyard’, ‘loved’, ‘ranked’, ‘pending’]

Score¶

This module contains models for Score objects.

class aiosu.models.score.Score(*, user_id: int, accuracy: float, mods: Mods, score: int, max_combo: int, passed: bool, perfect: bool, statistics: ScoreStatistics, rank: str, created_at: datetime, mode: Gamemode, replay: bool, type: Literal['solo_score', 'score_best_osu', 'score_best_taiko', 'score_best_fruits', 'score_best_mania', 'score_osu', 'score_taiko', 'score_fruits', 'score_mania', 'legacy_match_score'] = 'solo_score', id: int | None = None, pp: float | None = 0, best_id: int | None = None, beatmap: Beatmap | None = None, beatmapset: Beatmapset | None = None, weight: ScoreWeight | None = None, user: User | None = None, rank_global: int | None = None, rank_country: int | None = None, current_user_attributes: CurrentUserAttributes | None = None, beatmap_id: int | None = None)¶

user_id: int¶

accuracy: float¶

mods: Mods¶

score: int¶

max_combo: int¶

passed: bool¶

perfect: bool¶

statistics: ScoreStatistics¶

rank: str¶

created_at: datetime¶

mode: Gamemode¶

replay: bool¶

type: ScoreType¶

id: int | None¶: Always present except for API v1 recent scores.

pp: float | None¶

best_id: int | None¶

beatmap: Beatmap | None¶

beatmapset: Beatmapset | None¶

weight: ScoreWeight | None¶

user: User | None¶

rank_global: int | None¶

rank_country: int | None¶

current_user_attributes: CurrentUserAttributes | None¶

beatmap_id: int | None¶: Only present on API v1

property score_url: str | None¶

Link to the score.

Returns:: Link to the score on the osu! website
Return type:: Optional[str]

property replay_url: str | None¶

Link to the replay.

Returns:: Link to download the replay on the osu! website
Return type:: Optional[str]

property completion: float | None¶

Beatmap completion.

Raises:: ValueError – If mode is unknown
Returns:: Beatmap completion of a score (%). 100% for passes. None if no beatmap.
Return type:: Optional[float]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {'completion': ComputedFieldInfo(wrapped_property=<functools.cached_property object>, return_type=typing.Optional[float], alias=None, alias_priority=None, title=None, description='Beatmap completion.\n\n:raises ValueError: If mode is unknown\n:return: Beatmap completion of a score (%). 100% for passes. None if no beatmap.\n:rtype: Optional[float]', deprecated=None, examples=None, json_schema_extra=None, repr=True)}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

async request_beatmap(client: v1.Client) → None¶

For v1 Scores: requests the beatmap from the API and sets it.

Parameters:: client (aiosu.v1.client.Client) – An API v1 Client

class aiosu.models.score.ScoreStatistics(*, count_miss: int, count_50: int, count_100: int, count_300: int, count_geki: int, count_katu: int)¶

count_miss: int¶

count_50: int¶

count_100: int¶

count_300: int¶

count_geki: int¶

count_katu: int¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'count_100': FieldInfo(annotation=int, required=True), 'count_300': FieldInfo(annotation=int, required=True), 'count_50': FieldInfo(annotation=int, required=True), 'count_geki': FieldInfo(annotation=int, required=True), 'count_katu': FieldInfo(annotation=int, required=True), 'count_miss': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.score.ScoreWeight(*, percentage: float, pp: float)¶

percentage: float¶

pp: float¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'percentage': FieldInfo(annotation=float, required=True), 'pp': FieldInfo(annotation=float, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

aiosu.models.score.calculate_score_completion(mode: Gamemode, statistics: ScoreStatistics, beatmap: Beatmap) → float | None¶

Calculates completion for a score.

Parameters:

mode (aiosu.models.gamemode.Gamemode) – The gamemode of the score
statistics (aiosu.models.score.ScoreStatistics) – The statistics of the score
beatmap (aiosu.models.beatmap.Beatmap) – The beatmap of the score

Raises:

ValueError – If the gamemode is unknown

Returns:

Completion for the given score

Return type:

Optional[float]

Replay¶

This module contains models for replays.

class aiosu.models.files.replay.ReplayEvent(*, time: int, x: float, y: float, keys: ReplayKey)¶

Replay event data.

time: int¶

x: float¶

y: float¶

keys: ReplayKey¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'keys': FieldInfo(annotation=ReplayKey, required=True), 'time': FieldInfo(annotation=int, required=True), 'x': FieldInfo(annotation=float, required=True), 'y': FieldInfo(annotation=float, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.files.replay.ReplayFile(*, mode: Gamemode, version: int, map_md5: str, player_name: str, played_at: datetime, replay_md5: str, online_id: int, score: int, max_combo: int, perfect_combo: bool, mods: Mods, statistics: ScoreStatistics, replay_data: list[ReplayEvent], lifebar_data: list[ReplayLifebarEvent], mod_extras: float | None = None, skip_offset: int | None = None, rng_seed: int | None = None, lazer_replay_data: LazerReplayData | None = None)¶

Replay file data.

mode: Gamemode¶

version: int¶

map_md5: str¶

player_name: str¶

played_at: datetime¶

replay_md5: str¶

online_id: int¶

score: int¶

max_combo: int¶

perfect_combo: bool¶

mods: Mods¶

statistics: ScoreStatistics¶

replay_data: list[ReplayEvent]¶

lifebar_data: list[ReplayLifebarEvent]¶

mod_extras: float | None¶

skip_offset: int | None¶

rng_seed: int | None¶

lazer_replay_data: LazerReplayData | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'lazer_replay_data': FieldInfo(annotation=Union[LazerReplayData, NoneType], required=False, default=None), 'lifebar_data': FieldInfo(annotation=list[ReplayLifebarEvent], required=True), 'map_md5': FieldInfo(annotation=str, required=True), 'max_combo': FieldInfo(annotation=int, required=True), 'mod_extras': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'mode': FieldInfo(annotation=Gamemode, required=True), 'mods': FieldInfo(annotation=Mods, required=True), 'online_id': FieldInfo(annotation=int, required=True), 'perfect_combo': FieldInfo(annotation=bool, required=True), 'played_at': FieldInfo(annotation=datetime, required=True), 'player_name': FieldInfo(annotation=str, required=True), 'replay_data': FieldInfo(annotation=list[ReplayEvent], required=True), 'replay_md5': FieldInfo(annotation=str, required=True), 'rng_seed': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'score': FieldInfo(annotation=int, required=True), 'skip_offset': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'statistics': FieldInfo(annotation=ScoreStatistics, required=True), 'version': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.files.replay.ReplayKey(value)¶

Replay key data.

K1 = 1¶

K2 = 2¶

K3 = 4¶

K4 = 8¶

K5 = 16¶

K6 = 32¶

K7 = 64¶

K8 = 128¶

K9 = 256¶

K10 = 512¶

K11 = 1024¶

K12 = 2048¶

K13 = 4096¶

K14 = 8192¶

K15 = 16384¶

K16 = 32768¶

K17 = 65536¶

K18 = 131072¶

conjugate()¶: Returns self, the complex conjugate of any int.

bit_length()¶

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

to_bytes(length, byteorder, *, signed=False)¶

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)¶

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()¶

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real¶: the real part of a complex number

imag¶: the imaginary part of a complex number

numerator¶: the numerator of a rational number in lowest terms

denominator¶: the denominator of a rational number in lowest terms

class aiosu.models.files.replay.ReplayLifebarEvent(*, time: int, hp: float)¶

Replay lifebar event data.

time: int¶

hp: float¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'hp': FieldInfo(annotation=float, required=True), 'time': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

Mods¶

This module contains models for mods.

class aiosu.models.mods.Mod(value)¶

Bitwise Flags representing osu! mods.

NoMod = 0¶

NoFail = 1¶

Easy = 2¶

TouchDevice = 4¶

Hidden = 8¶

HardRock = 16¶

SuddenDeath = 32¶

DoubleTime = 64¶

Relax = 128¶

HalfTime = 256¶

Nightcore = 512¶: Only set along with DoubleTime. i.e: NC only gives 576

Flashlight = 1024¶

Autoplay = 2048¶

SpunOut = 4096¶

Autopilot = 8192¶: Called Relax2 on osu! API documentation

Perfect = 16384¶: Only set along with SuddenDeath. i.e: PF only gives 16416

Key4 = 32768¶

Key5 = 65536¶

Key6 = 131072¶

Key7 = 262144¶

Key8 = 524288¶

FadeIn = 1048576¶

Random = 2097152¶

Cinema = 4194304¶

Target = 8388608¶

Key9 = 16777216¶

KeyCoop = 33554432¶

Key1 = 67108864¶

Key3 = 134217728¶

Key2 = 268435456¶

ScoreV2 = 536870912¶

Mirror = 1073741824¶

property bitmask: int¶

property short_name: str¶

classmethod from_type(_Mod__o: object) → Mod¶

Get a Mod from a string or int.

Parameters:: __o (object) – The string or int to get the Mod from
Returns:: The Mod
Return type:: Mod
Raises:: ValueError – If the Mod does not exist

conjugate()¶: Returns self, the complex conjugate of any int.

bit_length()¶

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

to_bytes(length, byteorder, *, signed=False)¶

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)¶

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()¶

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real¶: the real part of a complex number

imag¶: the imaginary part of a complex number

numerator¶: the numerator of a rational number in lowest terms

denominator¶: the denominator of a rational number in lowest terms

class aiosu.models.mods.Mods(mods: list[str] | str | int)¶

List of Mod objects

property bitwise: int¶

Bitwise representation.

Returns:: Bitwise representation of the mod combination
Return type:: int

append(item)¶: S.append(value) – append value to the end of the sequence

clear() → None -- remove all items from S¶

copy()¶

count(value) → integer -- return number of occurrences of value¶

extend(other)¶: S.extend(iterable) – extend sequence by appending elements from the iterable

index(value[, start[, stop]]) → integer -- return first index of value.¶

Raises ValueError if the value is not present.

Supporting start and stop arguments is optional, but recommended.

insert(i, item)¶: S.insert(index, value) – insert value before index

pop([index]) → item -- remove and return item at index (default last).¶: Raise IndexError if list is empty or index is out of range.

remove(item)¶: S.remove(value) – remove first occurrence of value. Raise ValueError if the value is not present.

reverse()¶: S.reverse() – reverse IN PLACE

sort(*args, **kwds)¶

aiosu.models.mods.KeyMod = 521109504¶

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by ‘+’ or ‘-’ and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal. >>> int(‘0b100’, base=0) 4

aiosu.models.mods.FreemodAllowed = 1598026939¶

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero.

aiosu.models.mods.ScoreIncreaseMods = 1112¶

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero.

aiosu.models.mods.SpeedChangingMods = 832¶

int([x]) -> integer int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero.

Performance¶

This module contains models for API v2 difficulty attribute objects.

class aiosu.models.performance.CatchPerformanceAttributes(*, total: float)¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'total': FieldInfo(annotation=float, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

total: float¶

class aiosu.models.performance.ManiaPerformanceAttributes(*, total: float, difficulty: float)¶

difficulty: float¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'difficulty': FieldInfo(annotation=float, required=True), 'total': FieldInfo(annotation=float, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

total: float¶

class aiosu.models.performance.OsuPerformanceAttributes(*, total: float, aim: float, speed: float, accuracy: float, flashlight: float, effective_miss_count: float)¶

aim: float¶

speed: float¶

accuracy: float¶

flashlight: float¶

effective_miss_count: float¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'accuracy': FieldInfo(annotation=float, required=True), 'aim': FieldInfo(annotation=float, required=True), 'effective_miss_count': FieldInfo(annotation=float, required=True), 'flashlight': FieldInfo(annotation=float, required=True), 'speed': FieldInfo(annotation=float, required=True), 'total': FieldInfo(annotation=float, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

total: float¶

class aiosu.models.performance.PerformanceAttributes(*, total: float)¶

total: float¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'total': FieldInfo(annotation=float, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.performance.TaikoPerformanceAttributes(*, total: float, difficulty: float, accuracy: float, effective_miss_count: float)¶

difficulty: float¶

accuracy: float¶

effective_miss_count: float¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'accuracy': FieldInfo(annotation=float, required=True), 'difficulty': FieldInfo(annotation=float, required=True), 'effective_miss_count': FieldInfo(annotation=float, required=True), 'total': FieldInfo(annotation=float, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

total: float¶

Gamemode¶

This module contains models for Gamemode objects.

class aiosu.models.gamemode.Gamemode(value)¶

An enumeration.

STANDARD = 0¶

TAIKO = 1¶

CTB = 2¶

MANIA = 3¶

property id: int¶

property name_full: str¶

property name_short: str¶

property name_api: str¶

classmethod from_type(_Gamemode__o: object) → Gamemode¶

Gets a gamemode.

Parameters:: __o (object) – Object to search for
Raises:: ValueError – If object cannot be converted to Gamemode
Returns:: A Gamemode object. Will search by name_api, name_short, id
Return type:: aiosu.models.gamemode.Gamemode

Lazer¶

This module contains models for lazer specific data.

class aiosu.models.lazer.LazerMod(*, acronym: str, settings: dict[str, object] = None)¶

Temporary model for lazer mods.

acronym: str¶

settings: dict[str, object]¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'acronym': FieldInfo(annotation=str, required=True), 'settings': FieldInfo(annotation=dict[str, object], required=False, default_factory=dict)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.lazer.LazerReplayData(*, mods: list[LazerMod], statistics: LazerScoreStatistics, maximum_statistics: LazerScoreStatistics, online_id: int | None = None, client_version: str | None = None)¶

mods: list[LazerMod]¶

statistics: LazerScoreStatistics¶

maximum_statistics: LazerScoreStatistics¶

online_id: int | None¶

client_version: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'client_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'maximum_statistics': FieldInfo(annotation=LazerScoreStatistics, required=True), 'mods': FieldInfo(annotation=list[LazerMod], required=True), 'online_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'statistics': FieldInfo(annotation=LazerScoreStatistics, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.lazer.LazerScore¶

accuracy: float¶

beatmap_id: int¶

ended_at: datetime¶

has_replay: bool¶

is_perfect_combo: bool¶

legacy_perfect: bool¶

max_combo: int¶

maximum_statistics: LazerScoreStatistics¶

mods: list[LazerMod]¶

passed: bool¶

rank: str¶

ruleset_id: int¶

statistics: LazerScoreStatistics¶

total_score: int¶

type: ScoreType¶

user_id: int¶

beatmap: Beatmap | None¶

beatmapset: Beatmapset | None¶

best_id: int | None¶

build_id: int | None¶

current_user_attributes: CurrentUserAttributes | None¶

id: int | None¶

match: MultiplayerMatch | None¶

preserved: bool | None¶

position: int | None¶

ranked: bool | None¶

rank_country: int | None¶

rank_global: int | None¶

legacy_score_id: int | None¶

legacy_total_score: int | None¶

playlist_item_id: int | None¶

pp: float | None¶

room_id: int | None¶

started_at: datetime | None¶

user: User | None¶

weight: ScoreWeight | None¶

property created_at: datetime¶

property score: int¶

property replay: bool¶: Legacy shortcut for has_replay.

property score_url: str | None¶

Link to the score.

Returns:: Link to the score on the osu! website
Return type:: Optional[str]

property replay_url: str | None¶

Link to the replay.

Returns:: Link to download the replay on the osu! website
Return type:: Optional[str]

property completion: float | None¶

Beatmap completion.

Returns:: Beatmap completion of a score (%). 100% for passes. None if no beatmap.
Return type:: Optional[float]

property mode: Gamemode¶

property mods_str: str¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {'completion': ComputedFieldInfo(wrapped_property=<functools.cached_property object>, return_type=PydanticUndefined, alias=None, alias_priority=None, title=None, description='Beatmap completion.\n\n:return: Beatmap completion of a score (%). 100% for passes. None if no beatmap.\n:rtype: Optional[float]', deprecated=None, examples=None, json_schema_extra=None, repr=True), 'mode': ComputedFieldInfo(wrapped_property=<functools.cached_property object>, return_type=PydanticUndefined, alias=None, alias_priority=None, title=None, description=None, deprecated=None, examples=None, json_schema_extra=None, repr=True), 'mods_str': ComputedFieldInfo(wrapped_property=<functools.cached_property object>, return_type=PydanticUndefined, alias=None, alias_priority=None, title=None, description=None, deprecated=None, examples=None, json_schema_extra=None, repr=True)}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'accuracy': FieldInfo(annotation=float, required=True), 'beatmap': FieldInfo(annotation=Union[Beatmap, NoneType], required=False, default=None), 'beatmap_id': FieldInfo(annotation=int, required=True), 'beatmapset': FieldInfo(annotation=Union[Beatmapset, NoneType], required=False, default=None), 'best_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'build_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'current_user_attributes': FieldInfo(annotation=Union[CurrentUserAttributes, NoneType], required=False, default=None), 'ended_at': FieldInfo(annotation=datetime, required=True), 'has_replay': FieldInfo(annotation=bool, required=True, alias_priority=2, validation_alias='replay'), 'id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'is_perfect_combo': FieldInfo(annotation=bool, required=True), 'legacy_perfect': FieldInfo(annotation=bool, required=True), 'legacy_score_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'legacy_total_score': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'match': FieldInfo(annotation=Union[MultiplayerMatch, NoneType], required=False, default=None), 'max_combo': FieldInfo(annotation=int, required=True), 'maximum_statistics': FieldInfo(annotation=LazerScoreStatistics, required=True), 'mods': FieldInfo(annotation=list[LazerMod], required=True), 'passed': FieldInfo(annotation=bool, required=True), 'playlist_item_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'position': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'pp': FieldInfo(annotation=Union[float, NoneType], required=False, default=None), 'preserved': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'rank': FieldInfo(annotation=str, required=True), 'rank_country': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'rank_global': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'ranked': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'room_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'ruleset_id': FieldInfo(annotation=int, required=True), 'started_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'statistics': FieldInfo(annotation=LazerScoreStatistics, required=True), 'total_score': FieldInfo(annotation=int, required=True, alias_priority=2, validation_alias='score'), 'type': FieldInfo(annotation=Literal['solo_score', 'score_best_osu', 'score_best_taiko', 'score_best_fruits', 'score_best_mania', 'score_osu', 'score_taiko', 'score_fruits', 'score_mania', 'legacy_match_score'], required=True), 'user': FieldInfo(annotation=Union[User, NoneType], required=False, default=None), 'user_id': FieldInfo(annotation=int, required=True), 'weight': FieldInfo(annotation=Union[ScoreWeight, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.lazer.LazerScoreStatistics(*, miss: int = 0, meh: int = 0, ok: int = 0, good: int = 0, great: int = 0, perfect: int = 0, small_tick_miss: int = 0, small_tick_hit: int = 0, large_tick_miss: int = 0, large_tick_hit: int = 0, small_bonus: int = 0, large_bonus: int = 0, ignore_miss: int = 0, ignore_hit: int = 0, combo_break: int = 0, slider_tail_hit: int = 0, legacy_combo_increase: int = 0)¶

Relevant information:

https://github.com/ppy/osu/blob/master/osu.Game/Rulesets/Scoring/HitResult.cs https://github.com/ppy/osu-web/blob/master/resources/js/interfaces/solo-score-json.ts

miss: int¶

meh: int¶

ok: int¶

good: int¶

great: int¶

perfect: int¶

small_tick_miss: int¶

small_tick_hit: int¶

large_tick_miss: int¶

large_tick_hit: int¶

small_bonus: int¶

large_bonus: int¶

ignore_miss: int¶

ignore_hit: int¶

combo_break: int¶

slider_tail_hit: int¶

legacy_combo_increase: int¶

property count_300: int¶

property count_100: int¶

property count_50: int¶

property count_miss: int¶

property count_geki: int¶

property count_katu: int¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'combo_break': FieldInfo(annotation=int, required=False, default=0), 'good': FieldInfo(annotation=int, required=False, default=0), 'great': FieldInfo(annotation=int, required=False, default=0), 'ignore_hit': FieldInfo(annotation=int, required=False, default=0), 'ignore_miss': FieldInfo(annotation=int, required=False, default=0), 'large_bonus': FieldInfo(annotation=int, required=False, default=0), 'large_tick_hit': FieldInfo(annotation=int, required=False, default=0), 'large_tick_miss': FieldInfo(annotation=int, required=False, default=0), 'legacy_combo_increase': FieldInfo(annotation=int, required=False, default=0), 'meh': FieldInfo(annotation=int, required=False, default=0), 'miss': FieldInfo(annotation=int, required=False, default=0), 'ok': FieldInfo(annotation=int, required=False, default=0), 'perfect': FieldInfo(annotation=int, required=False, default=0), 'slider_tail_hit': FieldInfo(annotation=int, required=False, default=0), 'small_bonus': FieldInfo(annotation=int, required=False, default=0), 'small_tick_hit': FieldInfo(annotation=int, required=False, default=0), 'small_tick_miss': FieldInfo(annotation=int, required=False, default=0)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

Multiplayer¶

This module contains models for multiplayer.

class aiosu.models.multiplayer.MultiplayerEvent(*, id: int, timestamp: datetime, type: Literal['match-created', 'match-disbanded', 'host-changed', 'player-joined', 'player-left', 'player-kicked', 'match-created-no-user', 'match-disbanded-no-user', 'host-changed-no-user', 'player-joined-no-user', 'player-left-no-user', 'player-kicked-no-user', 'other'], user_id: int | None = None, game: MultiplayerGame | None = None)¶

id: int¶

timestamp: datetime¶

type: MultiplayerEventType¶

user_id: int | None¶

game: MultiplayerGame | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'game': FieldInfo(annotation=Union[MultiplayerGame, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'timestamp': FieldInfo(annotation=datetime, required=True), 'type': FieldInfo(annotation=Literal['match-created', 'match-disbanded', 'host-changed', 'player-joined', 'player-left', 'player-kicked', 'match-created-no-user', 'match-disbanded-no-user', 'host-changed-no-user', 'player-joined-no-user', 'player-left-no-user', 'player-kicked-no-user', 'other'], required=True), 'user_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.multiplayer.MultiplayerGame(*, id: int, start_time: datetime, mode: Gamemode, scoring_type: Literal['score', 'accuracy', 'combo', 'scorev2'], team_type: Literal['head-to-head', 'tag-coop', 'team-vs', 'tag-team-vs'], mods: list[Mods | LazerMod], beatmap_id: int, scores: list[Score], beatmap: Beatmap | None = None, end_time: datetime | None = None)¶

id: int¶

start_time: datetime¶

mode: Gamemode¶

scoring_type: MultiplayerScoringType¶

team_type: MultiplayerTeamType¶

mods: list[Mods | LazerMod]¶

beatmap_id: int¶

scores: list[Score]¶

beatmap: Beatmap | None¶

end_time: datetime | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'beatmap': FieldInfo(annotation=Union[Beatmap, NoneType], required=False, default=None), 'beatmap_id': FieldInfo(annotation=int, required=True), 'end_time': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'mode': FieldInfo(annotation=Gamemode, required=True), 'mods': FieldInfo(annotation=list[Union[Mods, LazerMod]], required=True), 'scores': FieldInfo(annotation=list[Score], required=True), 'scoring_type': FieldInfo(annotation=Literal['score', 'accuracy', 'combo', 'scorev2'], required=True), 'start_time': FieldInfo(annotation=datetime, required=True), 'team_type': FieldInfo(annotation=Literal['head-to-head', 'tag-coop', 'team-vs', 'tag-team-vs'], required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.multiplayer.MultiplayerLeaderboardItem(*, accuracy: float, attempts: int, completed: int, pp: float, room_id: int, total_score: int, user_id: int, user: User, position: int | None = None)¶

accuracy: float¶

attempts: int¶

completed: int¶

pp: float¶

room_id: int¶

total_score: int¶

user_id: int¶

user: User¶

position: int | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'accuracy': FieldInfo(annotation=float, required=True), 'attempts': FieldInfo(annotation=int, required=True), 'completed': FieldInfo(annotation=int, required=True), 'position': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'pp': FieldInfo(annotation=float, required=True), 'room_id': FieldInfo(annotation=int, required=True), 'total_score': FieldInfo(annotation=int, required=True), 'user': FieldInfo(annotation=User, required=True), 'user_id': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.multiplayer.MultiplayerLeaderboardResponse(*, leaderboard: list[MultiplayerLeaderboardItem], user_score: MultiplayerLeaderboardItem | None = None)¶

leaderboard: list[MultiplayerLeaderboardItem]¶

user_score: MultiplayerLeaderboardItem | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'leaderboard': FieldInfo(annotation=list[MultiplayerLeaderboardItem], required=True), 'user_score': FieldInfo(annotation=Union[MultiplayerLeaderboardItem, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.multiplayer.MultiplayerMatch(*, id: int, name: str, start_time: datetime, end_time: datetime | None = None)¶

id: int¶

name: str¶

start_time: datetime¶

end_time: datetime | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'end_time': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'name': FieldInfo(annotation=str, required=True), 'start_time': FieldInfo(annotation=datetime, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.multiplayer.MultiplayerMatchResponse(*, match: MultiplayerMatch, events: list[MultiplayerEvent], users: list[User], first_event_id: int, latest_event_id: int, current_game_id: int | None = None)¶

match: MultiplayerMatch¶

events: list[MultiplayerEvent]¶

users: list[User]¶

first_event_id: int¶

latest_event_id: int¶

current_game_id: int | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'current_game_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'events': FieldInfo(annotation=list[MultiplayerEvent], required=True), 'first_event_id': FieldInfo(annotation=int, required=True), 'latest_event_id': FieldInfo(annotation=int, required=True), 'match': FieldInfo(annotation=MultiplayerMatch, required=True), 'users': FieldInfo(annotation=list[User], required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.multiplayer.MultiplayerMatchesResponse(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None, matches: list[MultiplayerMatch])¶

matches: list[MultiplayerMatch]¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'cursor_string': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'matches': FieldInfo(annotation=list[MultiplayerMatch], required=True), 'next': FieldInfo(annotation=Union[partial[Coroutine[object, object, CursorModel]], NoneType], required=False, default=None, exclude=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

class aiosu.models.multiplayer.MultiplayerRoom(*, id: int, name: str, category: Literal['normal', 'spotlight', 'featured_artist'], type: Literal['playlists', 'realtime'], user_id: int, channel_id: int, active: bool, has_password: bool, auto_skip: bool, host: User, queue_mode: Literal['host_only', 'all_players', 'all_players_round_robin'], playlist: list[MultiplayerPlaylistItem], recent_participants: list[User], participant_count: int | None = None, starts_at: datetime | None = None, ends_at: datetime | None = None, max_attempts: int | None = None)¶

id: int¶

name: str¶

category: MultiplayerRoomCategory¶

type: MultiplayerRoomGroupType¶

user_id: int¶

channel_id: int¶

active: bool¶

has_password: bool¶

auto_skip: bool¶

host: User¶

queue_mode: MultiplayerQueueMode¶

playlist: list[MultiplayerPlaylistItem]¶

recent_participants: list[User]¶

participant_count: int | None¶

starts_at: datetime | None¶

ends_at: datetime | None¶

max_attempts: int | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'active': FieldInfo(annotation=bool, required=True), 'auto_skip': FieldInfo(annotation=bool, required=True), 'category': FieldInfo(annotation=Literal['normal', 'spotlight', 'featured_artist'], required=True), 'channel_id': FieldInfo(annotation=int, required=True), 'ends_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'has_password': FieldInfo(annotation=bool, required=True), 'host': FieldInfo(annotation=User, required=True), 'id': FieldInfo(annotation=int, required=True), 'max_attempts': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'name': FieldInfo(annotation=str, required=True), 'participant_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'playlist': FieldInfo(annotation=list[MultiplayerPlaylistItem], required=True), 'queue_mode': FieldInfo(annotation=Literal['host_only', 'all_players', 'all_players_round_robin'], required=True), 'recent_participants': FieldInfo(annotation=list[User], required=True), 'starts_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'type': FieldInfo(annotation=Literal['playlists', 'realtime'], required=True), 'user_id': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.multiplayer.MultiplayerRoomsResponse(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None, rooms: list[MultiplayerRoom])¶

Currently unused. Relevant for api-version >= 99999999

rooms: list[MultiplayerRoom]¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

class aiosu.models.multiplayer.MultiplayerScoresAround¶

higher: MultiplayerScoresResponse¶

lower: MultiplayerScoresResponse¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'higher': FieldInfo(annotation=MultiplayerScoresResponse, required=True), 'lower': FieldInfo(annotation=MultiplayerScoresResponse, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.multiplayer.MultiplayerScoresResponse(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None)¶

scores: list[LazerScore]¶

user_score: LazerScore | None¶

total: int | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'cursor_string': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'next': FieldInfo(annotation=Union[partial[Coroutine[object, object, CursorModel]], NoneType], required=False, default=None, exclude=True), 'scores': FieldInfo(annotation=list[LazerScore], required=True), 'total': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'user_score': FieldInfo(annotation=Union[LazerScore, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

aiosu.models.multiplayer.MultiplayerScoreSortType¶: alias of Literal[‘score_asc’, ‘score_desc’]

aiosu.models.multiplayer.MultiplayerEventType¶: alias of Literal[‘match-created’, ‘match-disbanded’, ‘host-changed’, ‘player-joined’, ‘player-left’, ‘player-kicked’, ‘match-created-no-user’, ‘match-disbanded-no-user’, ‘host-changed-no-user’, ‘player-joined-no-user’, ‘player-left-no-user’, ‘player-kicked-no-user’, ‘other’]

aiosu.models.multiplayer.MultiplayerRoomMode¶: alias of Literal[‘owned’, ‘participated’, ‘ended’]

aiosu.models.multiplayer.MultiplayerRoomCategory¶: alias of Literal[‘normal’, ‘spotlight’, ‘featured_artist’]

aiosu.models.multiplayer.MultiplayerRoomGroupType¶: alias of Literal[‘playlists’, ‘realtime’]

aiosu.models.multiplayer.MultiplayerQueueMode¶: alias of Literal[‘host_only’, ‘all_players’, ‘all_players_round_robin’]

Featured Artists¶

This module contains models for featured artists.

class aiosu.models.artist.Artist¶

id: int¶

name: str¶

user_id: int | None¶

description: str | None¶

visible: bool | None¶

header_url: str | None¶

cover_url: str | None¶

created_at: datetime | None¶

updated_at: datetime | None¶

beatmapsets: list[Beatmapset] | None¶

label: ArtistLabel | None¶

albums: list[ArtistAlbum] | None¶

tracks: list[ArtistTrack] | None¶

bandcamp: str | None¶

facebook: str | None¶

patreon: str | None¶

soundcloud: str | None¶

spotify: str | None¶

twitter: str | None¶

website: str | None¶

youtube: str | None¶

video_url: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'albums': FieldInfo(annotation=Union[list[ArtistAlbum], NoneType], required=False, default=None), 'bandcamp': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'beatmapsets': FieldInfo(annotation=Union[list[Beatmapset], NoneType], required=False, default=None), 'cover_url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'created_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'facebook': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'header_url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'label': FieldInfo(annotation=Union[ArtistLabel, NoneType], required=False, default=None), 'name': FieldInfo(annotation=str, required=True), 'patreon': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'soundcloud': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'spotify': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'tracks': FieldInfo(annotation=Union[list[ArtistTrack], NoneType], required=False, default=None), 'twitter': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'updated_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'user_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'video_url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'visible': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'website': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'youtube': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.artist.ArtistAlbum(*, id: int, artist_id: int, title: str, title_romanized: str, genre: str, is_new: bool, cover_url: str)¶

id: int¶

artist_id: int¶

title: str¶

title_romanized: str¶

genre: str¶

is_new: bool¶

cover_url: str¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'artist_id': FieldInfo(annotation=int, required=True), 'cover_url': FieldInfo(annotation=str, required=True), 'genre': FieldInfo(annotation=str, required=True), 'id': FieldInfo(annotation=int, required=True), 'is_new': FieldInfo(annotation=bool, required=True), 'title': FieldInfo(annotation=str, required=True), 'title_romanized': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.artist.ArtistLabel¶

id: int¶

artists: list[Artist]¶

name: str¶

description: str¶

icon_url: str¶

header_url: str¶

created_at: datetime | None¶

updated_at: datetime | None¶

soundcloud: str | None¶

website: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'artists': FieldInfo(annotation=list[Artist], required=True), 'created_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'description': FieldInfo(annotation=str, required=True), 'header_url': FieldInfo(annotation=str, required=True), 'icon_url': FieldInfo(annotation=str, required=True), 'id': FieldInfo(annotation=int, required=True), 'name': FieldInfo(annotation=str, required=True), 'soundcloud': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'updated_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'website': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.artist.ArtistSearch(*, is_default_sort: bool, sort: Literal['album_asc', 'album_desc', 'artist_asc', 'artist_desc', 'bpm_asc', 'bpm_desc', 'genre_asc', 'genre_desc', 'length_asc', 'length_desc', 'relevance_asc', 'relevance_desc', 'title_asc', 'title_desc', 'update_asc', 'update_desc'])¶

is_default_sort: bool¶

sort: ArtistSortType¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'is_default_sort': FieldInfo(annotation=bool, required=True), 'sort': FieldInfo(annotation=Literal['album_asc', 'album_desc', 'artist_asc', 'artist_desc', 'bpm_asc', 'bpm_desc', 'genre_asc', 'genre_desc', 'length_asc', 'length_desc', 'relevance_asc', 'relevance_desc', 'title_asc', 'title_desc', 'update_asc', 'update_desc'], required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.artist.ArtistTrack(*, id: int, artist_id: int, bpm: float, cover_url: str, exclusive: bool, genre: str, is_new: bool, length: str, title: str, artist: Artist, osz: str, preview: str, album: ArtistAlbum | None = None, album_id: int | None = None, updated_at: datetime | None = None, version: str | None = None)¶

id: int¶

artist_id: int¶

bpm: float¶

cover_url: str¶

exclusive: bool¶

genre: str¶

is_new: bool¶

length: str¶

title: str¶

artist: Artist¶

osz_url: str¶

preview_url: str¶

album: ArtistAlbum | None¶

album_id: int | None¶

updated_at: datetime | None¶

version: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'album': FieldInfo(annotation=Union[ArtistAlbum, NoneType], required=False, default=None), 'album_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'artist': FieldInfo(annotation=Artist, required=True), 'artist_id': FieldInfo(annotation=int, required=True), 'bpm': FieldInfo(annotation=float, required=True), 'cover_url': FieldInfo(annotation=str, required=True), 'exclusive': FieldInfo(annotation=bool, required=True), 'genre': FieldInfo(annotation=str, required=True), 'id': FieldInfo(annotation=int, required=True), 'is_new': FieldInfo(annotation=bool, required=True), 'length': FieldInfo(annotation=str, required=True), 'osz_url': FieldInfo(annotation=str, required=True, alias='osz', alias_priority=2), 'preview_url': FieldInfo(annotation=str, required=True, alias='preview', alias_priority=2), 'title': FieldInfo(annotation=str, required=True), 'updated_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.artist.ArtistTracksResponse(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None, artist_tracks: list[ArtistTrack], search: ArtistSearch | None = None)¶

Artist response model.

artist_tracks: list[ArtistTrack]¶

search: ArtistSearch | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'artist_tracks': FieldInfo(annotation=list[ArtistTrack], required=True), 'cursor_string': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'next': FieldInfo(annotation=Union[partial[Coroutine[object, object, CursorModel]], NoneType], required=False, default=None, exclude=True), 'search': FieldInfo(annotation=Union[ArtistSearch, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

aiosu.models.artist.ArtistSortType¶: alias of Literal[‘album_asc’, ‘album_desc’, ‘artist_asc’, ‘artist_desc’, ‘bpm_asc’, ‘bpm_desc’, ‘genre_asc’, ‘genre_desc’, ‘length_asc’, ‘length_desc’, ‘relevance_asc’, ‘relevance_desc’, ‘title_asc’, ‘title_desc’, ‘update_asc’, ‘update_desc’]

Backgrounds¶

This module contains models for seasonal background objects.

class aiosu.models.backgrounds.Background(*, url: str, user: User)¶

url: str¶

user: User¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'url': FieldInfo(annotation=str, required=True), 'user': FieldInfo(annotation=User, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.backgrounds.SeasonalBackgroundSet(*, ends_at: datetime, backgrounds: list[Background])¶

ends_at: datetime¶

backgrounds: list[Background]¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'backgrounds': FieldInfo(annotation=list[Background], required=True), 'ends_at': FieldInfo(annotation=datetime, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

Changelogs¶

This module contains models for changelog objects.

class aiosu.models.changelog.Build(*, id: int, created_at: datetime, display_version: str, users: int, version: str, youtube_id: str | None = None, update_stream: UpdateStream | None = None, changelog_entries: list[ChangelogEntry] | None = None, versions: Version | None = None)¶

id: int¶

created_at: datetime¶

display_version: str¶

users: int¶

version: str¶

youtube_id: str | None¶

update_stream: UpdateStream | None¶

changelog_entries: list[ChangelogEntry] | None¶

versions: Version | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'changelog_entries': FieldInfo(annotation=Union[list[ChangelogEntry], NoneType], required=False, default=None), 'created_at': FieldInfo(annotation=datetime, required=True), 'display_version': FieldInfo(annotation=str, required=True), 'id': FieldInfo(annotation=int, required=True), 'update_stream': FieldInfo(annotation=Union[UpdateStream, NoneType], required=False, default=None), 'users': FieldInfo(annotation=int, required=True), 'version': FieldInfo(annotation=str, required=True), 'versions': FieldInfo(annotation=Union[Version, NoneType], required=False, default=None), 'youtube_id': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

type: ChangelogEntryType¶

category: str¶

major: bool¶

id: int | None¶

title: str | None¶

created_at: datetime | None¶

url: str | None¶

github_url: str | None¶

github_pull_request_id: int | None¶

repository: str | None¶

message: str | None¶

message_html: str | None¶

github_user: GithubUser | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'category': FieldInfo(annotation=str, required=True), 'created_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'github_pull_request_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'github_url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'github_user': FieldInfo(annotation=Union[GithubUser, NoneType], required=False, default=None), 'id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'major': FieldInfo(annotation=bool, required=True), 'message': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'message_html': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'repository': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'type': FieldInfo(annotation=Literal['add', 'fix'], required=True), 'url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.changelog.ChangelogListing(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None, builds: list[Build], search: ChangelogSearch, streams: list[UpdateStream])¶

builds: list[Build]¶

search: ChangelogSearch¶

streams: list[UpdateStream]¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'builds': FieldInfo(annotation=list[Build], required=True), 'cursor_string': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'next': FieldInfo(annotation=Union[partial[Coroutine[object, object, CursorModel]], NoneType], required=False, default=None, exclude=True), 'search': FieldInfo(annotation=ChangelogSearch, required=True), 'streams': FieldInfo(annotation=list[UpdateStream], required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

class aiosu.models.changelog.ChangelogSearch(*, limit: int, fro: str | None = None, to: str | None = None, max_id: int | None = None, stream: str | None = None)¶

limit: int¶

fro: str | None¶

to: str | None¶

max_id: int | None¶

stream: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'fro': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='from', alias_priority=2), 'limit': FieldInfo(annotation=int, required=True), 'max_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'stream': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'to': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

display_name: str¶

github_url: str | None¶

id: int | None¶

osu_username: str | None¶

user_id: int | None¶

user_url: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'display_name': FieldInfo(annotation=str, required=True), 'github_url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'osu_username': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'user_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'user_url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.changelog.UpdateStream¶

id: int¶

is_featured: bool¶

name: str¶

display_name: str | None¶

user_count: int | None¶

latest_build: Build | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'display_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'is_featured': FieldInfo(annotation=bool, required=True), 'latest_build': FieldInfo(annotation=Union[Build, NoneType], required=False, default=None), 'name': FieldInfo(annotation=str, required=True), 'user_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.changelog.Version¶

next: Build | None¶

previous: Build | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'next': FieldInfo(annotation=Union[Build, NoneType], required=False, default=None), 'previous': FieldInfo(annotation=Union[Build, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

aiosu.models.changelog.ChangelogMessageFormat¶: alias of Literal[‘markdown’, ‘html’]

aiosu.models.changelog.ChangelogEntryType¶: alias of Literal[‘add’, ‘fix’]

Spotlights¶

This module contains models for spotlight objects.

class aiosu.models.spotlight.Spotlight(*, id: int, name: str, mode_specific: bool, type: Literal['bestof', 'monthly', 'spotlight', 'theme', 'special'], start_date: datetime, end_date: datetime, participant_count: int | None = None)¶

id: int¶

name: str¶

mode_specific: bool¶

type: SpotlightType¶

start_date: datetime¶

end_date: datetime¶

participant_count: int | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'end_date': FieldInfo(annotation=datetime, required=True), 'id': FieldInfo(annotation=int, required=True), 'mode_specific': FieldInfo(annotation=bool, required=True), 'name': FieldInfo(annotation=str, required=True), 'participant_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'start_date': FieldInfo(annotation=datetime, required=True), 'type': FieldInfo(annotation=Literal['bestof', 'monthly', 'spotlight', 'theme', 'special'], required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

aiosu.models.spotlight.SpotlightType¶: alias of Literal[‘bestof’, ‘monthly’, ‘spotlight’, ‘theme’, ‘special’]

News¶

This module contains models for news post objects.

class aiosu.models.news.Navigation¶

newer: NewsPost | None¶

older: NewsPost | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'newer': FieldInfo(annotation=Union[NewsPost, NoneType], required=False, default=None), 'older': FieldInfo(annotation=Union[NewsPost, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.news.NewsListing(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None, news_posts: list[NewsPost], search: NewsSearch, news_sidebar: NewsSidebar)¶

news_posts: list[NewsPost]¶

search: NewsSearch¶

news_sidebar: NewsSidebar¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'cursor_string': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'news_posts': FieldInfo(annotation=list[NewsPost], required=True), 'news_sidebar': FieldInfo(annotation=NewsSidebar, required=True), 'next': FieldInfo(annotation=Union[partial[Coroutine[object, object, CursorModel]], NoneType], required=False, default=None, exclude=True), 'search': FieldInfo(annotation=NewsSearch, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

class aiosu.models.news.NewsPost(*, id: int, title: str, slug: str, author: str, edit_url: str, published_at: datetime, updated_at: datetime, first_image: str | None = None, content: str | None = None, preview: str | None = None, navigation: Navigation | None = None)¶

id: int¶

title: str¶

slug: str¶

author: str¶

edit_url: str¶

published_at: datetime¶

updated_at: datetime¶

first_image: str | None¶

content: str | None¶

preview: str | None¶

navigation: Navigation | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'author': FieldInfo(annotation=str, required=True), 'content': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'edit_url': FieldInfo(annotation=str, required=True), 'first_image': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'navigation': FieldInfo(annotation=Union[Navigation, NoneType], required=False, default=None), 'preview': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'published_at': FieldInfo(annotation=datetime, required=True), 'slug': FieldInfo(annotation=str, required=True), 'title': FieldInfo(annotation=str, required=True), 'updated_at': FieldInfo(annotation=datetime, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.news.NewsSearch(*, limit: int, sort: Literal['published_asc', 'published_desc'])¶

limit: int¶

sort: NewsSortType¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'limit': FieldInfo(annotation=int, required=True), 'sort': FieldInfo(annotation=Literal['published_asc', 'published_desc'], required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

aiosu.models.news.NewsSortType¶: alias of Literal[‘published_asc’, ‘published_desc’]

Forum¶

This module contains the Forum model.

class aiosu.models.forum.ForumCreateTopicResponse(*, topic: ForumTopic, post: ForumPost)¶

topic: ForumTopic¶

post: ForumPost¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'post': FieldInfo(annotation=ForumPost, required=True), 'topic': FieldInfo(annotation=ForumTopic, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.forum.ForumPoll(*, allow_vote_change: bool, hide_incomplete_results: bool, max_votes: int, total_vote_count: int, options: list[ForumPollOption], started_at: datetime, title: HTMLBody, ended_at: datetime | None = None, last_vote_at: datetime | None = None)¶

allow_vote_change: bool¶

hide_incomplete_results: bool¶

max_votes: int¶

total_vote_count: int¶

options: list[ForumPollOption]¶

started_at: datetime¶

title: HTMLBody¶

ended_at: datetime | None¶

last_vote_at: datetime | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'allow_vote_change': FieldInfo(annotation=bool, required=True), 'ended_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'hide_incomplete_results': FieldInfo(annotation=bool, required=True), 'last_vote_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'max_votes': FieldInfo(annotation=int, required=True), 'options': FieldInfo(annotation=list[ForumPollOption], required=True), 'started_at': FieldInfo(annotation=datetime, required=True), 'title': FieldInfo(annotation=HTMLBody, required=True), 'total_vote_count': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.forum.ForumPollOption(*, id: int, text: HTMLBody, vote_count: int | None = None)¶

id: int¶

text: HTMLBody¶

vote_count: int | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'id': FieldInfo(annotation=int, required=True), 'text': FieldInfo(annotation=HTMLBody, required=True), 'vote_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.forum.ForumPost(*, id: int, created_at: datetime, forum_id: int, topic_id: int, user_id: int, edited_by_id: int | None = None, edited_at: datetime | None = None, deleted_at: datetime | None = None, body: HTMLBody | None = None)¶

id: int¶

created_at: datetime¶

forum_id: int¶

topic_id: int¶

user_id: int¶

edited_by_id: int | None¶

edited_at: datetime | None¶

deleted_at: datetime | None¶

body: HTMLBody | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'body': FieldInfo(annotation=Union[HTMLBody, NoneType], required=False, default=None), 'created_at': FieldInfo(annotation=datetime, required=True), 'deleted_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'edited_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'edited_by_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'forum_id': FieldInfo(annotation=int, required=True), 'id': FieldInfo(annotation=int, required=True), 'topic_id': FieldInfo(annotation=int, required=True), 'user_id': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.forum.ForumTopic(*, id: int, title: str, created_at: datetime, first_post_id: int, last_post_id: int, forum_id: int, is_locked: bool, post_count: int, type: Literal['normal', 'sticky', 'announcement'], updated_at: datetime, user_id: int, deleted_at: datetime | None = None, poll: ForumPoll | None = None)¶

id: int¶

title: str¶

created_at: datetime¶

first_post_id: int¶

last_post_id: int¶

forum_id: int¶

is_locked: bool¶

post_count: int¶

type: ForumTopicType¶

updated_at: datetime¶

user_id: int¶

deleted_at: datetime | None¶

poll: ForumPoll | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'created_at': FieldInfo(annotation=datetime, required=True), 'deleted_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'first_post_id': FieldInfo(annotation=int, required=True), 'forum_id': FieldInfo(annotation=int, required=True), 'id': FieldInfo(annotation=int, required=True), 'is_locked': FieldInfo(annotation=bool, required=True), 'last_post_id': FieldInfo(annotation=int, required=True), 'poll': FieldInfo(annotation=Union[ForumPoll, NoneType], required=False, default=None), 'post_count': FieldInfo(annotation=int, required=True), 'title': FieldInfo(annotation=str, required=True), 'type': FieldInfo(annotation=Literal['normal', 'sticky', 'announcement'], required=True), 'updated_at': FieldInfo(annotation=datetime, required=True), 'user_id': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.forum.ForumTopicResponse(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None, topic: ForumTopic, posts: list[ForumPost])¶

topic: ForumTopic¶

posts: list[ForumPost]¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'cursor_string': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'next': FieldInfo(annotation=Union[partial[Coroutine[object, object, CursorModel]], NoneType], required=False, default=None, exclude=True), 'posts': FieldInfo(annotation=list[ForumPost], required=True), 'topic': FieldInfo(annotation=ForumTopic, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

aiosu.models.forum.ForumTopicType¶: alias of Literal[‘normal’, ‘sticky’, ‘announcement’]

Chat¶

This module contains models for chat.

class aiosu.models.chat.ChatChannel(*, channel_id: int, type: Literal['PM', 'PUBLIC', 'PRIVATE', 'MULTIPLAYER', 'SPECTATOR', 'TEMPORARY', 'GROUP', 'ANNOUNCE'], name: str, moderated: bool, message_length_limit: int, icon: str | None = None, description: str | None = None, last_message_id: int | None = None, users: list[int] | None = None, current_user_attributes: CurrentUserAttributes | None = None)¶

id: int¶

type: ChatChannelType¶

name: str¶

moderated: bool¶

message_length_limit: int¶

icon: str | None¶

description: str | None¶

last_message_id: int | None¶

user_ids: list[int] | None¶

current_user_attributes: CurrentUserAttributes | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'current_user_attributes': FieldInfo(annotation=Union[CurrentUserAttributes, NoneType], required=False, default=None), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'icon': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True, alias='channel_id', alias_priority=2), 'last_message_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'message_length_limit': FieldInfo(annotation=int, required=True), 'moderated': FieldInfo(annotation=bool, required=True), 'name': FieldInfo(annotation=str, required=True), 'type': FieldInfo(annotation=Literal['PM', 'PUBLIC', 'PRIVATE', 'MULTIPLAYER', 'SPECTATOR', 'TEMPORARY', 'GROUP', 'ANNOUNCE'], required=True), 'user_ids': FieldInfo(annotation=Union[list[int], NoneType], required=False, default=None, alias='users', alias_priority=2)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.chat.ChatChannelResponse(*, channel: ChatChannel, users: list[User] | None = None)¶

channel: ChatChannel¶

users: list[User] | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'channel': FieldInfo(annotation=ChatChannel, required=True), 'users': FieldInfo(annotation=Union[list[User], NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.chat.ChatMessage(*, message_id: int, sender_id: int, channel_id: int, timestamp: str, content: str, is_action: bool, uuid: str | None = None, sender: User | None = None)¶

message_id: int¶

sender_id: int¶

channel_id: int¶

timestamp: str¶

content: str¶

is_action: bool¶

uuid: str | None¶

sender: User | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'channel_id': FieldInfo(annotation=int, required=True), 'content': FieldInfo(annotation=str, required=True), 'is_action': FieldInfo(annotation=bool, required=True), 'message_id': FieldInfo(annotation=int, required=True), 'sender': FieldInfo(annotation=Union[User, NoneType], required=False, default=None), 'sender_id': FieldInfo(annotation=int, required=True), 'timestamp': FieldInfo(annotation=str, required=True), 'uuid': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.chat.ChatMessageCreateResponse(*, channel: ChatChannel, message: ChatMessage)¶

channel: ChatChannel¶

message: ChatMessage¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'channel': FieldInfo(annotation=ChatChannel, required=True), 'message': FieldInfo(annotation=ChatMessage, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.chat.ChatUpdateResponse(*, messages: list[ChatMessage] | None = None, presence: list[ChatChannel] | None = None, silences: list)¶

messages: list[ChatMessage] | None¶

presence: list[ChatChannel] | None¶

silences: list¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'messages': FieldInfo(annotation=Union[list[ChatMessage], NoneType], required=False, default=None), 'presence': FieldInfo(annotation=Union[list[ChatChannel], NoneType], required=False, default=None), 'silences': FieldInfo(annotation=list, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.chat.ChatUserSilence(*, id: int, user_id: int)¶

id: int¶

user_id: int¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'id': FieldInfo(annotation=int, required=True), 'user_id': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

aiosu.models.chat.ChatChannelType¶: alias of Literal[‘PM’, ‘PUBLIC’, ‘PRIVATE’, ‘MULTIPLAYER’, ‘SPECTATOR’, ‘TEMPORARY’, ‘GROUP’, ‘ANNOUNCE’]

aiosu.models.chat.ChatIncludeType¶: alias of Literal[‘messages’, ‘presence’, ‘silences’]

Wiki¶

This module contains models for wiki objects.

class aiosu.models.wiki.WikiPage(*, title: str, path: str, locale: str, available_locales: list[str], layout: str, markdown: str, subtitle: str | None = None, tags: list[str] | None = None)¶

title: str¶

path: str¶

locale: str¶

available_locales: list[str]¶

layout: str¶

markdown: str¶

subtitle: str | None¶

tags: list[str] | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'available_locales': FieldInfo(annotation=list[str], required=True), 'layout': FieldInfo(annotation=str, required=True), 'locale': FieldInfo(annotation=str, required=True), 'markdown': FieldInfo(annotation=str, required=True), 'path': FieldInfo(annotation=str, required=True), 'subtitle': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'tags': FieldInfo(annotation=Union[list[str], NoneType], required=False, default=None), 'title': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

Kudosu¶

This module contains models for kudosu objects.

class aiosu.models.kudosu.KudosuGiver(*, url: str, username: str)¶

url: str¶

username: str¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'url': FieldInfo(annotation=str, required=True), 'username': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.kudosu.KudosuHistory(*, id: int, action: Literal['give', 'vote.give', 'reset', 'vote.reset', 'revoke', 'vote.revoke'], created_at: datetime, amount: int, model: str, giver: KudosuGiver | None = None, post: KudosuPost | None = None)¶

id: int¶

action: KudosuAction¶

created_at: datetime¶

amount: int¶

model: str¶

giver: KudosuGiver | None¶

post: KudosuPost | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'action': FieldInfo(annotation=Literal['give', 'vote.give', 'reset', 'vote.reset', 'revoke', 'vote.revoke'], required=True), 'amount': FieldInfo(annotation=int, required=True), 'created_at': FieldInfo(annotation=datetime, required=True), 'giver': FieldInfo(annotation=Union[KudosuGiver, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'model': FieldInfo(annotation=str, required=True), 'post': FieldInfo(annotation=Union[KudosuPost, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.kudosu.KudosuPost(*, title: str, url: str | None = None)¶

title: str¶

url: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'title': FieldInfo(annotation=str, required=True), 'url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

aiosu.models.kudosu.KudosuAction¶: alias of Literal[‘give’, ‘vote.give’, ‘reset’, ‘vote.reset’, ‘revoke’, ‘vote.revoke’]

Search¶

This module contains models for the search endpoint.

class aiosu.models.search.SearchResponse(*, users: SearchResult | None = None, wiki_pages: SearchResult | None = None)¶

users: SearchResult | None¶

wiki_pages: SearchResult | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'users': FieldInfo(annotation=Union[SearchResult, NoneType], required=False, default=None), 'wiki_pages': FieldInfo(annotation=Union[SearchResult, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.search.SearchResult(*, data: list[User | WikiPage], total: int)¶

data: list[User | WikiPage]¶

total: int¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'data': FieldInfo(annotation=list[Union[User, WikiPage]], required=True), 'total': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

aiosu.models.search.SearchMode¶: alias of Literal[‘all’, ‘user’, ‘wiki_page’]

Comments¶

This module contains models for comment objects.

class aiosu.models.comment.Comment(*, id: int, commentable_id: int, commentable_type: Literal['beatmapset', 'news_post', 'build'], created_at: datetime, updated_at: datetime, pinned: bool, votes_count: int, replies_count: int, message: str | None = None, message_html: str | None = None, deleted_at: datetime | None = None, edited_at: datetime | None = None, edited_by_id: int | None = None, parent_id: int | None = None, legacy_name: str | None = None, user_id: int | None = None)¶

id: int¶

commentable_id: int¶

commentable_type: CommentableType¶

created_at: datetime¶

updated_at: datetime¶

pinned: bool¶

votes_count: int¶

replies_count: int¶

message: str | None¶

message_html: str | None¶

deleted_at: datetime | None¶

edited_at: datetime | None¶

edited_by_id: int | None¶

parent_id: int | None¶

legacy_name: str | None¶

user_id: int | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'commentable_id': FieldInfo(annotation=int, required=True), 'commentable_type': FieldInfo(annotation=Literal['beatmapset', 'news_post', 'build'], required=True), 'created_at': FieldInfo(annotation=datetime, required=True), 'deleted_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'edited_at': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'edited_by_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True), 'legacy_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'message': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'message_html': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'parent_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'pinned': FieldInfo(annotation=bool, required=True), 'replies_count': FieldInfo(annotation=int, required=True), 'updated_at': FieldInfo(annotation=datetime, required=True), 'user_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'votes_count': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.comment.CommentBundle(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None, commentable_meta: list[Commentable], comments: list[Comment], has_more: bool, included_comments: list[Comment], sort: Literal['new', 'old', 'top'], user_follow: bool, user_votes: list[int], users: list[User], pinned_comments: list[Comment] | None = None, total: int | None = None, top_level_count: int | None = None, has_more_id: int | None = None)¶

commentable_meta: list[Commentable]¶

comments: list[Comment]¶

has_more: bool¶

included_comments: list[Comment]¶

sort: CommentSortType¶

user_follow: bool¶

user_votes: list[int]¶

users: list[User]¶

pinned_comments: list[Comment] | None¶

total: int | None¶

top_level_count: int | None¶

has_more_id: int | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'commentable_meta': FieldInfo(annotation=list[Commentable], required=True), 'comments': FieldInfo(annotation=list[Comment], required=True), 'cursor_string': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'has_more': FieldInfo(annotation=bool, required=True), 'has_more_id': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'included_comments': FieldInfo(annotation=list[Comment], required=True), 'next': FieldInfo(annotation=Union[partial[Coroutine[object, object, CursorModel]], NoneType], required=False, default=None, exclude=True), 'pinned_comments': FieldInfo(annotation=Union[list[Comment], NoneType], required=False, default=None), 'sort': FieldInfo(annotation=Literal['new', 'old', 'top'], required=True), 'top_level_count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'total': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'user_follow': FieldInfo(annotation=bool, required=True), 'user_votes': FieldInfo(annotation=list[int], required=True), 'users': FieldInfo(annotation=list[User], required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

id: int | None¶

title: str | None¶

url: str | None¶

type: str | None¶

owner_id: int | None¶

owner_title: str | None¶

current_user_attributes: CurrentUserAttributes | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

aiosu.models.comment.CommentSortType¶: alias of Literal[‘new’, ‘old’, ‘top’]

aiosu.models.comment.CommentableType¶: alias of Literal[‘beatmapset’, ‘news_post’, ‘build’]

API Events¶

This module contains models for API events.

class aiosu.models.event.Event(*, created_at: datetime, id: int, type: Literal['achievement', 'beatmapPlaycount', 'beatmapsetApprove', 'beatmapsetDelete', 'beatmapsetRevive', 'beatmapsetUpdate', 'beatmapsetUpload', 'rank', 'rankLost', 'usernameChange', 'userSupportAgain', 'userSupportFirst', 'userSupportGift'], parse_error: bool | None = None, achievement: Achievement | None = None, user: EventUser | None = None, beatmap: EventBeatmap | None = None, beatmapset: EventBeatmapset | None = None, approval: BeatmapRankStatus | None = None, count: int | None = None, rank: int | None = None, mode: Gamemode | None = None, scoreRank: str | None = None)¶

created_at: datetime¶

id: int¶

type: EventType¶: Information on types: https://github.com/ppy/osu-web/blob/master/resources/js/interfaces/event-json.ts

parse_error: bool | None¶

achievement: Achievement | None¶

user: EventUser | None¶

beatmap: EventBeatmap | None¶

beatmapset: EventBeatmapset | None¶

approval: BeatmapRankStatus | None¶

count: int | None¶

rank: int | None¶

mode: Gamemode | None¶

score_rank: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'achievement': FieldInfo(annotation=Union[Achievement, NoneType], required=False, default=None), 'approval': FieldInfo(annotation=Union[BeatmapRankStatus, NoneType], required=False, default=None), 'beatmap': FieldInfo(annotation=Union[EventBeatmap, NoneType], required=False, default=None), 'beatmapset': FieldInfo(annotation=Union[EventBeatmapset, NoneType], required=False, default=None), 'count': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'created_at': FieldInfo(annotation=datetime, required=True), 'id': FieldInfo(annotation=int, required=True), 'mode': FieldInfo(annotation=Union[Gamemode, NoneType], required=False, default=None), 'parse_error': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'rank': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'score_rank': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='scoreRank', alias_priority=2), 'type': FieldInfo(annotation=Literal['achievement', 'beatmapPlaycount', 'beatmapsetApprove', 'beatmapsetDelete', 'beatmapsetRevive', 'beatmapsetUpdate', 'beatmapsetUpload', 'rank', 'rankLost', 'usernameChange', 'userSupportAgain', 'userSupportFirst', 'userSupportGift'], required=True), 'user': FieldInfo(annotation=Union[EventUser, NoneType], required=False, default=None)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.event.EventBeatmap(*, title: str, url: str)¶

title: str¶

url: str¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'title': FieldInfo(annotation=str, required=True), 'url': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.event.EventBeatmapset(*, title: str, url: str)¶

title: str¶

url: str¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'title': FieldInfo(annotation=str, required=True), 'url': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.event.EventResponse(*, cursor_string: str | None = None, next: partial[Coroutine[object, object, CursorModel]] | None = None, events: list[Event])¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'cursor_string': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'events': FieldInfo(annotation=list[Event], required=True), 'next': FieldInfo(annotation=Union[partial[Coroutine[object, object, CursorModel]], NoneType], required=False, default=None, exclude=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

events: list[Event]¶

cursor_string: str | None¶

next: partial[Coroutine[object, object, CursorModel]] | None¶: Partial function to get the next page of results.

class aiosu.models.event.EventUser(*, username: str, url: str, previousUsername: str | None = None)¶

username: str¶

url: str¶

previous_username: str | None¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'previous_username': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='previousUsername', alias_priority=2), 'url': FieldInfo(annotation=str, required=True), 'username': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

aiosu.models.event.EventType¶: alias of Literal[‘achievement’, ‘beatmapPlaycount’, ‘beatmapsetApprove’, ‘beatmapsetDelete’, ‘beatmapsetRevive’, ‘beatmapsetUpdate’, ‘beatmapsetUpload’, ‘rank’, ‘rankLost’, ‘usernameChange’, ‘userSupportAgain’, ‘userSupportFirst’, ‘userSupportGift’]

OAuth Token¶

This module contains models for API v2 token objects.

class aiosu.models.oauthtoken.OAuthToken(*, token_type: str = 'Bearer', access_token: str = '', refresh_token: str = '', expires_on: datetime = datetime.datetime(1971, 1, 1, 0, 0))¶

token_type: str¶: Defaults to ‘Bearer’

access_token: str¶

refresh_token: str¶

expires_on: datetime¶: Can be a datetime.datetime object or a string. Alternatively, expires_in may be passed representing the number of seconds the token will be valid for.

property owner_id: int¶

property scopes: Scopes¶

property can_refresh: bool¶: Returns True if the token can be refreshed.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {'can_refresh': ComputedFieldInfo(wrapped_property=<functools.cached_property object>, return_type=<class 'bool'>, alias=None, alias_priority=None, title=None, description='Returns True if the token can be refreshed.', deprecated=None, examples=None, json_schema_extra=None, repr=True), 'owner_id': ComputedFieldInfo(wrapped_property=<functools.cached_property object>, return_type=<class 'int'>, alias=None, alias_priority=None, title=None, description=None, deprecated=None, examples=None, json_schema_extra=None, repr=True), 'scopes': ComputedFieldInfo(wrapped_property=<functools.cached_property object>, return_type=<enum 'Scopes'>, alias=None, alias_priority=None, title=None, description=None, deprecated=None, examples=None, json_schema_extra=None, repr=True)}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'access_token': FieldInfo(annotation=str, required=False, default=''), 'expires_on': FieldInfo(annotation=datetime, required=False, default=datetime.datetime(1971, 1, 1, 0, 0)), 'refresh_token': FieldInfo(annotation=str, required=False, default=''), 'token_type': FieldInfo(annotation=str, required=False, default='Bearer')}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

OAuth Scopes¶

This module contains models for API v2 scopes.

class aiosu.models.scopes.Scopes(value)¶

An enumeration.

NONE = 0¶

PUBLIC = 1¶

IDENTIFY = 2¶

FRIENDS_READ = 4¶

FORUM_WRITE = 8¶

DELEGATE = 16¶

CHAT_READ = 32¶

CHAT_WRITE = 64¶

CHAT_WRITE_MANAGE = 128¶

LAZER = 256¶

classmethod from_api_list(scopes: list[str]) → Scopes¶

conjugate()¶: Returns self, the complex conjugate of any int.

bit_length()¶

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

to_bytes(length, byteorder, *, signed=False)¶

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)¶

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()¶

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real¶: the real part of a complex number

imag¶: the imaginary part of a complex number

numerator¶: the numerator of a rational number in lowest terms

denominator¶: the denominator of a rational number in lowest terms

Legacy¶

These classes are exclusive to API v1 requests.

class aiosu.models.legacy.match.Match(*, match_id: int, name: str, start_time: datetime, games: list[MatchGame], end_time: datetime | None = None)¶

Multiplayer match API object.

id: int¶

name: str¶

start_time: datetime¶

games: list[MatchGame]¶

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'end_time': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'games': FieldInfo(annotation=list[MatchGame], required=True), 'id': FieldInfo(annotation=int, required=True, alias='match_id', alias_priority=2), 'name': FieldInfo(annotation=str, required=True), 'start_time': FieldInfo(annotation=datetime, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

end_time: datetime | None¶: None if game is ongoing.

class aiosu.models.legacy.match.MatchGame(*, game_id: int, start_time: datetime, beatmap_id: int, play_mode: Gamemode, match_type: int, scoring_type: MatchScoringType, team_type: MatchTeamType, scores: list[MatchScore], mods: Mods, end_time: datetime | None = None)¶

Multiplayer game API object.

id: int¶

start_time: datetime¶

beatmap_id: int¶

mode: Gamemode¶

match_type: int¶

scoring_type: MatchScoringType¶

team_type: MatchTeamType¶

scores: list[MatchScore]¶

mods: Mods¶

end_time: datetime | None¶: None if game was aborted.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'beatmap_id': FieldInfo(annotation=int, required=True), 'end_time': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=True, alias='game_id', alias_priority=2), 'match_type': FieldInfo(annotation=int, required=True), 'mode': FieldInfo(annotation=Gamemode, required=True, alias='play_mode', alias_priority=2), 'mods': FieldInfo(annotation=Mods, required=True), 'scores': FieldInfo(annotation=list[MatchScore], required=True), 'scoring_type': FieldInfo(annotation=MatchScoringType, required=True), 'start_time': FieldInfo(annotation=datetime, required=True), 'team_type': FieldInfo(annotation=MatchTeamType, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.legacy.match.MatchScore(*, slot: int, team: MatchTeam, user_id: int, score: int, maxcombo: int, passed: bool, perfect: bool, enabled_mods: Mods, statistics: ScoreStatistics)¶

slot: int¶

team: MatchTeam¶

user_id: int¶

score: int¶

max_combo: int¶

passed: bool¶

perfect: bool¶

enabled_mods: Mods¶

statistics: ScoreStatistics¶

get_full_mods(game: MatchGame) → Mods¶

Get the mods including globals from the match.

Parameters:: game (MatchGame) – The match the score took place in
Returns:: Mods list of Mod objects
Return type:: Mods

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'enabled_mods': FieldInfo(annotation=Mods, required=True), 'max_combo': FieldInfo(annotation=int, required=True, alias='maxcombo', alias_priority=2), 'passed': FieldInfo(annotation=bool, required=True, alias='pass', alias_priority=2), 'perfect': FieldInfo(annotation=bool, required=True), 'score': FieldInfo(annotation=int, required=True), 'slot': FieldInfo(annotation=int, required=True), 'statistics': FieldInfo(annotation=ScoreStatistics, required=True), 'team': FieldInfo(annotation=MatchTeam, required=True), 'user_id': FieldInfo(annotation=int, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class aiosu.models.legacy.match.MatchScoringType(value)¶

An enumeration.

SCORE = 0¶

ACCURACY = 1¶

COMBO = 2¶

SCOREV2 = 3¶

conjugate()¶: Returns self, the complex conjugate of any int.

bit_length()¶

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

to_bytes(length, byteorder, *, signed=False)¶

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)¶

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()¶

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real¶: the real part of a complex number

imag¶: the imaginary part of a complex number

numerator¶: the numerator of a rational number in lowest terms

denominator¶: the denominator of a rational number in lowest terms

class aiosu.models.legacy.match.MatchTeam(value)¶

An enumeration.

NONE = 0¶

BLUE = 1¶

RED = 2¶

conjugate()¶: Returns self, the complex conjugate of any int.

bit_length()¶

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

to_bytes(length, byteorder, *, signed=False)¶

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)¶

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()¶

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real¶: the real part of a complex number

imag¶: the imaginary part of a complex number

numerator¶: the numerator of a rational number in lowest terms

denominator¶: the denominator of a rational number in lowest terms

class aiosu.models.legacy.match.MatchTeamType(value)¶

An enumeration.

HEADTOHEAD = 0¶

COOP = 1¶

TEAMVS = 2¶

TAGTEAMVS = 3¶

conjugate()¶: Returns self, the complex conjugate of any int.

bit_length()¶

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

to_bytes(length, byteorder, *, signed=False)¶

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

from_bytes(byteorder, *, signed=False)¶

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use `sys.byteorder’ as the byte order value.
signed: Indicates whether two’s complement is used to represent the integer.

as_integer_ratio()¶

Return integer ratio.

Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

real¶: the real part of a complex number

imag¶: the imaginary part of a complex number

numerator¶: the numerator of a rational number in lowest terms

denominator¶: the denominator of a rational number in lowest terms

class aiosu.models.legacy.replay.ReplayCompact(*, content: str, encoding: str)¶

Replay API object.

content: str¶: Encoded LZMA data of the replay

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}¶: A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'content': FieldInfo(annotation=str, required=True), 'encoding': FieldInfo(annotation=str, required=True)}¶

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

encoding: str¶: The encoding used