Module genshin.models.starrail.rpgsimulator

HSR Lineup Simulator.

Classes

class APCShadowLineup (**data: Any)

Expand source code

class APCShadowLineup(StarRailLineup):
    """A Apocalyptic Shadow lineup."""

    detail: LineupDetail = Aliased("boss_info")
    node1_challenged_at: DateTime = Aliased("challenge_time")
    node2_challenged_at: DateTime = Aliased("challenge_time_node2")

A Apocalyptic Shadow lineup.

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

• StarRailLineup
• APIModel
• pydantic.main.BaseModel

Class variables

var detail : LineupDetail

var model_config : pydantic.config.ConfigDict

var node1_challenged_at : datetime.datetime

var node2_challenged_at : datetime.datetime

class APCShadowLineupResponse (**data: Any)

Expand source code

class APCShadowLineupResponse(APIModel):
    """Response for Apocalyptic Shadow lineups."""

    lineups: typing.Sequence[APCShadowLineup] = Aliased("list")
    next_page_token: str

Response for Apocalyptic Shadow lineups.

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 lineups : Sequence[APCShadowLineup]

var model_config : pydantic.config.ConfigDict

var next_page_token : str

class APCShadowSchedule (**data: Any)

Expand source code

class APCShadowSchedule(StarRailGameModeSchedule):
    """Apocalyptic Shadow schedule."""

    buff: StarRailGameModeBuff
    node1_buffs: typing.Sequence[StarRailGameModeBuff] = Aliased("addition_buff_1")
    node2_buffs: typing.Sequence[StarRailGameModeBuff] = Aliased("addition_buff_2")

    @pydantic.model_validator(mode="before")
    @classmethod
    def __convert_buffs(cls, v: dict[str, typing.Any]) -> dict[str, typing.Any]:
        v["buff"] = {"name": v["maze_buff_name_mi18n"], "desc": v["maze_buff_desc_mi18n"], "icon": v["buff_icon"]}
        return v

Apocalyptic Shadow schedule.

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

• StarRailGameModeSchedule
• APIModel
• pydantic.main.BaseModel

Class variables

var buff : StarRailGameModeBuff

var model_config : pydantic.config.ConfigDict

var node1_buffs : Sequence[StarRailGameModeBuff]

var node2_buffs : Sequence[StarRailGameModeBuff]

class LineupDetail (**data: Any)

Expand source code

class LineupDetail(APIModel):
    """Detail for a lineup."""

    buffs: typing.Sequence[StarRailGameModeBuff] = Aliased("buff_list")
    points: int

Detail for a lineup.

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 buffs : Sequence[StarRailGameModeBuff]

var model_config : pydantic.config.ConfigDict

var points : int

class MOCSchedule (**data: Any)

Expand source code

class MOCSchedule(StarRailGameModeSchedule):
    """Memory of Chaos schedule."""

    buff: StarRailGameModeBuff

    @pydantic.model_validator(mode="before")
    @classmethod
    def __convert_buffs(cls, v: dict[str, typing.Any]) -> dict[str, typing.Any]:
        v["buff"] = {"name": v["maze_buff_name_mi18n"], "desc": v["maze_buff_desc_mi18n"]}
        return v

Memory of Chaos schedule.

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

• StarRailGameModeSchedule
• APIModel
• pydantic.main.BaseModel

Class variables

var buff : StarRailGameModeBuff

var model_config : pydantic.config.ConfigDict

class PureFictionLineup (**data: Any)

Expand source code

class PureFictionLineup(StarRailLineup):
    """A Pure Fiction lineup."""

    detail: LineupDetail = Aliased("story_info")
    node1_challenged_at: DateTime = Aliased("challenge_time")
    node2_challenged_at: DateTime = Aliased("challenge_time_node2")

A Pure Fiction lineup.

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

• StarRailLineup
• APIModel
• pydantic.main.BaseModel

Class variables

var detail : LineupDetail

var model_config : pydantic.config.ConfigDict

var node1_challenged_at : datetime.datetime

