Module genshin.models.hoyolab.accompany

HoYoLAB character accompany models.

Classes

class AccompanyAction (**data: Any)

Expand source code

class AccompanyAction(APIModel):
    """Action that grants accompany points."""

    action: str
    points: int = Aliased("point")
    max_points_per_day: int = Aliased("max_point_per_day")
    done: bool
    jump: Optional[AccompanyJump] = None

Action that grants accompany points.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var action : str

var done : bool

var jump : AccompanyJump | None

var max_points_per_day : int

var model_config : pydantic.config.ConfigDict

var points : int

class AccompanyAvatarFrame (**data: Any)

Expand source code

class AccompanyAvatarFrame(APIModel):
    """Quarterly avatar frame reward progress."""

    config: AccompanyAvatarFrameConfig = Aliased("avatar_frame_conf")
    id: int = Aliased("avatar_frame_id")
    quarter_days: int = Aliased("accompany_quarter_days")
    accompanied_today: bool = Aliased("is_accompany_today")

Quarterly avatar frame reward progress.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var accompanied_today : bool

var config : AccompanyAvatarFrameConfig

var id : int

var model_config : pydantic.config.ConfigDict

var quarter_days : int

class AccompanyAvatarFrameConfig (**data: Any)

Expand source code

class AccompanyAvatarFrameConfig(APIModel):
    """Avatar frame reward configuration."""

    icon: str = Aliased("icon_url")
    popup_docs: Sequence[AccompanyPopupDoc] = Aliased("pop_up_doc")
    jump: AccompanyJump = Aliased("pop_up_jump")
    quarter_begin_at: int
    quarter_end_at: int
    quarter_left_seconds: int

Avatar frame reward configuration.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var icon : str

var jump : AccompanyJump

var model_config : pydantic.config.ConfigDict

var popup_docs : Sequence[AccompanyPopupDoc]

var quarter_begin_at : int

var quarter_end_at : int

var quarter_left_seconds : int

class AccompanyAwardInfo (**data: Any)

Expand source code

class AccompanyAwardInfo(APIModel):
    """Accompany rewards and point-earning actions."""

    pendants: Sequence[AccompanyPendant] = Aliased("pendant_list")
    actions: Sequence[AccompanyAction] = Aliased("action_list")
    titles: Sequence[AccompanyTitle] = Aliased("title_list")

Accompany rewards and point-earning actions.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var actions : Sequence[AccompanyAction]

var model_config : pydantic.config.ConfigDict

var pendants : Sequence[AccompanyPendant]

var titles : Sequence[AccompanyTitle]

class AccompanyCharacter (**data: Any)

Expand source code

class AccompanyCharacter(APIModel):
    """Accompany character."""

    info: AccompanyCharacterInfo = Aliased("basic")
    profile: AccompanyCharacterProfile = Aliased("attr_profile")
    attribute_ids: Sequence[int]

Accompany character.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var attribute_ids : Sequence[int]

var info : AccompanyCharacterInfo

var model_config : pydantic.config.ConfigDict

var profile : AccompanyCharacterProfile

class AccompanyCharacterAttribute (**data: Any)

Expand source code

class AccompanyCharacterAttribute(APIModel):
    """Accompany character attribute."""

    id: int
    icon: str = Aliased("icon_url")
    corner_icon: str = Aliased("corner_icon_url")

Accompany character attribute.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var corner_icon : str

var icon : str

var id : int

var model_config : pydantic.config.ConfigDict

class AccompanyCharacterDetails (**data: Any)

Expand source code

