def __get_allowed_item_names(items_data: EntitiesData,
not_allowed_item_names: List[str]) -> List[str]:
result = []
for item_design_data in items_data.values():
if ITEM_DESIGN_DESCRIPTION_PROPERTY_NAME in item_design_data.keys():
item_name = item_design_data[ITEM_DESIGN_DESCRIPTION_PROPERTY_NAME]
if item_name:
item_name = core.fix_allowed_value_candidate(item_name)
if len(item_name) < settings.MIN_ENTITY_NAME_LENGTH:
result.append(item_name)
else:
item_name_parts = item_name.split(' ')
for item_name_part in item_name_parts:
part_length = len(item_name_part)
length_matches = part_length > 1 and part_length < settings.MIN_ENTITY_NAME_LENGTH
is_proper_name = item_name_part == item_name_part.upper(
)
if length_matches and is_proper_name:
try:
int(item_name_part)
continue
except:
if item_name_part not in not_allowed_item_names:
result.append(item_name_part)
if result:
result = list(set(result))
return result
async def get_user_infos_from_tournament_data_by_name(
user_name: str, users_data: EntitiesData) -> List[EntityInfo]:
user_name_lower = user_name.lower()
result = {
user_id: user_info
for (user_id, user_info) in users_data.items()
if user_name_lower in user_info.get(
user.USER_DESCRIPTION_PROPERTY_NAME, '').lower()
}
user_infos_current = await __get_users_data(user_name)
if user_infos_current:
for user_info in user_infos_current.values():
user_id = user_info[user.USER_KEY_NAME]
if user_id in users_data:
current_user_info = await __get_user_info_by_id(user_id) or {}
current_user_name = current_user_info.get(
user.USER_DESCRIPTION_PROPERTY_NAME)
if user_id not in result:
result[user_id] = users_data[user_id]
if current_user_name and current_user_name != result[user_id][
user.USER_DESCRIPTION_PROPERTY_NAME]:
result[user_id]['CurrentName'] = current_user_name
else:
for tournament_user_id, tournament_user_info in result.items():
user_info = await __get_user_info_by_id(tournament_user_id)
if result[tournament_user_id][
user.USER_DESCRIPTION_PROPERTY_NAME] != user_info[
user.USER_DESCRIPTION_PROPERTY_NAME]:
result[tournament_user_id]['CurrentName'] = user_info[
user.USER_DESCRIPTION_PROPERTY_NAME]
return list(result.values())
def __get_title_upgrades(upgrades_infos_count: int,
items_data: EntitiesData) -> str:
items_names_list = utils.format.get_or_list(
sorted(item_info[ITEM_DESIGN_DESCRIPTION_PROPERTY_NAME]
for item_info in items_data.values()))
result = f'{upgrades_infos_count} crafting recipes requiring: {items_names_list}'
return result
def get_research_details_by_id(research_design_id: str, researches_data: EntitiesData) -> entity.EntityDetails:
if research_design_id:
if research_design_id and research_design_id in researches_data.keys():
research_info = researches_data[research_design_id]
research_details = __create_research_details_from_info(research_info, researches_data)
return research_details
return None
def get_item_details_by_id(
item_design_id: str, items_data: EntitiesData,
trainings_data: EntitiesData) -> entity.EntityDetails:
if item_design_id and item_design_id in items_data.keys():
return __create_base_details_from_info(items_data[item_design_id],
items_data, trainings_data)
else:
return None
async def get_entity_info_by_name(
self,
entity_name: str,
entities_data: EntitiesData = None) -> Dict[str, object]:
entities_data = entities_data or await self.get_data_dict3()
entity_id = await self.get_entity_id_by_name(
entity_name, entities_data=entities_data)
return entities_data.get(entity_id, None)
def __get_parents(item_info: EntityInfo, items_data: EntitiesData) -> List[EntityInfo]:
item_design_id = item_info.get(ITEM_DESIGN_KEY_NAME)
root_item_design_id = item_info.get('RootItemDesignId')
result = []
if entity.entity_property_has_value(root_item_design_id) and item_design_id != root_item_design_id:
parent_info = items_data.get(root_item_design_id)
if parent_info:
result = __get_parents(parent_info, items_data)
result.append(parent_info)
return result
def __get_upgrades_for(item_id: str, items_data: EntitiesData) -> List[Optional[EntityInfo]]:
# iterate through item_design_data and return every item_design containing the item id in question in property 'Ingredients'
result = []
for item_info in items_data.values():
ingredient_item_ids = list(__get_ingredients_dict(item_info['Ingredients']).keys())
if item_id in ingredient_item_ids:
result.append(item_info)
if not result:
result = [None]
return result
def filter_targets(user_infos: List[EntityInfo],
division_design_id: str,
last_month_user_data: EntitiesData,
current_fleet_data: EntitiesData = {},
min_star_value: int = None,
max_star_value: int = None,
min_trophies_value: int = None,
max_trophies_value: int = None,
max_highest_trophies: int = None) -> List[EntityInfo]:
result = []
for user_info in user_infos:
current_division_design_id = current_fleet_data.get(
user_info.get(fleet.FLEET_KEY_NAME),
{}).get(DIVISION_DESIGN_KEY_NAME)
user_division_design_id = user_info.get('Alliance', {}).get(
DIVISION_DESIGN_KEY_NAME, '0')
alliance_division_design_id = current_division_design_id or user_division_design_id
trophies = int(user_info.get('Trophy', 0))
highest_trophies = int(user_info.get('HighestTrophy', 0))
division_matches = division_design_id == alliance_division_design_id
if division_matches and (
not min_trophies_value or trophies >= min_trophies_value) and (
not max_trophies_value or trophies <= max_trophies_value
) and (not max_highest_trophies
or highest_trophies <= max_highest_trophies):
star_value, _ = user.get_star_value_from_user_info(
user_info, star_count=user_info.get('AllianceScore'))
if (not min_star_value or star_value >= min_star_value) and (
not max_star_value or star_value <= max_star_value):
user_id = user_info[user.USER_KEY_NAME]
user_info['StarValue'] = star_value or 0
user_info['LastMonthStarValue'] = last_month_user_data.get(
user_id, {}).get('AllianceScore') or '-'
result.append(user_info)
result = sorted(
result,
key=lambda user_info:
(user_info.get('StarValue', 0), int(user_info.get('AllianceScore', 0)),
int(user_info.get('Trophy', 0))),
reverse=True)
return result
def __get_item_infos_by_name(
item_name: str,
items_data: EntitiesData,
return_best_match: bool = False) -> List[EntityInfo]:
item_design_ids = __get_item_design_ids_from_name(item_name, items_data)
result = [
items_data[item_design_id] for item_design_id in item_design_ids
if item_design_id in items_data.keys()
]
if result:
get_best_match = return_best_match or utils.is_str_in_list(
item_name, ALLOWED_ITEM_NAMES, case_sensitive=False
) and len(item_name) < settings.MIN_ENTITY_NAME_LENGTH - 1
if get_best_match:
result = [result[0]]
return result
async def get_user_details_by_info(
ctx: Context,
user_info: EntityInfo,
max_tourney_battle_attempts: int = None,
retrieved_at: datetime = None,
past_fleet_infos: EntitiesData = None,
as_embed: bool = settings.USE_EMBEDS) -> Union[List[Embed], List[str]]:
is_past_data = past_fleet_infos is not None and past_fleet_infos
user_id = user_info[USER_KEY_NAME]
retrieved_at = retrieved_at or utils.get_utc_now()
tourney_running = tourney.is_tourney_running(utc_now=retrieved_at)
if past_fleet_infos:
ship_info = {}
fleet_info = past_fleet_infos.get(user_info.get(fleet.FLEET_KEY_NAME))
current_user_info = await __get_user_info_by_id(user_id) or {}
current_user_name = current_user_info.get(
USER_DESCRIPTION_PROPERTY_NAME)
if current_user_name and current_user_name != user_info.get(
USER_DESCRIPTION_PROPERTY_NAME):
user_info['CurrentName'] = current_user_name
else:
_, ship_info = await ship.get_inspect_ship_for_user(user_id)
fleet_info = await __get_fleet_info_by_user_info(user_info)
is_in_tourney_fleet = fleet.is_tournament_fleet(
fleet_info) and tourney_running
user_details = __create_user_details_from_info(
user_info,
fleet_info,
ship_info,
max_tourney_battle_attempts=max_tourney_battle_attempts,
retrieved_at=retrieved_at,
is_past_data=is_past_data,
is_in_tourney_fleet=is_in_tourney_fleet)
if as_embed:
return [(await
user_details.get_details_as_embed(ctx, display_inline=False))]
else:
return (await
user_details.get_details_as_text(entity.EntityDetailsType.LONG
))
def __filter_data_dict(data: EntitiesData, by_key: Any, by_value: Any, ignore_case: bool) -> Optional[EntitiesData]:
"""Parameter 'data':
- A dict with entity ids as keys and entity info as values. """
if data:
result = {}
for key, entry in data.items():
entry_value = entry[by_key]
value = by_value
if ignore_case:
entry_value = str(entry_value).lower()
value = str(value).lower()
if isinstance(by_value, list):
if entry_value in value:
result[key] = entry
elif entry_value == value:
result[key] = entry
return result
else:
return data
def __flatten_raw_dict_for_excel(raw_dict: EntitiesData) -> List[EntityInfo]:
entity = {}
result = []
children = []
for key, value in raw_dict.items():
if isinstance(value, dict):
children.extend(__flatten_raw_dict_for_excel(value))
elif isinstance(value, list):
for child in value:
children.extend(__flatten_raw_dict_for_excel(child))
else:
entity[key] = excel.fix_field(value)
if children:
for child in children:
result_entity = dict(entity)
result_entity.update(child)
result.append(result_entity)
else:
result = [entity]
return result
def __create_user_data_from_data_v3(users: List[List[Union[int, str]]], data: List[List[Union[int, str]]], fleet_data: EntitiesData) -> EntitiesData:
result = {}
users_dict = dict(users)
for entry in data:
fleet_id = entry[1]
result[entry[0]] = {
'Id': entry[0],
'AllianceId': fleet_id,
'Trophy': entry[2],
'AllianceScore': entry[3],
'AllianceMembership': entry[4],
'AllianceJoinDate': entry[5],
'LastLoginDate': entry[6],
'Name': users_dict[entry[0]],
'Alliance': {}
}
if fleet_id and fleet_id != '0':
fleet_info = fleet_data.get(fleet_id, {})
for key, value in fleet_info.items():
result[entry[0]]['Alliance'][key] = value
return result
async def get_entities_infos_by_name(
self,
entity_name: str,
entities_data: EntitiesData = None,
sorted_key_function: Callable[[dict, dict], str] = None
) -> List[Dict[str, object]]:
entities_data = entities_data or await self.get_data_dict3()
sorted_key_function = sorted_key_function or self.__sorted_key_function
entity_ids = await self.get_entities_ids_by_name(
entity_name, entities_data=entities_data)
entities_data_keys = entities_data.keys()
result = [
entities_data[entity_id] for entity_id in entity_ids
if entity_id in entities_data_keys
]
if sorted_key_function is not None:
result = sorted(result,
key=lambda entity_info:
(sorted_key_function(entity_info, entities_data)))
return result
def __prepare_top_fleets(
fleets_data: EntitiesData) -> List[Tuple[int, str, str, str, str]]:
"""
Returns:
List[
Tuple[
fleet rank (int),
fleet name (str),
fleet trophies (str),
fleet stars (str),
number of approved members (str)
]
]
"""
result = [
(position,
escape_markdown(fleet_info[fleet.FLEET_DESCRIPTION_PROPERTY_NAME]),
fleet_info['Trophy'], fleet_info['Score'],
fleet_info['NumberOfApprovedMembers'])
for position, fleet_info in enumerate(fleets_data.values(), start=1)
]
return result