var node2_challenged_at : datetime.datetime

class PureFictionLineupResponse (**data: Any)

Expand source code

class PureFictionLineupResponse(APIModel):
    """Response for Pure Fiction lineups."""

    lineups: typing.Sequence[PureFictionLineup] = Aliased("list")
    next_page_token: str

Response for Pure Fiction lineups.

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 lineups : Sequence[PureFictionLineup]

var model_config : pydantic.config.ConfigDict

var next_page_token : str

class PureFictionSchedule (**data: Any)

Expand source code

class PureFictionSchedule(StarRailGameModeSchedule):
    """Pure Future schedule."""

    buffs: typing.Sequence[StarRailGameModeBuff] = Aliased("addition_buff")
    default_buffs: typing.Sequence[StarRailGameModeBuff] = Aliased("sub_maze_buff_list")

Pure Future schedule.

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

• StarRailGameModeSchedule
• APIModel
• pydantic.main.BaseModel

Class variables

var buffs : Sequence[StarRailGameModeBuff]

var default_buffs : Sequence[StarRailGameModeBuff]

var model_config : pydantic.config.ConfigDict

class StarRailGameMode (**data: Any)

Expand source code

class StarRailGameMode(APIModel):
    """HSR game mode, like MOC."""

    id: int
    name: str
    floors: typing.Sequence[StarRailGameModeFloor]
    type: StarRailGameModeType = Aliased("root_type")

    @pydantic.model_validator(mode="before")
    @classmethod
    def __unnest_children(cls, v: dict[str, typing.Any]) -> dict[str, typing.Any]:
        """Unnest the children field."""
        if not (children := v.get("children")):
            msg = "Missing 'children' field in HSRGameMode."
            raise ValueError(msg)

        v["floors"] = children[0]["children"]
        v["name"] = children[0]["name"]
        return v

HSR game mode, like MOC.

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 floors : Sequence[StarRailGameModeFloor]

var id : int

var model_config : pydantic.config.ConfigDict

var name : str

var type : StarRailGameModeType

class StarRailGameModeBuff (**data: Any)

Expand source code

class StarRailGameModeBuff(APIModel):
    """HSR game mode buff."""

    name: str
    desc: str
    icon: typing.Optional[str] = None
    simple_desc: typing.Optional[str] = None

HSR game mode buff.

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 desc : str

var icon : str | None

var model_config : pydantic.config.ConfigDict

var name : str

var simple_desc : str | None

class StarRailGameModeFloor (**data: Any)

Expand source code

class StarRailGameModeFloor(APIModel):
    """A floor of a game mode, like MOC Stage 1."""

    id: int
    name: str
    floor: int

    @pydantic.model_validator(mode="before")
    @classmethod
    def __extract_floor(cls, v: dict[str, typing.Any]) -> dict[str, typing.Any]:
        extend = v["extend"]
        v["floor"] = extend["floor"]
        return v

A floor of a game mode, like MOC Stage 1.

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 floor : int

var id : int

var model_config : pydantic.config.ConfigDict

var name : str

class StarRailGameModeSchedule (**data: Any)

Expand source code

class StarRailGameModeSchedule(APIModel):
    """Base HSR lineup game mode schedule."""

    id: int = Aliased("group_id")
    name: str = Aliased("name_mi18n")
    start_time: datetime.datetime = Aliased("schedule_begin_time")
    end_time: datetime.datetime = Aliased("schedule_end_time")

    is_now: bool
    is_show: bool
    floor_nums: int

Base HSR lineup game mode schedule.

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

Subclasses

• APCShadowSchedule
• MOCSchedule
• PureFictionSchedule

Class variables

var end_time : datetime.datetime

var floor_nums : int

var id : int

var is_now : bool

var is_show : bool

var model_config : pydantic.config.ConfigDict

var name : str

var start_time : datetime.datetime

class StarRailGameModeType (value, names=None, *, module=None, qualname=None, type=None, start=1)

Expand source code