class AccompanyCharacterDetails(APIModel):
    """Accompany character page details."""

    info: AccompanyCharacterInfo = Aliased("basic")
    profile: AccompanyCharacterProfile = Aliased("attr_profile")
    accompany_info: AccompanyInfo
    voice_scripts: Mapping[str, Sequence[AccompanyVoiceLine]] = Aliased("attr_wiki_voice_script")
    videos: Sequence[AccompanyWikiVideo] = Aliased("attr_wiki_video")
    gallery: Sequence[AccompanyWikiImage] = Aliased("attr_wiki_gallery")
    widget: Optional[AccompanyWidget] = Aliased("attr_widget", default=None)
    moment_posts: Sequence[AccompanyMomentPost] = Aliased("attr_moment")
    feed_info: AccompanyFeedInfo
    game_jump_url: str
    award_info: Optional[AccompanyAwardInfo] = None
    lantern_sign: Optional[AccompanyLanternSign] = None
    avatar_frame: Optional[AccompanyAvatarFrame] = None
    stats: Optional[AccompanyTopicStats] = None
    """Topic statistics, not part of role_info but passed in by the client."""

    @field_validator("voice_scripts", mode="before")
    def __unnest_voice_scripts(cls, v: Optional[dict[str, Any]]) -> dict[str, Any]:
        return {name: script["list"] for name, script in v["scripts"].items()} if v else {}

    @field_validator("videos", mode="before")
    def __unnest_videos(cls, v: Optional[dict[str, Any]]) -> list[Any]:
        return v["videos"] if v else []

    @field_validator("gallery", mode="before")
    def __unnest_gallery(cls, v: Optional[dict[str, Any]]) -> list[Any]:
        return v["images"] if v else []

    @field_validator("moment_posts", mode="before")
    def __unnest_moment_posts(cls, v: Optional[dict[str, Any]]) -> list[Any]:
        return [post["post"] for post in v["post_list"]] if v else []

Accompany character page details.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var accompany_info : AccompanyInfo

var avatar_frame : AccompanyAvatarFrame | None

var award_info : AccompanyAwardInfo | None

var feed_info : AccompanyFeedInfo

var gallery : Sequence[AccompanyWikiImage]

var game_jump_url : str

var info : AccompanyCharacterInfo

var lantern_sign : AccompanyLanternSign | None

var model_config : pydantic.config.ConfigDict

var moment_posts : Sequence[AccompanyMomentPost]

var profile : AccompanyCharacterProfile

var stats : AccompanyTopicStats | None

Topic statistics, not part of role_info but passed in by the client.

var videos : Sequence[AccompanyWikiVideo]

var voice_scripts : Mapping[str, Sequence[AccompanyVoiceLine]]

var widget : AccompanyWidget | None

class AccompanyCharacterGame (**data: Any)

Expand source code

class AccompanyCharacterGame(APIModel):
    """Accompany character game."""

    attributes: Sequence[Sequence[AccompanyCharacterAttribute]] = Aliased("attribute_group_list")
    id: int = Aliased("game_id")
    icon: str = Aliased("game_icon")
    characters: Sequence[AccompanyCharacter] = Aliased("role_list")

    @field_validator("attributes", mode="before")
    def __unnest_attributes(cls, v: list[dict[str, Any]]) -> list[list[dict[str, Any]]]:
        return [group["attribute_list"] for group in v]

    @property
    def game(self) -> types.Game:
        if self.id == 2:
            return types.Game.GENSHIN
        if self.id == 6:
            return types.Game.STARRAIL
        if self.id == 8:
            return types.Game.ZZZ

        raise ValueError(f"Unknown game ID: {self.id}")

Accompany character game.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var attributes : Sequence[Sequence[AccompanyCharacterAttribute]]

var characters : Sequence[AccompanyCharacter]

var icon : str

var id : int

var model_config : pydantic.config.ConfigDict

Instance variables

prop game : Game

Expand source code

@property
def game(self) -> types.Game:
    if self.id == 2:
        return types.Game.GENSHIN
    if self.id == 6:
        return types.Game.STARRAIL
    if self.id == 8:
        return types.Game.ZZZ

    raise ValueError(f"Unknown game ID: {self.id}")

class AccompanyCharacterInfo (**data: Any)

Expand source code

