class Member(namedtuple("Member", ["id", "hid", "system", "color", "avatar_url", "name", "birthday", "pronouns", "description", "prefix", "suffix", "created"])): id: int hid: str system: int color: str avatar_url: str name: str birthday: date pronouns: str description: str prefix: str suffix: str created: datetime def to_json(self): return { "id": self.hid, "name": self.name, "color": self.color, "avatar_url": self.avatar_url, "birthday": self.birthday.isoformat() if self.birthday else None, "pronouns": self.pronouns, "description": self.description, "prefix": self.prefix, "suffix": self.suffix }
def get_frappe_dataset(batch_size): home = str(Path.home()) Args = namedtuple("Args", ["data"]) args = Args(data=os.path.join(home, ".keras/datasets")) x_train, y_train, x_val, y_val, x_test, y_test = load_raw_data(args) x_train = tf.convert_to_tensor(x_train, dtype=tf.int64) x_test = tf.convert_to_tensor(x_test, dtype=tf.int64) y_train = tf.convert_to_tensor(y_train, dtype=tf.int64) y_test = tf.convert_to_tensor(y_test, dtype=tf.int64) db = tf.data.Dataset.from_tensor_slices((x_train, y_train)) db = db.batch(batch_size).repeat(2) test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test)) test_db = test_db.batch(batch_size) return db, test_db
def __init__(self, gpu=False): import torch import torchvision model_t = torchvision.models.detection.fasterrcnn_resnet50_fpn self.device = torch.device('cuda:0' if gpu else 'cpu') self.model = model_t(pretrained=True, box_nms_thresh=0.3).to(self.device) self.model.eval() # noinspection PyArgumentList def predict_boxes(self, image_filename): import torch import matplotlib.pylab as plt input_tensor = torch.zeros(1, 3, 2710, 3384).to(self.device) img = plt.imread(image_filename).astype('float32') / 255 input_tensor[0] = torch.Tensor(img.transpose((2, 0, 1))) output = self.model(input_tensor)[0] bboxes = output['boxes'] labels = output['labels'] scores = output['scores'] bboxes[[0, 2]] /= img.shape[0] bboxes[[1, 3]] /= img.shape[1] return [ Box(float(confidence), *map(float, box)) for box, label, confidence in zip(bboxes, labels, scores) if label == 3 ] Box = namedtuple('Box', 'confidence xmin ymin xmax ymax')
from pruner.core.domain_registry import init_domain_core_pytorch from pruner.domains.ioslicerbar.pytorch.propagator import simple_domain_propagate_o2io, simple_domain_propagate_o2i, \ ConcatPropagateWrapper, simple_domain_propagate_o2o from pruner.prunedirector.pytorch.dependency import PruneTracker, init_dep_node, add_dep_dsts, prune_module_domain, \ regen_replace_modules_in_model from pruner.util.pytorch.module_traverse import get_submodule, get_module_comp_rec module_factory_fn, domain_factory_fn = init_domain_core_pytorch('ioslicerbar') # utility for instrumentation # out_module_names is a list of list, each inner most list is either one output from seq # or all the outputs going into a shortcut # end of instrumentation utility in_out_record = namedtuple('in_out_record', ['in_module_name', 'out_module_names', 'op']) def create_entries_for_conv_group(module, tracker: PruneTracker, tracker_str_stack): entry_module = None exit_module = None # check entry_module_entity = None exit_module_entity = None prev_module = None prev_module_entity = None for submodule_name, submodule_entity in get_submodule(module).items(): cur_submodule_type = type(submodule_entity)
import random from collections.__init__ import namedtuple from configuration import Configurable Transition = namedtuple('Transition', ('current_state', 'current_future_pos', 'current_past_pos',\ 'action', 'reward',\ 'next_state', 'next_future_pos', 'next_past_pos', \ 'terminal', 'info')) class ReplayMemory(Configurable): """ Container that stores and samples transitions. """ def __init__(self, config=None, transition_type=Transition): super(ReplayMemory, self).__init__(config) self.capacity = int(self.config['memory_capacity']) self.transition_type = transition_type self.memory = [] self.position = 0 @classmethod def default_config(cls): return dict(memory_capacity=10000, n_steps=1, gamma=0.99) def push(self, *args): """Saves a transition.""" if len(self.memory) < self.capacity: self.memory.append(None) self.position = len(self.memory) - 1
class ImageVideoWriter: def __init__(self, file): self.writer = None self.file = file self.writer = imageio.get_writer(self.file, macro_block_size=None) def add_frame(self, screen, format): frame = NumpyRGBWrapper(screen, format).numpyRGB self.writer.append_data(screen) def endSession(self): self.writer.close() RLStep = namedtuple('Step', 'screen, observation, action, reward, done, meta') class ActionEmbedding: """ Simple one-hot embedding of the action space """ def __init__(self, env): self.env = env def tensor(self, action): action_t = torch.zeros(self.env.action_space.n) action_t[action] = 1.0 return action_t def numpy(self, action):
class Member( namedtuple("Member", [ "id", "hid", "system", "color", "avatar_url", "name", "birthday", "pronouns", "description", "prefix", "suffix", "created" ])): """An immutable representation of a system member fetched from the database.""" id: int hid: str system: int color: str avatar_url: str name: str birthday: date pronouns: str description: str prefix: str suffix: str created: datetime def to_json(self): return { "id": self.hid, "name": self.name, "color": self.color, "avatar_url": self.avatar_url, "birthday": self.birthday.isoformat() if self.birthday else None, "pronouns": self.pronouns, "description": self.description, "prefix": self.prefix, "suffix": self.suffix } @staticmethod async def get_member_by_name(conn, system_id: int, member_name: str) -> "Optional[Member]": """Fetch a member by the given name in the given system from the database.""" member = await db.get_member_by_name(conn, system_id, member_name) return member @staticmethod async def get_member_by_hid(conn, system_id: Optional[int], member_hid: str) -> "Optional[Member]": """Fetch a member by the given hid from the database. If @`system_id` is present, will only return members from that system.""" if system_id: member = await db.get_member_by_hid_in_system( conn, system_id, member_hid) else: member = await db.get_member_by_hid(conn, member_hid) return member @staticmethod async def get_member_fuzzy(conn, system_id: int, name: str) -> "Optional[Member]": by_hid = await Member.get_member_by_hid(conn, system_id, name) if by_hid: return by_hid by_name = await Member.get_member_by_name(conn, system_id, name) return by_name async def set_name(self, conn, new_name: str): """ Set the name of a member. :raises: CustomEmojiError """ # Custom emojis can't go in the member name # Technically they *could*, but they wouldn't render properly # so I'd rather explicitly ban them to in order to avoid confusion if contains_custom_emoji(new_name): raise errors.CustomEmojiError() await db.update_member_field(conn, self.id, "name", new_name) async def set_description(self, conn, new_description: Optional[str]): """ Set or clear the description of a member. :raises: DescriptionTooLongError """ # Explicit length checking if new_description and len(new_description) > 1024: raise errors.DescriptionTooLongError() await db.update_member_field(conn, self.id, "description", new_description) async def set_avatar(self, conn, new_avatar_url: Optional[str]): """ Set or clear the avatar of a member. :raises: InvalidAvatarURLError """ if new_avatar_url: validate_avatar_url_or_raise(new_avatar_url) await db.update_member_field(conn, self.id, "avatar_url", new_avatar_url) async def set_color(self, conn, new_color: Optional[str]): """ Set or clear the associated color of a member. :raises: InvalidColorError """ cleaned_color = None if new_color: match = re.fullmatch("#?([0-9A-Fa-f]{6})", new_color) if not match: raise errors.InvalidColorError() cleaned_color = match.group(1).lower() await db.update_member_field(conn, self.id, "color", cleaned_color) async def set_birthdate(self, conn, new_date: Union[date, str]): """ Set or clear the birthdate of a member. To hide the birth year, pass a year of 0001. If passed a string, will attempt to parse the string as a date. :raises: InvalidDateStringError """ if isinstance(new_date, str): date_str = new_date try: new_date = datetime.strptime(date_str, "%Y-%m-%d").date() except ValueError: try: # Try again, adding 0001 as a placeholder year # This is considered a "null year" and will be omitted from the info card # Useful if you want your birthday to be displayed yearless. new_date = datetime.strptime("0001-" + date_str, "%Y-%m-%d").date() except ValueError: raise errors.InvalidDateStringError() await db.update_member_field(conn, self.id, "birthday", new_date) async def set_pronouns(self, conn, new_pronouns: str): """Set or clear the associated pronouns with a member.""" await db.update_member_field(conn, self.id, "pronouns", new_pronouns) async def set_proxy_tags(self, conn, prefix: Optional[str], suffix: Optional[str]): """ Set the proxy tags for a member. Having no prefix *and* no suffix will disable proxying. """ # Make sure empty strings or other falsey values are actually None prefix = prefix or None suffix = suffix or None async with conn.transaction(): await db.update_member_field(conn, member_id=self.id, field="prefix", value=prefix) await db.update_member_field(conn, member_id=self.id, field="suffix", value=suffix) async def delete(self, conn): """Delete this member from the database.""" await db.delete_member(conn, self.id) async def fetch_system(self, conn) -> "System": """Fetch the member's system from the database""" return await db.get_system(conn, self.system) async def message_count(self, conn) -> int: return await db.get_member_message_count(conn, self.id)
from collections.__init__ import namedtuple NeuralProcessParams = namedtuple('NeuralProcessParams', ['dim_r', 'dim_z', 'n_hidden_units_h', 'n_hidden_units_g']) GaussianParams = namedtuple('GaussianParams', ['mu', 'sigma'])
from collections.__init__ import namedtuple from xml.etree import ElementTree import requests Episode = namedtuple('Episode', 'title link pubdate show_id') episode_data = {} def get_episode(show_id): # GET EPISODE info = episode_data.get(show_id) print("{}. {}".format(info.show_id, info.title)) def get_latest_show_id(): # GET LATEST SHOW ID latest_show_id = max(episode_data.keys()) return latest_show_id def download_data(): # DOWNLOAD THE EPISODE DATA url = 'https://talkpython.fm/episodes/rss' resp = requests.get(url) resp.raise_for_status() dom = ElementTree.fromstring(resp.text) items = dom.findall('channel/item') episode_count = len(items) for idx, item in enumerate(items): episode = Episode(
from collections.__init__ import namedtuple ResultRow = namedtuple( 'ResultRow', ['position', 'state', 'bib', 'laps_done', 'total_time', 'lap_times'])
class System(namedtuple("System", ["id", "hid", "name", "description", "tag", "avatar_url", "created"])): id: int hid: str name: str description: str tag: str avatar_url: str created: datetime @staticmethod async def get_by_account(conn, account_id: str) -> "System": return await db.get_system_by_account(conn, account_id) @staticmethod async def create_system(conn, account_id: str, system_name: Optional[str] = None) -> "System": existing_system = await System.get_by_account(conn, account_id) if existing_system: raise errors.ExistingSystemError() new_hid = generate_hid() async with conn.transaction(): new_system = await db.create_system(conn, system_name, new_hid) await db.link_account(conn, new_system.id, account_id) return new_system async def set_name(self, conn, new_name: Optional[str]): await db.update_system_field(conn, self.id, "name", new_name) async def set_description(self, conn, new_description: Optional[str]): if new_description and len(new_description) > 1024: raise errors.DescriptionTooLongError() await db.update_system_field(conn, self.id, "description", new_description) async def set_tag(self, conn, new_tag: Optional[str]): if new_tag: if len(new_tag) > 32: raise errors.TagTooLongError() if contains_custom_emoji(new_tag): raise errors.CustomEmojiError() members_exceeding = await db.get_members_exceeding(conn, system_id=self.id, length=32 - len(new_tag) - 1) if len(members_exceeding) > 0: raise errors.TagTooLongWithMembersError([member.name for member in members_exceeding]) await db.update_system_field(conn, self.id, "tag", new_tag) async def set_avatar(self, conn, new_avatar_url: Optional[str]): if new_avatar_url: validate_avatar_url_or_raise(new_avatar_url) await db.update_system_field(conn, self.id, "avatar", new_avatar_url) async def link_account(self, conn, new_account_id: str): existing_system = await System.get_by_account(conn, new_account_id) if existing_system: if existing_system.id == self.id: raise errors.AccountInOwnSystemError() raise errors.AccountAlreadyLinkedError(existing_system) await db.link_account(conn, self.id, new_account_id) async def unlink_account(self, conn, account_id: str): linked_accounts = await db.get_linked_accounts(conn, self.id) if len(linked_accounts) == 1: raise errors.UnlinkingLastAccountError() await db.unlink_account(conn, self.id, account_id) async def delete(self, conn): await db.remove_system(conn, self.id) def to_json(self): return { "id": self.hid, "name": self.name, "description": self.description, "tag": self.tag, "avatar_url": self.avatar_url }
from collections.__init__ import namedtuple SongGenerationParams = namedtuple('SongGenerationParams', ['xml', 'back_track', 'outf']) # parameters for each standard to generate over: # xml: path to xml file with standard notes and chords # back_track: path to mp3 file with backing track with the same xml chords and tempo # outf: saving name for output song_params_dict = { 'fly': SongGenerationParams('Fly_me_to_the_moon.xml', 'Fly_me_to_the_moon_v2.mp3', 'Fly_me_to_the_moon'), 'giant': SongGenerationParams('Giant_Steps_200.xml', 'Giant_Steps_200_BT.mp3', 'Giant_steps'), 'blue': SongGenerationParams('Blue_Bossa.xml', 'blue_bossa.mp3', 'Blue_bossa'), 'it': SongGenerationParams('It_dont_mean_a_thing.xml', 'It_dont_mean_a_thing.mp3', 'It_dont_mean_a_thing'), 'well': SongGenerationParams('Well_You_Neednt.xml', 'Well_You_Neednt.mp3', 'Well_you_neednt'), 'over': SongGenerationParams('Over_The_Rainbow_with_chords.xml', 'Over_the_Rainbow.mp3', 'Over_the_rainbow'), 'just': SongGenerationParams('just_friends.xml', 'Just_Friends.mp3', 'Just_friends'), 'there':
import random from collections.__init__ import namedtuple from typing import Dict import numpy as np import tensorflow as tf NeuralProcessParams = namedtuple( "NeuralProcessParams", ["dim_x", "dim_y", "dim_r", "dim_z", "n_hidden_units_h", "n_hidden_units_g"], ) def split_context_target(xs, ys, n_context): """Randomly split a set of x,y samples into context and target sets""" context_mask = np.zeros(xs.shape[0], dtype=bool) context_mask[[i for i in random.sample(range(xs.shape[0]), n_context)]] = True context_xs = xs[context_mask] context_ys = ys[context_mask] target_xs = xs[~context_mask] target_ys = ys[~context_mask] return context_xs, context_ys, target_xs, target_ys
from typing import List from collections.__init__ import namedtuple from xml.etree.ElementTree import Element, SubElement Tag = namedtuple('Tag', 'id name applicability') def create_tag_xml(tags: List[Tag]) -> Element: root = Element('odoo') for tag in tags: record = SubElement(root, 'record', { 'id': tag.id, 'model': 'account.account.tag' }) SubElement(record, 'field', {'name': 'name'}).text = tag.name SubElement(record, 'field', { 'name': 'applicability' }).text = tag.applicability return root
from collections.__init__ import namedtuple from django.utils.translation import ugettext_lazy as _ # the parameter labels is a list of string and tuple # labels=['welcome_introduction', # ('caap', 'specific,custom')] # second parameter can have few values: # specific # common # specific,common # Used base.views.education_groups.detail.EducationGroupGeneralInformation#get_sections_with_translated_labels Section = namedtuple('Section', 'title labels') SECTION_LIST = [ Section(title=_('Welcome'), labels=[ ('welcome_introduction', 'specific'), ('welcome_profil', 'specific'), ('welcome_job', 'specific'), ('welcome_programme', 'specific'), ('welcome_parcours', 'specific'), ]), Section(title=_('Teaching profile'), labels=[('comp_acquis', 'specific'), ('structure', 'specific')]), Section(title=_('Detailed programme'), labels=[ ('mineures', 'specific'), ('majeures', 'specific'), ('programme_detaille', 'specific'), ('finalites', 'specific'),
class TupperboxImportResult( namedtuple("TupperboxImportResult", ["updated", "created", "tags"])): pass
def cast_to_int(arg: str): return int(float(arg)) def put_in_xml_setter(arg: str): setters = [XMLSetter(*v.split(",")) for v in arg] mirroring = [ XMLSetter(p.replace("_l_", "_r_"), v) for p, v in setters if "_l_" in p ] + [ XMLSetter(p.replace("_r_", "_l_"), v) for p, v in setters if "_r_" in p ] return [s._replace(path=s.path) for s in setters + mirroring] XMLSetter = namedtuple("XMLSetter", "path value") @contextmanager def mutate_xml( changes: List[XMLSetter], dofs: List[str], goal_space: Box, n_blocks: int, xml_filepath: Path, ): def rel_to_abs(path: Path): return Path(xml_filepath.parent, path) def mutate_tree(tree: ET.ElementTree):
class System( namedtuple("System", [ "id", "hid", "name", "description", "tag", "avatar_url", "token", "created", "ui_tz" ])): id: int hid: str name: str description: str tag: str avatar_url: str token: str created: datetime # pytz-compatible time zone name, usually Olson-style (eg. Europe/Amsterdam) ui_tz: str @staticmethod async def get_by_id(conn, system_id: int) -> Optional["System"]: return await db.get_system(conn, system_id) @staticmethod async def get_by_account(conn, account_id: int) -> Optional["System"]: return await db.get_system_by_account(conn, account_id) @staticmethod async def get_by_token(conn, token: str) -> Optional["System"]: return await db.get_system_by_token(conn, token) @staticmethod async def create_system(conn, account_id: int, system_name: Optional[str] = None) -> "System": async with conn.transaction(): existing_system = await System.get_by_account(conn, account_id) if existing_system: raise errors.ExistingSystemError() new_hid = generate_hid() async with conn.transaction(): new_system = await db.create_system(conn, system_name, new_hid) await db.link_account(conn, new_system.id, account_id) return new_system async def set_name(self, conn, new_name: Optional[str]): await db.update_system_field(conn, self.id, "name", new_name) async def set_description(self, conn, new_description: Optional[str]): # Explicit length error if new_description and len(new_description) > 1024: raise errors.DescriptionTooLongError() await db.update_system_field(conn, self.id, "description", new_description) async def set_tag(self, conn, new_tag: Optional[str]): if new_tag: # Explicit length error if len(new_tag) > 32: raise errors.TagTooLongError() if contains_custom_emoji(new_tag): raise errors.CustomEmojiError() await db.update_system_field(conn, self.id, "tag", new_tag) async def set_avatar(self, conn, new_avatar_url: Optional[str]): if new_avatar_url: validate_avatar_url_or_raise(new_avatar_url) await db.update_system_field(conn, self.id, "avatar_url", new_avatar_url) async def link_account(self, conn, new_account_id: int): async with conn.transaction(): existing_system = await System.get_by_account(conn, new_account_id) if existing_system: if existing_system.id == self.id: raise errors.AccountInOwnSystemError() raise errors.AccountAlreadyLinkedError(existing_system) await db.link_account(conn, self.id, new_account_id) async def unlink_account(self, conn, account_id: int): async with conn.transaction(): linked_accounts = await db.get_linked_accounts(conn, self.id) if len(linked_accounts) == 1: raise errors.UnlinkingLastAccountError() await db.unlink_account(conn, self.id, account_id) async def get_linked_account_ids(self, conn) -> List[int]: return await db.get_linked_accounts(conn, self.id) async def delete(self, conn): await db.remove_system(conn, self.id) async def refresh_token(self, conn) -> str: new_token = "".join( random.choices(string.ascii_letters + string.digits, k=64)) await db.update_system_field(conn, self.id, "token", new_token) return new_token async def create_member(self, conn, member_name: str) -> Member: # TODO: figure out what to do if this errors out on collision on generate_hid new_hid = generate_hid() if len(member_name) > self.get_member_name_limit(): raise errors.MemberNameTooLongError(tag_present=bool(self.tag)) member = await db.create_member(conn, self.id, member_name, new_hid) return member async def get_members(self, conn) -> List[Member]: return await db.get_all_members(conn, self.id) async def get_switches(self, conn, count) -> List[Switch]: """Returns the latest `count` switches logged for this system, ordered latest to earliest.""" return [ Switch(**s) for s in await db.front_history(conn, self.id, count) ] async def get_latest_switch(self, conn) -> Optional[Switch]: """Returns the latest switch logged for this system, or None if no switches have been logged""" switches = await self.get_switches(conn, 1) if switches: return switches[0] else: return None async def add_switch(self, conn, members: List[Member]) -> Switch: """ Logs a new switch for a system. :raises: MembersAlreadyFrontingError, DuplicateSwitchMembersError """ new_ids = [member.id for member in members] last_switch = await self.get_latest_switch(conn) # If we have a switch logged before, make sure this isn't a dupe switch if last_switch: last_switch_members = await last_switch.fetch_members(conn) last_ids = [member.id for member in last_switch_members] # We don't compare by set() here because swapping multiple is a valid operation if last_ids == new_ids: raise errors.MembersAlreadyFrontingError(members) # Check for dupes if len(set(new_ids)) != len(new_ids): raise errors.DuplicateSwitchMembersError() async with conn.transaction(): switch_id = await db.add_switch(conn, self.id) # TODO: batch query here for member in members: await db.add_switch_member(conn, switch_id, member.id) return await self.get_latest_switch(conn) def get_member_name_limit(self) -> int: """Returns the maximum length a member's name or nickname is allowed to be in order for the member to be proxied. Depends on the system tag.""" if self.tag: return 32 - len(self.tag) - 1 else: return 32 async def match_proxy(self, conn, message: str) -> Optional[Tuple[Member, str]]: """Tries to find a member with proxy tags matching the given message. Returns the member and the inner contents.""" members = await db.get_all_members(conn, self.id) # Sort by specificity (members with both prefix and suffix defined go higher) # This will make sure more "precise" proxy tags get tried first and match properly members = sorted( members, key=lambda x: int(bool(x.prefix)) + int(bool(x.suffix)), reverse=True) for member in members: proxy_prefix = member.prefix or "" proxy_suffix = member.suffix or "" if not proxy_prefix and not proxy_suffix: # If the member has neither a prefix or a suffix, cancel early # Otherwise it'd match any message no matter what continue # Check if the message matches these tags if message.startswith(proxy_prefix) and message.endswith( proxy_suffix): # If the message starts with a mention, "separate" that and match the bit after mention_match = re.match(r"^(<(@|@!|#|@&|a?:\w+:)\d+>\s*)+", message) leading_mentions = "" if mention_match: message = message[mention_match.span(0)[1]:].strip() leading_mentions = mention_match.group(0) # Extract the inner message (special case because -0 is invalid as an end slice) if len(proxy_suffix) == 0: inner_message = message[len(proxy_prefix):] else: inner_message = message[len(proxy_prefix ):-len(proxy_suffix)] # Add the stripped mentions back if there are any inner_message = leading_mentions + inner_message return member, inner_message def format_time(self, dt: datetime) -> str: """ Localizes the given `datetime` to a string based on the system's preferred time zone. Assumes `dt` is a naïve `datetime` instance set to UTC, which is consistent with the rest of PluralKit. """ tz = pytz.timezone(self.ui_tz) # Set to aware (UTC), convert to tz, set to naive (tz), then format and append name return tz.normalize( pytz.utc.localize(dt)).replace(tzinfo=None).isoformat( sep=" ", timespec="seconds") + " " + tz.tzname(dt) async def set_time_zone(self, conn, tz_name: str) -> pytz.tzinfo: """ Sets the system time zone to the time zone represented by the given string. If `tz_name` is None or an empty string, will default to UTC. If `tz_name` does not represent a valid time zone string, will raise InvalidTimeZoneError. :raises: InvalidTimeZoneError :returns: The `pytz.tzinfo` instance of the newly set time zone. """ canonical_name = canonicalize_tz_name(tz_name or "UTC") if not canonical_name: raise errors.InvalidTimeZoneError(tz_name) tz = pytz.timezone(canonical_name) await db.update_system_field(conn, self.id, "ui_tz", tz.zone) return tz async def import_from_tupperbox(self, conn, data: dict): """ Imports from a Tupperbox JSON data file. :raises: TupperboxImportError """ if not "tuppers" in data: raise errors.TupperboxImportError() if not isinstance(data["tuppers"], list): raise errors.TupperboxImportError() all_tags = set() created_members = set() updated_members = set() for tupper in data["tuppers"]: # Sanity check tupper fields for field in [ "name", "avatar_url", "brackets", "birthday", "description", "tag" ]: if field not in tupper: raise errors.TupperboxImportError() # Find member by name, create if not exists member_name = str(tupper["name"]) member = await Member.get_member_by_name(conn, self.id, member_name) if not member: # And keep track of created members created_members.add(member_name) member = await self.create_member(conn, member_name) else: # Keep track of updated members updated_members.add(member_name) # Set avatar await member.set_avatar(conn, str(tupper["avatar_url"])) # Set proxy tags if not (isinstance(tupper["brackets"], list) and len(tupper["brackets"]) >= 2): raise errors.TupperboxImportError() await member.set_proxy_tags(conn, str(tupper["brackets"][0]), str(tupper["brackets"][1])) # Set birthdate (input is in ISO-8601, first 10 characters is the date) if tupper["birthday"]: try: await member.set_birthdate(conn, str(tupper["birthday"][:10])) except errors.InvalidDateStringError: pass # Set description await member.set_description(conn, tupper["description"]) # Keep track of tag all_tags.add(tupper["tag"]) # Since Tupperbox does tags on a per-member basis, we only apply a system tag if # every member has the same tag (surprisingly common) # If not, we just do nothing. (This will be reported in the caller function through the returned result) if len(all_tags) == 1: tag = list(all_tags)[0] await self.set_tag(conn, tag) return TupperboxImportResult(updated=updated_members, created=created_members, tags=all_tags) def to_json(self): return { "id": self.hid, "name": self.name, "description": self.description, "tag": self.tag, "avatar_url": self.avatar_url }
""" exceptions """ from collections.__init__ import namedtuple ODBRequestErrorMessage = namedtuple("ODBException", "class_name, message")
import os from collections.__init__ import namedtuple from contextlib import contextmanager from tempfile import NamedTemporaryFile from typing import List, Sequence, Iterable def as_lines(*lines: str) -> List[bytes]: return [f'{line}\n'.encode('utf-8') for line in lines] Replacement = namedtuple('Replacement', ['line', 'from_column', 'to_column', 'text']) def apply_replacements(file_text: Sequence[bytes], replacements: Iterable[Replacement]) -> List[bytes]: replaced_text = list(file_text) replacements_by_line = {} for replacement in replacements: replacements_by_line.setdefault(replacement.line, []).append(replacement) for line, line_replacements in replacements_by_line.items(): sorted_replacements = sorted(line_replacements, key=lambda replacement: replacement.from_column) delta = 0 for replacement in sorted_replacements: prev_line = replaced_text[line] replaced_text[line] = prev_line[:replacement.from_column + delta] \ + replacement.text.encode('utf-8') \ + prev_line[replacement.to_column + delta:] delta += len(replacement.text) - (replacement.to_column - replacement.from_column) return replaced_text
if not user: user = conf.get('feeds', {}).get('anonymous_user_username') password = conf.get('feeds', {}).get('anonymous_user_password') logger.debug("using values: " + str([feeds_url, token_url, client_url, user, conn_timeout, read_timeout])) # TODO need a better way to select which client to return, here if token_url and client_url: http_client = Oauth2AuthenticatedClient(token_url=token_url, client_url=client_url, username=user, password=password, connect_timeout=conn_timeout, read_timeout=read_timeout, verify=verify) else: http_client = HTTPBasicAuthClient(username=user, password=password, connect_timeout=conn_timeout, read_timeout=read_timeout, verify=verify) return FeedClient(endpoint=feeds_url, http_client=http_client) FeedGroup = namedtuple('FeedGroup', ['feed', 'name', 'access_tier', 'description']) FeedGroupList = namedtuple('FeedList', ['next_token', 'groups']) Feed = namedtuple('Feed', ['name', 'description', 'access_tier']) FeedList = namedtuple('FeedList', ['next_token', 'feeds']) GroupData = namedtuple('GroupData', ['data', 'next_token', 'since'])
import random from collections.__init__ import namedtuple from rl_agents.configuration import Configurable Transition = namedtuple( 'Transition', ('state', 'action', 'reward', 'next_state', 'terminal', 'info')) class ReplayMemory(Configurable): """ Container that stores and samples transitions. """ def __init__(self, config=None, transition_type=Transition): super(ReplayMemory, self).__init__(config) self.capacity = int(self.config['memory_capacity']) self.transition_type = transition_type self.memory = [] self.position = 0 @classmethod def default_config(cls): return dict(memory_capacity=10000, n_steps=1, gamma=0.99) def push(self, *args): """Saves a transition.""" if len(self.memory) < self.capacity: self.memory.append(None) self.position = len(self.memory) - 1 elif len(self.memory) > self.capacity:
# 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 queue import warnings from collections.__init__ import namedtuple from ..core.utils import is_real_iterable EdgeType = namedtuple("EdgeType", "n1 rel n2") class GraphSchema: """ Class to encapsulate the schema information for a heterogeneous graph. Typically this should be created from a StellarGraph object, using the :func:`~stellargraph.core.graph.create_graph_schema` method. """ def __init__(self, is_directed, node_types, edge_types, schema): self._is_directed = is_directed self.node_types = node_types self.edge_types = edge_types self.schema = schema
from collections.__init__ import namedtuple from typing import Iterable, Tuple from tetrominoes.shape import Shape Cell = namedtuple("Cell", 'x,y') class BoardException(Exception): pass class IllegalBoardAction(BoardException): pass class Board: def __init__(self, size): self._cells = [[0 for _ in range(size)] for _ in range(size)] self._size = size self._shapes_in_board = [] def can_fit(self, shape: Shape, start_cell: Cell): return self.all_cells_available(start_cell, shape) def insert_shape(self, shape: Shape, start_cell: Cell): if not self.can_fit(shape, start_cell): raise IllegalBoardAction() self._fill_cells(start_cell, shape) self._shapes_in_board.append((shape.name, shape.rotation)) return self
help= "String to prepend to all main commands, for example, sourcing a virtualenv" ) parser.add_argument( '--flag', '-f', default=[], action='append', help="directories to create and sync automatically with each run") return parser # new_parser.add_argument( # '--summary-path', # help='Path where Tensorflow summary of run is to be written.') Flag = namedtuple('Flag', 'key values') class SpecObj: def __init__(self, command: str, flags: List[Flag], delimiter: str = '='): self.command = command self.flags = [Flag(*f) for f in flags] self.delimiter = delimiter @Transaction.wrapper def cli(prefix: str, path: PurePath, spec: Path, flags: List[str], logger: UI, description: str, transaction: Transaction, *args, **kwargs): # spec: Path with spec.open() as f: obj = json.load(f, object_pairs_hook=lambda pairs: pairs)
class SynchronizedData(namedtuple('SynchronizedData', ('timestamp', 'order', 'type', 'data'))): """ Small class used to store and sort data to synchronize for a game. Properties:
from collections.__init__ import namedtuple from datetime import datetime from unittest import mock import pandas as pd import numpy as np Cut = namedtuple('corte', ['start', 'end']) class Cuts(object): argentinaCuts = { 'hiperinflacion': Cut(datetime(year=1980, month=1, day=1), datetime(year=1991, month=3, day=1)), 'convertibilidad': Cut(datetime(year=1991, month=4, day=1), datetime(year=1999, month=12, day=1)), 'crisisYrecuperacion': Cut(datetime(year=2000, month=1, day=1), datetime(year=2003, month=4, day=1)), 'kirchner': Cut(datetime(year=2003, month=5, day=1), datetime(year=2015, month=12, day=1)), 'macri': Cut(datetime(year=2016, month=1, day=1), datetime(year=2018, month=3, day=1)), } CUT_NAMES_IN_ORDER = [ 'hiperinflacion', 'convertibilidad', 'crisisYrecuperacion', 'kirchner', 'macri'
import elasticsearch_dsl import pandas as pd import re from pandas.errors import EmptyDataError TRAINING_JOBS = 'training_jobs' VALIDATION_JOBS = 'validation_jobs' JOB_INDEX = elasticsearch_dsl.Index(TRAINING_JOBS) VALIDATION_JOB_INDEX = elasticsearch_dsl.Index(VALIDATION_JOBS) Metrics = namedtuple('Metrics', ['epochs', 'train_acc', 'final_val_acc', 'best_val_acc', 'final_val_loss', 'best_val_loss', 'final_val_sensitivity', 'best_val_sensitivity', 'final_val_specificity', 'best_val_specificity']) class TrainingJob(elasticsearch_dsl.Document): id = elasticsearch_dsl.Integer() schema_version = elasticsearch_dsl.Integer() job_name = elasticsearch_dsl.Keyword() author = elasticsearch_dsl.Keyword() created_at = elasticsearch_dsl.Date() ended_at = elasticsearch_dsl.Date() params = elasticsearch_dsl.Text() raw_log = elasticsearch_dsl.Text()