Module genshin.models.zzz.chronicle.challenge.shiyu

ZZZ Shiyu Defense models.

Classes

class ChallengeBangboo (**data: Any)

Expand source code

class ChallengeBangboo(APIModel):
    """Shiyu Defense bangboo model."""

    id: int
    rarity: typing.Literal["S", "A"]
    level: int
    icon: str = Aliased("bangboo_rectangle_url")

Shiyu Defense bangboo model.

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

• ShiyuDefenseBangboo

Class variables

var icon : str

var id : int

var level : int

var model_config : pydantic.config.ConfigDict

var rarity : Literal['S', 'A']

class ShiyuDefenseBangboo (**data: Any)

Expand source code

class ShiyuDefenseBangboo(ChallengeBangboo):
    """Shiyu Defense bangboo model."""

Shiyu Defense bangboo model.

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

• ChallengeBangboo
• APIModel
• pydantic.main.BaseModel

Class variables

var icon : str

var id : int

var level : int

var model_config : pydantic.config.ConfigDict

var rarity : Literal['S', 'A']

class ShiyuDefenseBuff (**data: Any)

Expand source code

class ShiyuDefenseBuff(APIModel):
    """Shiyu Defense buff model."""

    name: str = Aliased("title")
    description: str = Aliased("text")

Shiyu Defense buff model.

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 model_config : pydantic.config.ConfigDict

var name : str

class ShiyuDefenseCharacter (**data: Any)

Expand source code

class ShiyuDefenseCharacter(APIModel):
    """Shiyu Defense character model."""

    id: int
    level: int
    rarity: typing.Literal["S", "A"]
    element: ZZZElementType = Aliased("element_type")
    icon: str = Aliased("role_square_url")
    mindscape: int = Aliased("rank")

Shiyu Defense character model.

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 element : ZZZElementType

var icon : str

var id : int

var level : int

var mindscape : int

var model_config : pydantic.config.ConfigDict

var rarity : Literal['S', 'A']

class ShiyuDefenseFloor (**data: Any)

Expand source code

class ShiyuDefenseFloor(APIModel):
    """Shiyu Defense floor model."""

    index: int = Aliased("layer_index")
    rating: typing.Literal["S", "A", "B"]
    id: int = Aliased("layer_id")
    buffs: list[ShiyuDefenseBuff]
    node_1: ShiyuDefenseNode
    node_2: ShiyuDefenseNode
    challenge_time: DateTime = Aliased("floor_challenge_time")
    name: str = Aliased("zone_name")

Shiyu Defense floor model.

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 : list[ShiyuDefenseBuff]

var challenge_time : datetime.datetime

var id : int

var index : int

var model_config : pydantic.config.ConfigDict

var name : str

var node_1 : ShiyuDefenseNode

var node_2 : ShiyuDefenseNode

var rating : Literal['B', 'A', 'S']

class ShiyuDefenseMonster (**data: Any)

Expand source code

class ShiyuDefenseMonster(APIModel):
    """Shiyu Defense monster model."""

    id: int
    name: str
    weakness: typing.Union[ZZZElementType, int] = Aliased(
        "weak_element_type", deprecated="ShiyuDefenseMonster.weakness doesn't return anything meaningful anymore."
    )
    level: int
    element_effects: ShiyuMonsterElementEffects

    @pydantic.model_validator(mode="before")
    @classmethod
    def __nest_element_effects(cls, v: dict[str, typing.Any]) -> dict[str, typing.Any]:
        v["element_effects"] = {
            "ice_weakness": v["ice_weakness"],
            "fire_weakness": v["fire_weakness"],
            "elec_weakness": v["elec_weakness"],
            "ether_weakness": v["ether_weakness"],
            "physics_weakness": v["physics_weakness"],
        }
        return v

Shiyu Defense monster model.

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 element_effects : ShiyuMonsterElementEffects

var id : int

var level : int

var model_config : pydantic.config.ConfigDict

var name : str

Instance variables

var weakness : ZZZElementType | int

Expand source code