class AccompanyCharacterInfo(APIModel):
    """Accompany character info."""

    role_id: int
    game_id: int
    name: str
    brief_name: str
    topic_id: int
    game_name: str

Accompany character info.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var brief_name : str

var game_id : int

var game_name : str

var model_config : pydantic.config.ConfigDict

var name : str

var role_id : int

var topic_id : int

class AccompanyCharacterProfile (**data: Any)

Expand source code

class AccompanyCharacterProfile(APIModel):
    """Accompany character color and images."""

    card_color: str
    bg_dark_color: str
    bg_light_color: str
    bg_card_color: str

    card_image: str = Aliased("card_img_url")
    video: str = Aliased("full_screen_video_265")
    icon: str = Aliased("icon_url")

Accompany character color and images.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var bg_card_color : str

var bg_dark_color : str

var bg_light_color : str

var card_color : str

var card_image : str

var icon : str

var model_config : pydantic.config.ConfigDict

var video : str

class AccompanyFeedInfo (**data: Any)

Expand source code

class AccompanyFeedInfo(APIModel):
    """Post counts of an accompany character's feed."""

    fan_art_posts: int = Aliased("fan_art_post_num")
    discussion_posts: int = Aliased("discussion_post_num")
    yesterday_posts: int = Aliased("yesterday_post_num")
    total_posts: int = Aliased("total_post_num")

Post counts of an accompany character's feed.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var discussion_posts : int

var fan_art_posts : int

var model_config : pydantic.config.ConfigDict

var total_posts : int

var yesterday_posts : int

class AccompanyInfo (**data: Any)

Expand source code

class AccompanyInfo(APIModel):
    """Accompany progress of a character."""

    days: int = Aliased("accompany_days")
    quarter_days: int = Aliased("accompany_quarter_days")
    accompanied_today: bool = Aliased("is_accompany_today")
    can_accompany: bool
    points: int = Aliased("accompany_point")
    available_points: int = Aliased("available_accompany_point")

Accompany progress of a character.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var accompanied_today : bool

var available_points : int

var can_accompany : bool

var days : int

var model_config : pydantic.config.ConfigDict

var points : int

var quarter_days : int

class AccompanyJump (**data: Any)

Expand source code

class AccompanyJump(APIModel):
    """Deep link to a location in the app or on the web."""

    text: str
    app_path: str
    web_path: str

Deep link to a location in the app or on the web.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var app_path : str

var model_config : pydantic.config.ConfigDict

var text : str

var web_path : str

class AccompanyLanternBonus (**data: Any)

Expand source code

class AccompanyLanternBonus(APIModel):
    """Lantern sign reward tier."""

    required_points: int = Aliased("require_accompany_points")
    pendant_id: int
    lifetime: int
    title: str
    light_icon: str = Aliased("light_icon_url")
    dark_icon: str = Aliased("dark_icon_url")
    description: str = Aliased("desc")

Lantern sign reward tier.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var dark_icon : str

var description : str

var lifetime : int

var light_icon : str

var model_config : pydantic.config.ConfigDict

var pendant_id : int

var required_points : int

var title : str

class AccompanyLanternConfig (**data: Any)

Expand source code

class AccompanyLanternConfig(APIModel):
    """Lantern sign event configuration."""

    bonuses: Sequence[AccompanyLanternBonus]
    templates: Sequence[AccompanyLanternTemplate] = Aliased("lantern_sign_templates")
    jump: AccompanyJump = Aliased("pop_up_jump")
    quarter_begin_at: int
    quarter_end_at: int
    quarter_left_seconds: int
    light_icon: str = Aliased("light_icon_url")
    dark_icon: str = Aliased("dark_icon_url")

Lantern sign event configuration.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var bonuses : Sequence[AccompanyLanternBonus]

var dark_icon : str

var jump : AccompanyJump

var light_icon : str

var model_config : pydantic.config.ConfigDict

var quarter_begin_at : int

