mirror of
https://github.com/PaiGramTeam/SIMNet.git
synced 2024-11-27 00:05:15 +00:00
371 lines
13 KiB
Python
371 lines
13 KiB
Python
from typing import Optional, Any, Dict, List
|
|
|
|
from simnet.client.base import BaseClient
|
|
from simnet.client.routes import CALCULATOR_URL
|
|
from simnet.errors import BadRequest
|
|
from simnet.models.genshin.calculator import (
|
|
CalculatorResult,
|
|
CalculatorCharacter,
|
|
CalculatorWeapon,
|
|
CalculatorArtifact,
|
|
CalculatorFurnishing,
|
|
CalculatorCharacterDetails,
|
|
CalculatorTalent,
|
|
)
|
|
from simnet.utils.enum_ import Region
|
|
from simnet.utils.player import recognize_genshin_server
|
|
|
|
|
|
class CalculatorClient(BaseClient):
|
|
"""A client for retrieving data from Genshin's calculator component."""
|
|
|
|
async def request_calculator(
|
|
self,
|
|
endpoint: str,
|
|
*,
|
|
method: str = "POST",
|
|
lang: Optional[str] = None,
|
|
params: Optional[Dict[str, Any]] = None,
|
|
data: Optional[Dict[str, Any]] = None,
|
|
) -> Dict[str, Any]:
|
|
"""Make a request towards the calculator endpoint.
|
|
|
|
Args:
|
|
endpoint (str): The calculator endpoint to send the request to.
|
|
method (str): The HTTP method to use for the request (default "POST").
|
|
lang (str): The language to use for the request (default None).
|
|
params (dict): The parameters to include in the request URL (default None).
|
|
data (dict): The data to include in the request body (default None).
|
|
|
|
Returns:
|
|
dict: The data returned by the calculator endpoint.
|
|
"""
|
|
params = dict(params or {})
|
|
|
|
base_url = CALCULATOR_URL.get_url(self.region)
|
|
url = base_url / endpoint
|
|
|
|
if method == "GET":
|
|
params["lang"] = lang or self.lang
|
|
data = None
|
|
else:
|
|
data = dict(data or {})
|
|
data["lang"] = lang or self.lang
|
|
|
|
headers = {}
|
|
if self.region == Region.CHINESE:
|
|
headers["Referer"] = (
|
|
"https://webstatic.mihoyo.com/ys/event/e20200923adopt_calculator/index.html?"
|
|
"bbs_presentation_style=fullscreen&bbs_auth_required=true&"
|
|
"utm_source=bbs&utm_medium=mys&utm_campaign=icon#/"
|
|
)
|
|
|
|
data = await self.request_lab(
|
|
url, method=method, params=params, data=data, headers=headers
|
|
)
|
|
|
|
return data
|
|
|
|
async def _execute_calculator(
|
|
self,
|
|
data: Dict[str, Any],
|
|
*,
|
|
lang: Optional[str] = None,
|
|
) -> CalculatorResult:
|
|
"""Calculate the results of a builder.
|
|
|
|
Args:
|
|
data (dict): The data used to calculate the results.
|
|
lang (str): The language to use for the request (default None).
|
|
|
|
Returns:
|
|
CalculatorResult: The calculated results.
|
|
"""
|
|
data = await self.request_calculator("compute", lang=lang, data=data)
|
|
return CalculatorResult(**data)
|
|
|
|
async def _enable_calculator_sync(self, enabled: bool = True) -> None:
|
|
"""Enable data syncing in calculator.
|
|
|
|
Args:
|
|
enabled (bool): Whether to enable syncing (default True).
|
|
"""
|
|
await self.request_calculator(
|
|
"avatar/auth", method="POST", data=dict(avatar_auth=int(enabled))
|
|
)
|
|
|
|
async def _get_calculator_items(
|
|
self,
|
|
slug: str,
|
|
filters: Dict[str, Any],
|
|
query: Optional[str] = None,
|
|
*,
|
|
player_id: Optional[int] = None,
|
|
is_all: bool = False,
|
|
sync: bool = False,
|
|
lang: Optional[str] = None,
|
|
autoauth: bool = True,
|
|
) -> List[Dict[str, Any]]:
|
|
"""Get all items of a specific slug from a calculator.
|
|
|
|
Args:
|
|
slug (str): The slug to get the items for.
|
|
filters (dict): The filters to apply to the items.
|
|
query (str): The query to search for (default None).
|
|
player_id (int): The player ID to use for syncing (default None).
|
|
is_all (bool): Whether to include Traveler items (default False).
|
|
sync (bool): Whether to sync data from the calculator (default False).
|
|
lang (str): The language to use for the request (default None).
|
|
autoauth (bool): Whether to enable syncing if it is not already enabled (default True).
|
|
|
|
Returns:
|
|
list: A list of dictionaries representing the items retrieved from the calculator.
|
|
"""
|
|
endpoint = f"sync/{slug}/list" if sync else f"{slug}/list"
|
|
|
|
if query:
|
|
if any(filters.values()):
|
|
raise TypeError("Cannot specify a query and filter at the same time")
|
|
|
|
filters = dict(keywords=query, **filters)
|
|
|
|
payload: Dict[str, Any] = dict(page=1, size=69420, is_all=is_all, **filters)
|
|
|
|
if sync:
|
|
player_id = player_id or self.player_id
|
|
payload["uid"] = player_id
|
|
payload["region"] = recognize_genshin_server(player_id)
|
|
|
|
try:
|
|
data = await self.request_calculator(endpoint, lang=lang, data=payload)
|
|
except BadRequest as e:
|
|
if e.ret_code != -502002: # Sync not enabled
|
|
raise
|
|
if not autoauth:
|
|
raise BadRequest(e.response, "Calculator sync is not enabled") from e
|
|
|
|
await self._enable_calculator_sync()
|
|
data = await self.request_calculator(endpoint, lang=lang, data=payload)
|
|
|
|
return data["list"]
|
|
|
|
async def get_calculator_characters(
|
|
self,
|
|
*,
|
|
query: Optional[str] = None,
|
|
elements: Optional[List[int]] = None,
|
|
weapon_types: Optional[List[int]] = None,
|
|
include_traveler: bool = False,
|
|
sync: bool = False,
|
|
player_id: Optional[int] = None,
|
|
lang: Optional[str] = None,
|
|
) -> List[CalculatorCharacter]:
|
|
"""Get all characters provided by the Enhancement Progression Calculator.
|
|
|
|
Args:
|
|
query (str): The query to search for (default None).
|
|
elements (list): A list of element IDs to filter by (default None).
|
|
weapon_types (list): A list of weapon type IDs to filter by (default None).
|
|
include_traveler (bool): Whether to include Traveler characters (default False).
|
|
sync (bool): Whether to sync data from the calculator (default False).
|
|
player_id (int): The player ID to use for syncing (default None).
|
|
lang (str): The language to use for the request (default None).
|
|
|
|
Returns:
|
|
list: A list of CalculatorCharacter objects representing the characters retrieved from the calculator.
|
|
"""
|
|
data = await self._get_calculator_items(
|
|
"avatar",
|
|
lang=lang,
|
|
is_all=include_traveler,
|
|
sync=sync,
|
|
player_id=player_id,
|
|
query=query,
|
|
filters=dict(
|
|
element_attr_ids=elements or [],
|
|
weapon_cat_ids=weapon_types or [],
|
|
),
|
|
)
|
|
return [CalculatorCharacter(**i) for i in data]
|
|
|
|
async def get_calculator_weapons(
|
|
self,
|
|
*,
|
|
query: Optional[str] = None,
|
|
types: Optional[List[int]] = None,
|
|
rarities: Optional[List[int]] = None,
|
|
lang: Optional[str] = None,
|
|
) -> List[CalculatorWeapon]:
|
|
"""Get all weapons provided by the Enhancement Progression Calculator.
|
|
|
|
Args:
|
|
query (Optional[str], optional): A query string to filter the results. Defaults to None.
|
|
types (Optional[List[int]], optional): A list of weapon types to include in the results. Defaults to None.
|
|
rarities (Optional[List[int]], optional): A list of weapon rarities to include in the results.
|
|
Defaults to None.
|
|
lang (Optional[str], optional): The language to use for the calculator. Defaults to None.
|
|
|
|
Returns:
|
|
List[CalculatorWeapon]: A list of weapons provided by the Enhancement Progression Calculator.
|
|
"""
|
|
data = await self._get_calculator_items(
|
|
"weapon",
|
|
lang=lang,
|
|
query=query,
|
|
filters=dict(
|
|
weapon_cat_ids=types or [],
|
|
weapon_levels=rarities or [],
|
|
),
|
|
)
|
|
return [CalculatorWeapon(**i) for i in data]
|
|
|
|
async def get_calculator_furnishings(
|
|
self,
|
|
*,
|
|
types: Optional[int] = None,
|
|
rarities: Optional[int] = None,
|
|
lang: Optional[str] = None,
|
|
) -> List[CalculatorFurnishing]:
|
|
"""
|
|
Get all furnishings provided by the Enhancement Progression Calculator.
|
|
|
|
Args:
|
|
types (Optional[int], optional): The type of furnishings to retrieve. Defaults to None.
|
|
rarities (Optional[int], optional): The rarity of the furnishings to retrieve. Defaults to None.
|
|
lang (Optional[str], optional): The language to use for the calculator. Defaults to None.
|
|
|
|
Returns:
|
|
List[CalculatorFurnishing]: A list of furnishings provided by the Enhancement Progression Calculator.
|
|
"""
|
|
data = await self._get_calculator_items(
|
|
"furniture",
|
|
lang=lang,
|
|
filters=dict(
|
|
cat_id=types or 0,
|
|
weapon_levels=rarities or 0,
|
|
),
|
|
)
|
|
return [CalculatorFurnishing(**i) for i in data]
|
|
|
|
async def get_character_details(
|
|
self,
|
|
character: int,
|
|
*,
|
|
player_id: Optional[int] = None,
|
|
lang: Optional[str] = None,
|
|
) -> CalculatorCharacterDetails:
|
|
"""
|
|
Get the weapon, artifacts and talents of a character.
|
|
|
|
Args:
|
|
character (int): The ID of the character to retrieve details for.
|
|
player_id (Optional[int], optional): The player ID to use for the request. Defaults to None.
|
|
lang (Optional[str], optional): The language to use for the calculator. Defaults to None.
|
|
|
|
Returns:
|
|
CalculatorCharacterDetails: The details of the character.
|
|
"""
|
|
player_id = player_id or self.player_id
|
|
|
|
data = await self.request_calculator(
|
|
"sync/avatar/detail",
|
|
method="GET",
|
|
lang=lang,
|
|
params=dict(
|
|
avatar_id=int(character),
|
|
uid=player_id,
|
|
region=recognize_genshin_server(player_id),
|
|
),
|
|
)
|
|
return CalculatorCharacterDetails(**data)
|
|
|
|
async def get_character_talents(
|
|
self,
|
|
character: int,
|
|
*,
|
|
lang: Optional[str] = None,
|
|
) -> List[CalculatorTalent]:
|
|
"""Get the talents of a character.
|
|
|
|
Args:
|
|
character (int): The ID of the character to retrieve talents for.
|
|
lang (Optional[str], optional): The language to use for the calculator. Defaults to None.
|
|
|
|
Returns:
|
|
List[CalculatorTalent]: A list of talents for the specified character.
|
|
"""
|
|
data = await self.request_calculator(
|
|
"avatar/skill_list",
|
|
method="GET",
|
|
lang=lang,
|
|
params=dict(avatar_id=int(character)),
|
|
)
|
|
return [CalculatorTalent(**i) for i in data["list"]]
|
|
|
|
async def get_complete_artifact_set(
|
|
self,
|
|
artifact: int,
|
|
*,
|
|
lang: Optional[str] = None,
|
|
) -> List[CalculatorArtifact]:
|
|
"""
|
|
Get all artifacts that share a set with a specified artifact.
|
|
|
|
Args:
|
|
artifact (int): The ID of the artifact to retrieve the set for.
|
|
lang (Optional[str], optional): The language to use for the calculator. Defaults to None.
|
|
|
|
Returns:
|
|
List[CalculatorArtifact]: A list of artifacts that share a set with the specified artifact.
|
|
"""
|
|
data = await self.request_calculator(
|
|
"reliquary/set",
|
|
method="GET",
|
|
lang=lang,
|
|
params=dict(reliquary_id=int(artifact)),
|
|
)
|
|
return [CalculatorArtifact(**i) for i in data["reliquary_list"]]
|
|
|
|
async def _get_all_artifact_ids(self, artifact_id: int) -> List[int]:
|
|
"""Get all artifact IDs in the same set as a given artifact ID.
|
|
|
|
Args:
|
|
artifact_id (int): The ID of the artifact to retrieve the set for.
|
|
|
|
Returns:
|
|
List[int]: A list of artifact IDs that share a set with the specified artifact ID.
|
|
"""
|
|
others = await self.get_complete_artifact_set(artifact_id)
|
|
return [artifact_id] + [other.id for other in others]
|
|
|
|
async def get_teapot_replica_blueprint(
|
|
self,
|
|
share_code: int,
|
|
*,
|
|
region: Optional[str] = None,
|
|
player_id: Optional[int] = None,
|
|
lang: Optional[str] = None,
|
|
) -> List[CalculatorFurnishing]:
|
|
"""Get the furnishings used by a teapot replica blueprint.
|
|
|
|
Args:
|
|
share_code (int): The share code of the teapot replica blueprint to retrieve furnishings for.
|
|
region (Optional[str], optional): The region to use for the request. Defaults to None.
|
|
player_id (Optional[int], optional): The player ID to use for the request. Defaults to None.
|
|
lang (Optional[str], optional): The language to use for the calculator. Defaults to None.
|
|
|
|
Returns:
|
|
List[CalculatorFurnishing]: A list of furnishings used by the specified teapot replica blueprint.
|
|
"""
|
|
if not region:
|
|
player_id = player_id or self.player_id
|
|
region = recognize_genshin_server(player_id)
|
|
|
|
data = await self.request_calculator(
|
|
"furniture/blueprint",
|
|
method="GET",
|
|
lang=lang,
|
|
params=dict(share_code=share_code, region=region),
|
|
)
|
|
return [CalculatorFurnishing(**i) for i in data["list"]]
|