def __get__(self, obj: BaseModel | None, obj_type: type[BaseModel] | None = None) -> Any:
    if obj is None:
        if self.wrapped_property is not None:
            return self.wrapped_property.__get__(None, obj_type)
        raise AttributeError(self.field_name)

    warnings.warn(self.msg, DeprecationWarning, stacklevel=2)

    if self.wrapped_property is not None:
        return self.wrapped_property.__get__(obj, obj_type)
    return obj.__dict__[self.field_name]

Read-only data descriptor used to emit a runtime deprecation warning before accessing a deprecated field.

Attributes

msg

The deprecation message to be emitted.

wrapped_property

The property instance if the deprecated field is a computed field, or None.

field_name

The name of the field being deprecated.

class ShiyuDefenseNode (**data: Any)

Expand source code

class ShiyuDefenseNode(APIModel):
    """Shiyu Defense node model."""

    characters: list[ShiyuDefenseCharacter] = Aliased("avatars")
    bangboo: typing.Optional[ShiyuDefenseBangboo] = Aliased("buddy", default=None)
    recommended_elements: list[ZZZElementType] = Aliased("element_type_list")
    enemies: list[ShiyuDefenseMonster] = Aliased("monster_info")
    battle_time: typing.Optional[datetime.timedelta] = None

    @pydantic.field_validator("enemies", mode="before")
    @classmethod
    def __convert_enemies(cls, value: dict[typing.Literal["level", "list"], typing.Any]) -> list[ShiyuDefenseMonster]:
        level = value["level"]
        result: list[ShiyuDefenseMonster] = []
        for monster in value["list"]:
            monster["level"] = level
            result.append(ShiyuDefenseMonster(**monster))
        return result

Shiyu Defense node model.

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 bangboo : ShiyuDefenseBangboo | None

var battle_time : datetime.timedelta | None

var characters : list[ShiyuDefenseCharacter]

var enemies : list[ShiyuDefenseMonster]

var model_config : pydantic.config.ConfigDict

var recommended_elements : list[ZZZElementType]

class ShiyuDefense (**data: Any)

Expand source code

class ShiyuDefenseV1(APIModel):
    """ZZZ Shiyu Defense V1 model."""

    schedule_id: int
    begin_time: typing.Optional[DateTime] = Aliased("hadal_begin_time")
    end_time: typing.Optional[DateTime] = Aliased("hadal_end_time")
    has_data: bool
    ratings: typing.Mapping[typing.Literal["S", "A", "B"], int] = Aliased("rating_list")
    floors: list[ShiyuDefenseFloor] = Aliased("all_floor_detail")
    fastest_clear_time: int = Aliased("fast_layer_time")
    """Fastest clear time this season in seconds."""
    max_floor: int = Aliased("max_layer")

    @pydantic.field_validator("ratings", mode="before")
    @classmethod
    def __convert_ratings(
        cls, v: list[dict[typing.Literal["times", "rating"], typing.Any]]
    ) -> typing.Mapping[typing.Literal["S", "A", "B"], int]:
        return {d["rating"]: d["times"] for d in v}

    @pydantic.computed_field  # type: ignore[prop-decorator]
    @property
    def total_clear_time(self) -> int:
        """Total clear time for all floors in seconds."""
        total = 0
        for floor in self.floors:
            for node in (floor.node_1, floor.node_2):
                if node.battle_time is None:
                    continue
                total += int(node.battle_time.total_seconds())
        return total

ZZZ Shiyu Defense V1 model.

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 begin_time : datetime.datetime | None

var end_time : datetime.datetime | None

var fastest_clear_time : int

Fastest clear time this season in seconds.

var floors : list[ShiyuDefenseFloor]

var has_data : bool

var max_floor : int

var model_config : pydantic.config.ConfigDict

var ratings : Mapping[Literal['S', 'A', 'B'], int]

var schedule_id : int

Instance variables

prop total_clear_time : int

Expand source code

@pydantic.computed_field  # type: ignore[prop-decorator]
@property
def total_clear_time(self) -> int:
    """Total clear time for all floors in seconds."""
    total = 0
    for floor in self.floors:
        for node in (floor.node_1, floor.node_2):
            if node.battle_time is None:
                continue
            total += int(node.battle_time.total_seconds())
    return total

Total clear time for all floors in seconds.

class ShiyuDefenseV1 (**data: Any)

Expand source code