var quarter_end_at : int

var quarter_left_seconds : int

var templates : Sequence[AccompanyLanternTemplate]

class AccompanyLanternSign (**data: Any)

Expand source code

class AccompanyLanternSign(APIModel):
    """Lantern sign event progress."""

    config: AccompanyLanternConfig = Aliased("lantern_sign_conf")
    pendant_id: int = Aliased("lantern_pendant_id")
    post_points: int
    total_post_points: int
    post_points_today: int
    accompany_points: int
    total_accompany_points: int
    accompany_days: int
    accompanied_today: bool = Aliased("is_accompany_today")
    wearing: bool
    has_got: bool
    expire_at: int

Lantern sign event progress.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var accompanied_today : bool

var accompany_days : int

var accompany_points : int

var config : AccompanyLanternConfig

var expire_at : int

var has_got : bool

var model_config : pydantic.config.ConfigDict

var pendant_id : int

var post_points : int

var post_points_today : int

var total_accompany_points : int

var total_post_points : int

var wearing : bool

class AccompanyLanternTemplate (**data: Any)

Expand source code

class AccompanyLanternTemplate(APIModel):
    """Suggested post template for the lantern sign event."""

    subject: str
    game_id: int
    classification_id: int
    topic_ids: Sequence[int]

Suggested post template for the lantern sign event.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var classification_id : int

var game_id : int

var model_config : pydantic.config.ConfigDict

var subject : str

var topic_ids : Sequence[int]

class AccompanyMomentPost (**data: Any)

Expand source code

class AccompanyMomentPost(APIModel):
    """Official post shown on an accompany character's page."""

    id: int = Aliased("post_id")
    game_id: int
    subject: str
    content: str
    lang: str
    created_at: UnixDateTime

Official post shown on an accompany character's page.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var content : str

var created_at : datetime.datetime

var game_id : int

var id : int

var lang : str

var model_config : pydantic.config.ConfigDict

var subject : str

class AccompanyPendant (**data: Any)

Expand source code

class AccompanyPendant(APIModel):
    """Cosmetic unlockable with accompany points."""

    id: int = Aliased("pendant_id")
    icon: str = Aliased("icon_url")
    lifetime: str
    source: str
    type: str = Aliased("pendant_type")
    cost: int = Aliased("point")
    award_type: str
    is_owned: bool
    can_use: bool
    in_use: bool
    jump: Optional[AccompanyJump] = Aliased("use_jump", default=None)

Cosmetic unlockable with accompany points.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var award_type : str

var can_use : bool

var cost : int

var icon : str

var id : int

var in_use : bool

var is_owned : bool

var jump : AccompanyJump | None

var lifetime : str

var model_config : pydantic.config.ConfigDict

var source : str

var type : str

class AccompanyPopupDoc (**data: Any)

Expand source code

class AccompanyPopupDoc(APIModel):
    """Avatar frame popup document."""

    day: str = Aliased("the_day")
    icon: str
    description: str = Aliased("desc")

Avatar frame popup document.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var day : str

var description : str

var icon : str

var model_config : pydantic.config.ConfigDict

class AccompanyRecentPoster (**data: Any)

Expand source code

class AccompanyRecentPoster(APIModel):
    """Recent poster in an accompany character's topic."""

    uid: int
    posted_at: UnixDateTime = Aliased("post_time")

Recent poster in an accompany character's topic.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var model_config : pydantic.config.ConfigDict

var posted_at : datetime.datetime

var uid : int

class AccompanyResult (**data: Any)

Expand source code

class AccompanyResult(APIModel):
    """Accompany result."""

    accompany_days: int
    points_increased: int = Aliased("increase_accompany_point")

Accompany result.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var accompany_days : int

var model_config : pydantic.config.ConfigDict

var points_increased : int

class AccompanyTitle (**data: Any)

Expand source code