class StarRailGameModeType(str, Enum):
    """HSR lineup game mode enum."""

    MOC = "Chasm"
    """Memory of Chaos."""
    PURE_FICTION = "Story"
    """Pure Fiction."""
    APC_SHADOW = "Boss"
    """Apocalyptic Shadow."""
    ANOMALY_ARBITRATION = "Peak"
    """Anomaly Arbitration."""

HSR lineup game mode enum.

Ancestors

• builtins.str
• enum.Enum

Class variables

var ANOMALY_ARBITRATION

Anomaly Arbitration.

var APC_SHADOW

Apocalyptic Shadow.

var MOC

Memory of Chaos.

var PURE_FICTION

Pure Fiction.

class StarRailLineup (**data: Any)

Expand source code

class StarRailLineup(APIModel):
    """A HSR lineup."""

    id: str
    player: StarRailLineupPlayer
    type: StarRailGameModeType = Aliased("lineup_type")

    title: str
    description: str
    likes: int = Aliased("like_cnt")
    comments: int = Aliased("comment_cnt")
    favorites: int = Aliased("favour_cnt")
    views: int = Aliased("view_cnt")

    created_at: datetime.datetime
    last_edited_at: datetime.datetime = Aliased("last_edit")

    stars: int = Aliased("star_num")
    cycles_taken: int = Aliased("round_num")

    characters: typing.Sequence[typing.Sequence[character.StarRailLineupCharacter]] = Aliased("avatar_group")

    @pydantic.field_validator("characters", mode="before")
    @classmethod
    def __unnest_characters(
        cls, v: typing.Sequence[dict[str, typing.Any]]
    ) -> typing.Sequence[typing.Sequence[dict[str, typing.Any]]]:
        # Merge relic info from "group"
        for g in v:
            group = g["group"]

            for avatar in g["avatar_details"]:
                group_avatar = next((a for a in group if a["item_id"] == str(avatar["id"])), None)
                if not group_avatar:
                    continue

                relics = group_avatar.get("relics", []) + group_avatar.get("relic_sides", [])

                for relic in avatar.get("relics", []):
                    group_avatar_relic = next((r for r in relics if r["item_id"] == str(relic["id"])), None)
                    if not group_avatar_relic:
                        continue

                    relic.update(group_avatar_relic)

        return [g["avatar_details"] for g in v]

    @pydantic.model_validator(mode="before")
    @classmethod
    def __nest_player(cls, v: dict[str, typing.Any]) -> dict[str, typing.Any]:
        """Nest the player field."""
        v["player"] = {
            "uid": v["account_uid"],
            "nickname": v["nickname"],
            "avatar_url": v["avatar_url"],
            "level": v["game_level"],
        }
        return v

A HSR lineup.

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

Subclasses

• APCShadowLineup
• PureFictionLineup

Class variables

var characters : Sequence[Sequence[StarRailLineupCharacter]]

var comments : int

var created_at : datetime.datetime

var cycles_taken : int

var description : str

var favorites : int

var id : str

var last_edited_at : datetime.datetime

var likes : int

var model_config : pydantic.config.ConfigDict

var player : StarRailLineupPlayer

var stars : int

var title : str

var type : StarRailGameModeType

var views : int

class StarRailLineupPlayer (**data: Any)

Expand source code

class StarRailLineupPlayer(APIModel):
    """A HSR lineup player."""

    uid: str
    nickname: str
    avatar_url: str
    level: int

A HSR lineup player.

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

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

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

Ancestors

• APIModel
• pydantic.main.BaseModel

Class variables

var avatar_url : str

var level : int

var model_config : pydantic.config.ConfigDict

var nickname : str

var uid : str

class StarRailLineupResponse (**data: Any)

Expand source code

class StarRailLineupResponse(APIModel):
    """Response for HSR lineups."""

    lineups: typing.Sequence[StarRailLineup] = Aliased("list")
    next_page_token: str

Response for HSR lineups.

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 lineups : Sequence[StarRailLineup]

var model_config : pydantic.config.ConfigDict

var next_page_token : str