class ShiyuDefenseV1(APIModel):
    """ZZZ Shiyu Defense V1 model."""

    schedule_id: int
    begin_time: typing.Optional[DateTime] = Aliased("hadal_begin_time")
    end_time: typing.Optional[DateTime] = Aliased("hadal_end_time")
    has_data: bool
    ratings: typing.Mapping[typing.Literal["S", "A", "B"], int] = Aliased("rating_list")
    floors: list[ShiyuDefenseFloor] = Aliased("all_floor_detail")
    fastest_clear_time: int = Aliased("fast_layer_time")
    """Fastest clear time this season in seconds."""
    max_floor: int = Aliased("max_layer")

    @pydantic.field_validator("ratings", mode="before")
    @classmethod
    def __convert_ratings(
        cls, v: list[dict[typing.Literal["times", "rating"], typing.Any]]
    ) -> typing.Mapping[typing.Literal["S", "A", "B"], int]:
        return {d["rating"]: d["times"] for d in v}

    @pydantic.computed_field  # type: ignore[prop-decorator]
    @property
    def total_clear_time(self) -> int:
        """Total clear time for all floors in seconds."""
        total = 0
        for floor in self.floors:
            for node in (floor.node_1, floor.node_2):
                if node.battle_time is None:
                    continue
                total += int(node.battle_time.total_seconds())
        return total

ZZZ Shiyu Defense V1 model.

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 begin_time : datetime.datetime | None

var end_time : datetime.datetime | None

var fastest_clear_time : int

Fastest clear time this season in seconds.

var floors : list[ShiyuDefenseFloor]

var has_data : bool

var max_floor : int

var model_config : pydantic.config.ConfigDict

var ratings : Mapping[Literal['S', 'A', 'B'], int]

var schedule_id : int

Instance variables

prop total_clear_time : int

Expand source code

@pydantic.computed_field  # type: ignore[prop-decorator]
@property
def total_clear_time(self) -> int:
    """Total clear time for all floors in seconds."""
    total = 0
    for floor in self.floors:
        for node in (floor.node_1, floor.node_2):
            if node.battle_time is None:
                continue
            total += int(node.battle_time.total_seconds())
    return total

Total clear time for all floors in seconds.

class ShiyuDefenseV2 (**data: Any)

Expand source code

class ShiyuDefenseV2(APIModel):
    """ZZZ Shiyu Defense V2 model."""

    schedule_id: int = Aliased("zone_id")
    begin_time: typing.Optional[DateTime] = Aliased("hadal_begin_time")
    end_time: typing.Optional[DateTime] = Aliased("hadal_end_time")
    passed_fifth_floor: bool = Aliased("pass_fifth_floor")

    brief_info: typing.Optional[ShiyuV2BriefInfo] = Aliased("brief", default=None)
    fourth_frontier: typing.Optional[ShiyuV2FourthFloor] = Aliased("fourth_layer_detail", default=None)
    fifth_frontier: typing.Optional[ShiyuV2FifthFloor] = Aliased("fitfh_layer_detail", default=None)  # Nice typo hoyo

    player_nickname: str = Aliased("nick_name")
    player_avatar: str = Aliased("icon")

ZZZ Shiyu Defense V2 model.

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 begin_time : datetime.datetime | None

var brief_info : genshin.models.zzz.chronicle.challenge.shiyu.ShiyuV2BriefInfo | None

var end_time : datetime.datetime | None

var fifth_frontier : ShiyuV2FifthFloor | None

var fourth_frontier : ShiyuV2FourthFloor | None

var model_config : pydantic.config.ConfigDict

var passed_fifth_floor : bool

var player_avatar : str

var player_nickname : str

var schedule_id : int

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

Expand source code

class ShiyuMonsterElementEffect(enum.IntEnum):
    """Shiyu Defense monster element effect enum."""

    WEAKNESS = 1
    RESISTANCE = -1
    NEUTRAL = 0

Shiyu Defense monster element effect enum.

Ancestors

• enum.IntEnum
• builtins.int
• enum.Enum

Class variables

var NEUTRAL

var RESISTANCE

var WEAKNESS

class ShiyuMonsterElementEffects (**data: Any)

Expand source code