class AccompanyTitle(APIModel):
    """Title earnable through accompanying."""

    title: str
    name: str = Aliased("title_name")
    description: str = Aliased("title_desc")
    icon: str = Aliased("icon_url")
    highlight_icon: str = Aliased("highlight_icon_url")
    is_owned: bool

Title earnable through accompanying.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var description : str

var highlight_icon : str

var icon : str

var is_owned : bool

var model_config : pydantic.config.ConfigDict

var name : str

var title : str

class AccompanyTopicStats (**data: Any)

Expand source code

class AccompanyTopicStats(APIModel):
    """Community statistics of an accompany character's topic."""

    topic_id: int
    views: int = Aliased("view_num")
    replies: int = Aliased("reply_num")
    members: int = Aliased("member_num")
    posts: int = Aliased("post_num")
    today_posts: int = Aliased("today_increase_post_num")
    week_posts: int = Aliased("seven_days_increase_post_num")
    recent_posters: Sequence[AccompanyRecentPoster] = Aliased("recent_post_user_info_list")

Community statistics of an accompany character's topic.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var members : int

var model_config : pydantic.config.ConfigDict

var posts : int

var recent_posters : Sequence[AccompanyRecentPoster]

var replies : int

var today_posts : int

var topic_id : int

var views : int

var week_posts : int

class AccompanyVoiceLine (**data: Any)

Expand source code

class AccompanyVoiceLine(APIModel):
    """Accompany character voice line."""

    voice_url: str = Aliased("voice")
    text: str = Aliased("script")

Accompany character voice line.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var model_config : pydantic.config.ConfigDict

var text : str

var voice_url : str

class AccompanyVoiceSetting (**data: Any)

Expand source code

class AccompanyVoiceSetting(APIModel):
    """Voice and subtitle language setting of an accompany character."""

    voice_lang: str
    script_lang: str
    updated_at: UnixDateTime = Aliased("setting_unix")

Voice and subtitle language setting of an accompany character.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var model_config : pydantic.config.ConfigDict

var script_lang : str

var updated_at : datetime.datetime

var voice_lang : str

class AccompanyWidget (**data: Any)

Expand source code

class AccompanyWidget(APIModel):
    """Accompany character widget image assets."""

    role_image: AccompanyWidgetImage
    component_image: AccompanyWidgetImage = Aliased("role_component_image")
    emoji_image: AccompanyWidgetImage = Aliased("emo_url")
    background_url: str = Aliased("bg_url")

Accompany character widget image assets.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var background_url : str

var component_image : AccompanyWidgetImage

var emoji_image : AccompanyWidgetImage

var model_config : pydantic.config.ConfigDict

var role_image : AccompanyWidgetImage

class AccompanyWidgetImage (**data: Any)

Expand source code

class AccompanyWidgetImage(APIModel):
    """Widget image asset in two resolutions."""

    img_2x: str
    img_3x: str

Widget image asset in two resolutions.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var img_2x : str

var img_3x : str

var model_config : pydantic.config.ConfigDict

class AccompanyWikiImage (**data: Any)

Expand source code

class AccompanyWikiImage(APIModel):
    """Accompany character wiki gallery image."""

    image_url: str
    origin_url: str
    height: int
    width: int
    size: int
    synced_at: UnixDateTime = Aliased("sync_unix")

Accompany character wiki gallery image.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var height : int

var image_url : str

var model_config : pydantic.config.ConfigDict

var origin_url : str

var size : int

var synced_at : datetime.datetime

var width : int

class AccompanyWikiVideo (**data: Any)

Expand source code

class AccompanyWikiVideo(APIModel):
    """Accompany character wiki video."""

    video_id: str
    video_url: str
    cover_url: str
    synced_at: UnixDateTime = Aliased("sync_unix")
    sort: int

Accompany character wiki video.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var cover_url : str

var model_config : pydantic.config.ConfigDict

var sort : int

var synced_at : datetime.datetime

var video_id : str

var video_url : str