async def generatesupskills(source) -> str:
output = ""
removetooltip(source)
removecitation(source)
iconreplace(source)
for tr in source.find_all("tr"):
if tr.find_all("th"):
continue
if tr.get("class"):
continue
output += "**" + tr.find("td", {"class": "skill-name"}).text.strip() + \
"**\n"
# I don't know why this check is actually needed but it doesn't work
# without it
if EMP or DOMAIN in tr.find("td", {"class": "skill-name"}).text:
td = tr.find_all("td", {"style": ""})[1]
else:
td = tr.find_all("td", {"style": ""})[2]
for span in td.find_all("span", {"class": "tooltip"}):
span.replace_with("/" + span.text)
output += "Obtained: " + td.text.strip() + "\n"
td = tr.find("td", {"style": "text-align:left;"})
for span in td.find_all("span", {"class": "skill-upgrade-text"}):
span.replace_with("\n__" + span.text + "__")
for br in td.find_all("br"):
br.replace_with(" ")
output += td.text + "\n"
return output
async def generateskills(source, multiskill: bool) -> list:
# Skills are too big to put in one field, so this generates the information
# for each skill to be displayed in its own field.
output = []
# Miscellaneous cleaning
removetooltip(source)
removecitation(source)
iconreplace(source)
# Skill counter and text buffer for the skill info
i = 1
skillinfo = ""
for tr in source.find_all("tr"):
if tr.find_all("th") or tr.get("class"):
if multiskill and tr.find("th", {"colspan": "6"}):
output.append((tr.find("th", {"colspan": "6"}).text, "Press "
"the :arrows_counterclockwise: reaction to see "
"this character's other skills"))
continue
# Get the cell with the skill name
td = tr.find("td", {"class": "skill-name"})
# Handle any skill name changes
for span in td.find_all("span", {"class": "skill-upgrade-text"}):
for br in span.find_all("br"):
br.replace_with(" ")
span.replace_with("/" + span.text)
skillname = "Skill " + str(i) + ": " + td.text.strip()
# The next three cells don't have a class identifier, so you just have
# to hope the table format stays consistent with all cases
td = tr.find_all("td", {"class": None})
# The first unmarked cell is for the cooldown, which needs handling of
# potential cooldown reductions and linked skills
for span in td[0].find_all("span"):
if "Linked" not in span.text:
span.replace_with("/" + span.text + " ")
else:
span.replace_with("(Linked Skill) ")
skillinfo += "Cooldown: " + td[0].text + "\n"
# The second unmarked cell is for the duration, which needs handling of
# potential upgrades
for span in td[1].find_all("span"):
span.replace_with("/" + span.text + " ")
skillinfo += "Duration: " + td[1].text + "\n"
for span in td[2].find_all("span"):
span.replace_with("/" + span.text)
# The third unmarked cell is for the obtain level, which also includes
# potential upgrades
skillinfo += "Obtained: " + td[2].text + "\n"
# The cell with skill information apparently doesn't have an identifier,
# but it DOES always have a specific styling.
td = tr.find("td", {"style": "text-align:left;"})
for br in td.find_all("br"):
br.replace_with(" ")
for span in td.find_all("span", {"class": "skill-upgrade-text"}):
span.replace_with("\n__" + span.text + "__")
skillinfo += td.text + "\n"
output.append((skillname, skillinfo))
skillinfo = ""
i += 1
return output
async def generateca(source) -> list:
# Empty variables to be filled later
name = ""
output = []
outputtext = ""
# Miscellaneous cleaning
removetooltip(source)
removecitation(source)
iconreplace(source)
# Check if the CA eventually gets another name
if len(source.find_all("td", {"class": "skill-name"})) > 1:
namechange = True
else:
namechange = False
for tr in source.find_all("tr"):
# If the row has styling, it's a dud row
if tr.find("th") is not None:
continue
# If the row has a "skill" upgrade, add it in mark it as such, then
# Remove it to prevent double inclusion
if tr.find("td", {"class": "skill-name"}) and not namechange:
name = " - " + tr.find("td", {"class": "skill-name"}).text
tr.find("td", {"class": "skill-name"}).replace_with("")
if tr.find("span", {"class": "skill-upgrade-text"}):
if namechange:
outputtext += "__" + tr.find("span", {"class":
"skill-upgrade-text"}).text + \
"__\n"
tr.find("span", {"class": "skill-upgrade-text"})\
.replace_with("")
else:
tr.find("span", {"class": "skill-upgrade-text"}) \
.replace_with("\n__" + tr.find("span", {"class":
"skill-upgrade-text"}).text + "__\n")
td = tr.find("td", {"style": "text-align:left;"})
for br in td.find_all("br"):
br.replace_with(" ")
if namechange:
outputtext += "**" + tr.find("td", {"class": "skill-name"}).text + \
":** " + td.text + "\n"
else:
outputtext += td.text
output.append(name)
output.append(outputtext)
return output
async def generateca(source) -> list:
# Cutting out unneeded bits
raw = source[source.find("<img alt=\"Skill"):].split("</tr>", 1)[0]
# ...Mirage Munitions
if "None" in raw:
return ["None", "-"]
parsed = BeautifulSoup(raw, 'html.parser')
# Getting the name
name = parsed.find_all("td", {"class": "skill-name"})[0].text
# Remove line breaks
for br in parsed.find_all("br"):
br.replace_with("\n")
# Miscellaneous cleaning
removetooltip(parsed)
removecitation(parsed)
iconreplace(parsed)
for span in parsed.find_all("span", {"class": "skill-upgrade-text"}):
span.string.replace_with("**" + span.string + "**")
output = parsed.find_all("td", {"class": ""})[0].text
return [name, output]
async def generateaura(source: str, categories: list) -> str:
output = ""
# Check if the summon has sub auras and trim the source accordingly.
if "Summons with Sub Auras" in categories:
raw = source[source.find("Main Aura"):].split("</tbody>", 1)[0]
output += "__Main Aura__\n"
else:
raw = source[source.find("Aura"):].split("</tbody>", 1)[0]
parsed = BeautifulSoup(raw, "html.parser")
# Remove tooltips
removetooltip(parsed)
# Icons
iconreplace(parsed)
for tr in parsed.find_all("tr"):
# Main aura was already inserted in the trimming phase. This inserts
# the sub aura separator.
if "Aura" in tr.text:
output += "__Sub Aura__\n"
else:
output += "**" + tr.find("th").text + ":** " + tr.find("td").text \
+ "\n"
return output
async def generatecall(source: str) -> list:
# Empty variables to be filled later
output = []
# Trim to what's needed
raw = source[source.find("/Summons#Calls") - 25:].split("</tbody>", 1)[0]
parsed = BeautifulSoup(raw, "html.parser")
# Miscellaneous cleaning
removetooltip(parsed)
removecitation(parsed)
iconreplace(parsed)
# Remove cooldown text
for th in parsed.find_all("th", {"style": "width:35px;"}):
th.replace_with("")
# Get call name
output.append("Name " + parsed.find("th", {
"colspan": "2"
}).text.split(" ", 1)[1])
# Counters and buffer variables to be filled
skillspan = 0
cdspan = 0
uncap = ""
cd = ""
call = ""
for tr in parsed.find_all("tr"):
# Check if the row has call text, or if it's just an uncap identifier
# or uncomboable identifier
if tr.find("td"):
# Check if the call text covers multiple uncaps, and increment
# skillspan accordingly
if tr.find("td").get("rowspan"):
skillspan = int(tr.find("td")["rowspan"])
# Get call text
call = tr.find("td").text
# Check if the "call" is just an indicator that the call cannot be
# comboed:
if call == "Can't be included in other players' combo calls.":
continue
# De-increment cdspan and keep the cooldown as-is, or get the new
# cooldown if cdspan is 1 or less
if cdspan > 1:
cdspan -= 1
else:
for td in tr.find_all("td", {"style": "text-align:center;"}):
# If the cooldown has separate values for first call and
# subsequent calls, the first call will be recorded, and then
# when the tr steps to the next cooldown (for subsequent calls),
# a slash will be inserted to split the two.
if cd:
cd += "/"
cd += td.text
if td.get("rowspan"):
cdspan = int(td['rowspan'])
# Inserts a slash between multiple uncaps with the same call text and
# de-increments skillspan, or gets the uncap level.
if uncap:
uncap += "/" + tr.find("th").text
skillspan -= 1
else:
if "once" not in tr.text:
uncap = tr.find("th").text
# If all the uncaps are covered (skillspan <=1), then the output is
# processed and stored, and the buffer variables and counters are reset.
if skillspan <= 1:
skillspan = 0
# Check for the case of single-use summons
if "Can only be summoned once per battle." not in tr.text:
output.append(("" + uncap, call + " (" + cd + ")"))
else:
output[0] += "\n**" + call + "**"
uncap = ""
if cdspan <= 1:
cd = ""
return output