class ShiyuMonsterElementEffects(pydantic.BaseModel):
    """Shiyu Defense monster element effects model."""

    ice: ShiyuMonsterElementEffect = Aliased("ice_weakness")
    fire: ShiyuMonsterElementEffect = Aliased("fire_weakness")
    electric: ShiyuMonsterElementEffect = Aliased("elec_weakness")
    ether: ShiyuMonsterElementEffect = Aliased("ether_weakness")
    physical: ShiyuMonsterElementEffect = Aliased("physics_weakness")

Shiyu Defense monster element effects model.

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

• pydantic.main.BaseModel

Class variables

var electric : ShiyuMonsterElementEffect

var ether : ShiyuMonsterElementEffect

var fire : ShiyuMonsterElementEffect

var ice : ShiyuMonsterElementEffect

var model_config

var physical : ShiyuMonsterElementEffect

class ShiyuV2FifthFloor (**data: Any)

Expand source code

class ShiyuV2FifthFloor(APIModel):
    """ZZZ Shiyu Defense V2 fifth floor model."""

    layers: typing.Sequence[ShiyuV2FifthFloorLayer] = Aliased("layer_challenge_info_list")

ZZZ Shiyu Defense V2 fifth floor model.

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 layers : Sequence[ShiyuV2FifthFloorLayer]

var model_config : pydantic.config.ConfigDict

class ShiyuV2FifthFloorLayer (**data: Any)

Expand source code

class ShiyuV2FifthFloorLayer(APIModel):
    """ZZZ Shiyu Defense V2 fifth floor layer model."""

    id: int = Aliased("layer_id")
    rating: typing.Literal["S", "A", "B"]
    buff: ShiyuDefenseBuff = Aliased("buffer")
    score: int
    max_score: int
    clear_time: typing.Optional[int] = Aliased("battle_time", default=None)
    """Clear time in seconds."""
    boss_icon: str = Aliased("monster_pic")
    bangboo: typing.Optional[ShiyuDefenseBangboo] = Aliased("buddy", default=None)
    characters: typing.Sequence[ShiyuDefenseCharacter] = Aliased("avatar_list")

ZZZ Shiyu Defense V2 fifth floor layer model.

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 bangboo : ShiyuDefenseBangboo | None

var boss_icon : str

var buff : ShiyuDefenseBuff

var characters : Sequence[ShiyuDefenseCharacter]

var clear_time : int | None

Clear time in seconds.

var id : int

var max_score : int

var model_config : pydantic.config.ConfigDict

var rating : Literal['B', 'A', 'S']

var score : int

class ShiyuV2FourthFloor (**data: Any)

Expand source code

class ShiyuV2FourthFloor(APIModel):
    """ZZZ Shiyu Defense V2 fourth floor model."""

    buff: ShiyuDefenseBuff = Aliased("buffer")
    challenge_time: DateTime
    rating: typing.Literal["S", "A", "B"]
    layers: typing.Sequence[ShiyuV2FourthFloorLayer] = Aliased("layer_challenge_info_list")

ZZZ Shiyu Defense V2 fourth floor model.

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 buff : ShiyuDefenseBuff

var challenge_time : datetime.datetime

var layers : Sequence[ShiyuV2FourthFloorLayer]

var model_config : pydantic.config.ConfigDict

var rating : Literal['B', 'A', 'S']

class ShiyuV2FourthFloorLayer (**data: Any)

Expand source code

class ShiyuV2FourthFloorLayer(APIModel):
    """ZZZ Shiyu Defense V2 fourth floor layer model."""

    id: int = Aliased("layer_id")
    clear_time: typing.Optional[int] = Aliased("battle_time", default=None)
    """Clear time in seconds."""
    characters: typing.Sequence[ShiyuDefenseCharacter] = Aliased("avatar_list")
    bangboo: typing.Optional[ShiyuDefenseBangboo] = Aliased("buddy", default=None)

ZZZ Shiyu Defense V2 fourth floor layer model.

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 bangboo : ShiyuDefenseBangboo | None

var characters : Sequence[ShiyuDefenseCharacter]

var clear_time : int | None

Clear time in seconds.

var id : int

var model_config : pydantic.config.ConfigDict