def __init__(self, params): """ `__init__()` initializes the necessary objects for using the Constraint. Attributes: `height` -- Board heigh. `widt` -- Board width. `count` int -- Number of solutions found. `board` []position -- List of currently allocated pieces. `board_index` int -- Index in the list of allocated pieces. `pieces` []int -- List of given pieces to allocate. `last_xy` [][]coordinate -- List of last used position -- per every type of piece. `last_index` []int -- Index in the list of last positions. `used_cols` []int -- Attacked columns. `used_rows` []int -- Attacked rows. `used_diag_l` []int -- Attacked diagonals (left) `used_diag_r` []int -- Attacked diagonals (right) `used_cells` []int -- Map of cells "under attack". `king_rules` [8]coordinate -- Permitted moves for king `knight_rules` [8]coordinate -- Permitted moves for knight """ position = recordtype("position", ["x", "y", "kind"]) coordinate = recordtype("coordinate", ["x", "y"]) self.width = params["m"] self.height = params["n"] self.count = 0 self.pieces = params["pieces"] self.board = [] for _ in self.pieces: self.board.append(position(0, 0, 0)) self.board_index = 0 self.last_xy = [] self.last_index = [0] * number_of_types for _ in range(number_of_types): coord_list = [] for _ in range(len(self.pieces) + 1): coord_list.append(coordinate(0, 0)) self.last_xy.append(coord_list) self.attacked_cols = [0] * self.width self.attacked_rows = [0] * self.height self.attacked_diag_l = [0] * (self.width + self.height) self.attacked_diag_r = [0] * (self.width + self.height) self.attacked_cells = [0] * ((self.width+4) * (self.height+4)) self.king_rules = [ coordinate(-1, 0), coordinate(1, 0), coordinate(0, -1), coordinate(0, 1), coordinate(-1, -1), coordinate(1, 1), coordinate(1, -1), coordinate(-1, 1) ] self.knight_rules = [ coordinate(-2, -1), coordinate(-2, 1), coordinate(2, -1), coordinate(2, 1), coordinate(-1, -2), coordinate(-1, 2), coordinate(1, -2), coordinate(1, 2) ]
def train(model, optimizer, train_loader, model_evaluator, detection_loss, params, verbose, start_epoch=0, use_amp=False): """ args: model - nn.Module CNN to train optimizer - torch.optim params - json config trains model, saves best model by validation """ losses = [0] * 4 model.train() print("Total number of parameters trained this epoch: ", sum(p.numel() for pg in optimizer.param_groups for p in pg['params'] if p.requires_grad)) average_time = recordtype('average_time', ['inference_time', 'backprop_time', 'optimizer_time']) total_time = recordtype('total_time', ['inference_time', 'backprop_time', 'optimizer_time']) average = average_time(inference_time=0, backprop_time=0, optimizer_time=0) total = total_time(inference_time=0, backprop_time=0, optimizer_time=0) WARM_UP = 2 nr_batches = len(train_loader) counted_batches = nr_batches - WARM_UP for batch_idx, (input_, label, _) in enumerate(train_loader): if verbose: print("Batch id: ", batch_idx) now1 = time.time() batch_time = train_step(model, input_, label, optimizer, losses, detection_loss, params, verbose, use_amp) now2 = time.time() if verbose: print("=================") if batch_idx >= WARM_UP: average.inference_time += batch_time.inference_time / counted_batches average.backprop_time += batch_time.backprop_time / counted_batches average.optimizer_time += batch_time.optimizer_time / counted_batches total.inference_time += batch_time.inference_time total.backprop_time += batch_time.backprop_time total.optimizer_time += batch_time.optimizer_time if verbose: print("Total time: {}\n\n".format(now2-now1)) print("Times on {} batches of size {}:".format(counted_batches, params.batch_size)) print(average) print(total) print("Total time: ", total.inference_time + total.backprop_time + total.optimizer_time)
def setUpClass(cls): # Create test's data cls.test_data_list = [] cls.TestDataDevelop = recordtype("TestDataDevelop", "type data host port database user \ password schema") cls.TestDataTest = recordtype("TestDataTest", "type data host port virtualhost user \ password") cls.test_data_list.append( cls.TestDataDevelop("Develop.mr_robot", "test_data", "test_host", 1111, "test_database", "test_user", "test_password", "test_schema")) cls.test_data_list.append( cls.TestDataTest("Test.vpn", "test_data", "test_host", 2222, "test_virtualhost", "test_user", "test_password")) # add new test's data to table develop_mr_robot_configs with psql.open(host="localhost", user="******", database="db", password="******") as db: if not db.query( f"SELECT data FROM develop_mr_robot_configs\ WHERE data='{cls.test_data_list[0].data}'"): db.query(f"INSERT INTO develop_mr_robot_configs (data, host,\ port, database, \"user\", password, schema)\ VALUES \ ('{cls.test_data_list[0].data}',\ '{cls.test_data_list[0].host}',\ '{cls.test_data_list[0].port}',\ '{cls.test_data_list[0].database}',\ '{cls.test_data_list[0].user}',\ '{cls.test_data_list[0].password}',\ '{cls.test_data_list[0].schema}')") # add new test's data to table test_vpn_configs with psql.open(host="localhost", user="******", database="db", password="******") as db: if not db.query( f"SELECT data FROM test_vpn_configs\ WHERE data='{cls.test_data_list[1].data}'"): db.query(f"INSERT INTO test_vpn_configs (data, host, port,\ virtualhost, \"user\", password) VALUES \ ('{cls.test_data_list[1].data}',\ '{cls.test_data_list[1].host}',\ '{cls.test_data_list[1].port}',\ '{cls.test_data_list[1].virtualhost}',\ '{cls.test_data_list[1].user}',\ '{cls.test_data_list[1].password}')")
class NACopy(Edit, recordtype.recordtype("NACopy", ["copy", ("uncertain", False)])): """Represent copy number variants (Invitae-specific use) This class is intended for Invitae use only and does not represent a standard HGVS concept. The class may be changed, moved, or removed without notice. """ def __str__(self): s = "copy{}".format(self.copy) return "(" + s + ")" if self.uncertain else s def _set_uncertain(self): """sets the uncertain flag to True; used primarily by the HGVS grammar :returns: self """ self.uncertain = True return self @property def type(self): """return the type of this Edit :returns: edit type (str) """ return "copy" def _del_ins_lengths(self, ilen): """returns (del_len, ins_len). Unspecified ref or alt returns None for del_len or ins_len respectively. """ return (0, ilen * self.copy)
class RefTranscriptData(recordtype.recordtype("RefTranscriptData", ["transcript_sequence", "aa_sequence", "cds_start", "cds_stop", "protein_accession"])): @classmethod def setup_transcript_data(cls, ac, ac_p, db, ref="GRCh37.p10"): """helper for generating RefTranscriptData from for c_to_p""" tx_info = db.get_tx_info(ac) tx_seq = db.get_tx_seq(ac) if tx_info is None or tx_seq is None: raise hgvs.exceptions.HGVSError("Missing transcript data for accession: {}".format(ac)) # use 1-based hgvs coords cds_start = tx_info["cds_start_i"] + 1 cds_stop = tx_info["cds_end_i"] # padding list so biopython won't complain during the conversion tx_seq_to_translate = tx_seq[cds_start - 1:cds_stop] if len(tx_seq_to_translate) % 3 != 0: "".join(list(tx_seq_to_translate).extend(["N"] * ((3 - len(tx_seq_to_translate) % 3) % 3))) tx_seq_cds = Seq(tx_seq_to_translate) protein_seq = str(tx_seq_cds.translate()) transcript_data = RefTranscriptData(tx_seq, protein_seq, cds_start, cds_stop, ac_p) return transcript_data
def make_game_object(game_tag): """ :param game_tag: game_container from beautiful soup, to be parsed :return: game recordtype containing all information parsed, ready to be added to DB """ # main parser wrapper.... for now game_datetime = get_game_datetime(game_tag) away_team, home_team, away_rank, home_rank = get_team_names(game_tag) game_lines = check_has_lines(game_tag) away_spread, home_spread = get_game_spread(game_lines) away_ml, home_ml = get_moneyline(game_lines) over, under = get_game_total(game_lines) game_id = (game_datetime, home_team, away_team) # TODO: move this out of function Game = recordtype( 'Game', 'game_id away_spread home_spread away_ml home_ml over under ranks') game = Game(game_id=game_id, away_spread=away_spread, home_spread=home_spread, away_ml=away_ml, home_ml=home_ml, over=over, under=under, ranks=[home_rank, away_rank]) return game
def __init__(self, rows, cols, scope=10, num_food=5, max_pad=10): self.rows = rows self.cols = cols self.scope = scope self.num_food = num_food self.consumed_count = 0 self.max_pad = max_pad self.boxes = [] self.pos = recordtype('pos', 'rownum colnum') for i in range(rows): row_box = [] for j in range(cols): row_box.append(self.pos(i, j)) self.boxes.append(row_box) self.current_pos = self.pos(random.randint(0, self.rows - 1), random.randint(0, self.cols - 1)) self.foods = [ self.pos(random.randint(0, self.rows - 1), random.randint(0, self.cols - 1)) for _ in range(self.num_food) ]
def recordtype_row_strategy(column_names): """ Recordtype row strategy, rows returned as recordtypes Column names that are not valid Python identifiers will be replaced with col<number>_ """ import recordtype # optional dependency # replace empty column names with placeholders column_names = [ name if is_valid_identifier(name) else 'col%s_' % idx for idx, name in enumerate(column_names) ] recordtype_row_class = recordtype.recordtype('Row', column_names) # custom extension class that supports indexing class Row(recordtype_row_class): def __getitem__(self, index): if isinstance(index, slice): return tuple(getattr(self, x) for x in self.__slots__[index]) return getattr(self, self.__slots__[index]) def __setitem__(self, index, value): setattr(self, self.__slots__[index], value) def row_factory(row): return Row(*row) return row_factory
def __init__(self, value_dic, vector_name='Vector'): value_tuple = tuple(value_dic.values()) self.len_tuple = len(value_tuple) self.validate(value_tuple) self.vector_nt = recordtype(vector_name, ' '.join([k for k in value_dic.keys()])) self._vector = value_tuple
def forward(input_parameter_name): """ Forwards a Task's input as an output :param input_parameter_name: The name of this cmd_fxn's input parameter to forward """ return recordtype('Forward', 'input_parameter_name', default=None)
def out_dir(basename=''): """ Essentially will perform os.path.join(Task.output_dir, basename) :param str basename: The basename of the output_file """ return recordtype('OutputDir', 'basename', default=None)
def out_dir(basename=""): """ Essentially will perform os.path.join(Task.output_dir, basename) :param str basename: The basename of the output_file """ return recordtype("OutputDir", "basename", default=None)
def forward(input_parameter_name): """ Forwards a Task's input as an output :param input_parameter_name: The name of this cmd_fxn's input parameter to forward """ return recordtype("Forward", "input_parameter_name", default=None)
def recordtype_row_strategy(column_names): """ Recordtype row strategy, rows returned as recordtypes Column names that are not valid Python identifiers will be replaced with col<number>_ """ import recordtype # optional dependency # replace empty column names with placeholders column_names = [name if is_valid_identifier(name) else 'col%s_' % idx for idx, name in enumerate(column_names)] recordtype_row_class = recordtype.recordtype('Row', column_names) # custom extension class that supports indexing class Row(recordtype_row_class): def __getitem__(self, index): if isinstance(index, slice): return tuple(getattr(self, x) for x in self.__slots__[index]) return getattr(self, self.__slots__[index]) def __setitem__(self, index, value): setattr(self, self.__slots__[index], value) def row_factory(row): return Row(*row) return row_factory
class Repeat(Edit, recordtype.recordtype('Repeat', [('ref', None), ('min', None), ('max', None), ('uncertain', False)])): def __str__(self): if self.min > self.max: raise HGVSError( "Repeat min count must be less than or equal to max count") if self.min == self.max: return "{self.ref}[{self.min}]".format(self=self) return "{self.ref}({self.min}_{self.max})".format(self=self) def _set_uncertain(self): """sets the uncertain flag to True; used primarily by the HGVS grammar :returns: self """ self.uncertain = True return self @property def type(self): """return the type of this Edit :returns: edit type (str) """ return "repeat"
def train_step(model, input_, label, optimizer, losses, detection_loss, params, verbose, use_amp=False): input_ = input_.to(device) label[0] = label[0].to(device) label[1] = label[1].to(device) optimizer.zero_grad() # ================= # START INFERENCE time_before_inference = time.time() output = model(input_) time_after_inference = time.time() inference_duration = time_after_inference - time_before_inference if verbose: print("Forward propagation time: {}".format(inference_duration)) # END INFERENCE # ================= # ================= # START BACKPROPAGATION time_before_backprop = time.time() l_loss, c_loss = detection_loss.ssd_loss(output, label) loss = l_loss + c_loss update_losses(losses, l_loss.item(), c_loss.item()) if use_amp: with amp.scale_loss(loss, optimizer) as scaled_loss: scaled_loss.backward() else: loss.backward() time_after_backprop = time.time() backprop_duration = time_after_backprop - time_before_backprop if verbose: print("Backward propagation time: {}".format(backprop_duration)) # END BACKPROPAGATION # ================= a = time.time() optimizer.step() b = time.time() optimizer_duration = b-a if verbose: print("Optimizer step time: ", optimizer_duration) Times = recordtype('Times', ['inference_time', 'backprop_time', 'optimizer_time']) batch_time = Times(inference_time=inference_duration, backprop_time=backprop_duration, optimizer_time=optimizer_duration) return batch_time
class ParseResult( recordtype('ParseResult', 'scheme netloc path params query fragment'), urlparse1.ResultMixin): __slots__ = () def geturl(self): return urlparse1.urlunparse(self)
class SplitResult( recordtype('SplitResult', 'scheme netloc path query fragment'), urlparse1.ResultMixin): __slots__ = () def geturl(self): return urlparse1.urlunsplit(self)
def check_has_lines( game_tag ): # TODO: This is ugly. Come up with better way to handle this? """ :param game_tag: game_container from beautiful soup, to be parsed :return: recordtpe containing all parsed line information """ # check whether all lines are there or not and return the found tag if so # TODO: move this out of function Lines = recordtype( 'Lines', 'spread moneyline total prices has_spread has_moneyline has_total') lines = Lines(spread=None, moneyline=None, total=None, prices=None, has_spread=False, has_moneyline=False, has_total=False) lines.spread = game_tag.find_all('span', class_='market-line bet-handicap') lines.total = game_tag.find_all( 'span', class_='market-line bet-handicap both-handicaps') lines.prices = game_tag.find_all('span', class_='bet-price') # TODO: more elegant solution for this? for k in range(len(lines.prices)): price = lines.prices[k].text if '(' in price: for char in ['(', ')']: price = price.replace(char, '') lines.prices[k] = price num_prices = len(lines.prices) if num_prices == 6: lines.has_spread, lines.has_moneyline, lines.has_total = True, True, True elif num_prices == 4: if lines.spread: lines.has_spread = True if lines.total: lines.has_total = True if not lines.has_total or not lines.has_spread: lines.has_moneyline = True elif num_prices == 2: if lines.spread: lines.has_spread = True if lines.total: lines.has_total = True if not lines.has_total and not lines.has_spread: lines.has_moneyline = True # Pad lines.prices for indexing purposes if not lines.has_spread: lines.prices.insert(0, '') lines.prices.insert(0, '') if not lines.has_moneyline: lines.prices.insert(2, '') lines.prices.insert(2, '') return lines
def find(regex, n="==1", tags=None): """ Used to set an input_file's default behavior to finds output_files from a Task's parents using a regex :param str regex: a regex to match the file path :param str n: (cardinality) the number of files to find :param dict tags: filter parent search space using these tags """ return recordtype("FindFromParents", "regex n tags", default=None)
def dijkstra(): tests = [(1, 0, 3, 'R'), (-1, 0, 2, 'L'), (0, -1, 0, 'U'), (0, 1, 1, 'D')] def get_neighbors(x, y, path): k = key(x, y) ns = [] h = gethash(passw, path) for t in tests: tx = x + t[0] ty = y + t[1] if tx < 0 or ty < 0 or tx >= max_x or ty >= max_y: continue tk = key(tx, ty) if h[t[2]] in 'bcdef': ns.append((1, tx, ty, tk + path + t[3], path + t[3])) return ns QEntry = recordtype.recordtype('QEntry', 'x y k valid path') dist['0,0,'] = 0 prev['0,0,'] = None finder = {} inq = set() h = [] heapq.heappush(h, (0, 0, '', QEntry(x=0, y=0, k='0,0,', path='', valid=True))) finder['0,0,'] = h[0] inq.add('0,0,') while len(h) > 0: #print_map(dist); u = heapq.heappop(h) item = u[3] if not item.valid: continue inq.remove(item.k) if item.x == target_y and item.y == target_y: continue uk = item.k for v in get_neighbors(item.x, item.y, item.path): alt = dist[uk] + v[0] if alt > dist[v[3]]: dist[v[3]] = alt #prev[v[3]] = (uk, v[0], v[4], v[1], v[2]) entry = QEntry(x=v[1], y=v[2], k=v[3], path=v[4], valid=True) if v[3] in inq: finder[v[3]].valid = False inq.add(v[3]) finder[v[3]] = entry heapq.heappush(h, (-alt, -len(entry.path), entry.path, entry))
def Convert(): for file in files: #print("converting") f = open(file, 'r', encoding="utf-8") _file = f.read() f.close() text = [] _file = re.sub('\t*\n', '\n', _file) _file = re.sub(' *\n', '\n', _file) _file = re.sub('{', '{\n', _file) _file = re.sub('}', '\n}', _file) _file = re.sub('\"', '', _file) # Remove Comments for line in _file.split("\n"): if "#" in line: line = line.split("#")[0] text.append(line + "\n") # Format Input #print(text) out = "{" layer = 0 for line in text: if "{" in line: layer += 1 #print(line) temp = line.split("=") out += "\"{}\"".format(Replacer(temp[0])) + ": {" #print(temp) elif "}" in line: layer -= 1 out += "}," elif "=" in line: temp = line.split("=") out += "\"{}\" : \"{}\",".format(Replacer(temp[0]), Replacer(temp[1])) elif not line.isspace(): #print(line) out += "\"KEY_LESS_VALUE\":\"{}\",".format(line) out = out + "}" out = re.sub('\n', '', out) out = re.sub('\t', '', out) out = re.sub(',}', '}', out) #out = re.sub(' ','STL2PY_REPLACE_SPACE_',out) #print(out) try: x = json.loads(out, object_hook=lambda d: recordtype('X', d.keys()) (*d.values())) except Exception as e: print("\n-----") print(e) print(out) print(file)
def edge_expansion(edge, threshold, cursor): EDC = [] # added for avoid move back in network during searching visited_edges = [edge.edge_id] for node_geom in [edge.start_node, edge.end_node]: # for n in NODES: # n['dis'] = 0 visited_nodes = [] # TODO: maybe it should be copy of this node Node = recordtype('Node', 'geom dis') node = Node(node_geom, 0) H = [] heapq.heappush(H, (node.dis, node)) while H: node_min = heapq.heappop(H)[1] visited_nodes.append(node_min.geom) for edge_prim_record in get_node_edges(node_min.geom, cursor): edge_prim_id = edge_prim_record.edge_id if not edge_prim_id in visited_edges: edge_prim = get_edge_by_id(edge_prim_id, cursor) visited_edges.append(edge_prim_id) if node_geom == edge.start_node and node_min.geom == edge_prim.start_node: EDC.append((edge.edge_id, edge_prim.edge_id, 'SS', node_min.dis)) other_edge_prim_node = Node(edge_prim.end_node, 0) if node_geom == edge.start_node and node_min.geom == edge_prim.end_node: EDC.append((edge.edge_id, edge_prim.edge_id, 'SE', node_min.dis)) other_edge_prim_node = Node(edge_prim.start_node, 0) if node_geom == edge.end_node and node_min.geom == edge_prim.start_node: EDC.append((edge.edge_id, edge_prim.edge_id, 'ES', node_min.dis)) other_edge_prim_node = Node(edge_prim.end_node, 0) if node_geom == edge.end_node and node_min.geom == edge_prim.end_node: EDC.append((edge.edge_id, edge_prim.edge_id, 'EE', node_min.dis)) other_edge_prim_node = Node(edge_prim.start_node, 0) # find other node_primes of edge_prime if other_edge_prim_node.geom not in visited_nodes: # other_edge_prim_node['dis'] > node_min['dis'] + edge_prim['weight'] omitted if threshold >= node_min.dis + edge_prim.weight: other_edge_prim_node.dis = node_min.dis + edge_prim.weight heapq.heappush(H, (other_edge_prim_node.dis, other_edge_prim_node)) return EDC
def find(regex, n='==1', tags=None): """ Used to set an input_file's default behavior to finds output_files from a Task's parents using a regex :param str regex: a regex to match the file path :param str n: (cardinality) the number of files to find :param dict tags: filter parent search space using these tags """ return recordtype('FindFromParents', 'regex n tags', default=None)
def Options(optionsList=None, mutable=False): """Construct an o from proteus.LinearAlgebraToptions object (named tuple) :param optionsList: An iterable of options tuples. Each option is a 3-tuple, with the first entry the option name string, the second entry the default value, and the third entry a help string Example:: opts=Context.Options([("nnx", 11, "number of mesh nodes in x-direction"), ("nny", 21, "number of mesh nodes in y-direction"]) nnx = opts.nnx nny = opts.nny """ import ast, sys global contextOptionsString contextOptionsDict = {} help = "Context input options:\n" for optTuple in optionsList: help += """{0}[{1}] {2}\n\n""".format(optTuple[0], optTuple[1], optTuple[2]) contextOptionsDict[optTuple[0]] = optTuple[1] logEvent(help) if contextOptionsString == "?": print(help) contextOptionsString = None sys.exit(0) if contextOptionsString is not None: option_overides = contextOptionsString.split(" ") for option in option_overides: lvalue, rvalue = option.split("=") if lvalue in contextOptionsDict: logEvent("Processing context input options from commandline") try: contextOptionsDict[lvalue] = ast.literal_eval(rvalue) logEvent(lvalue + " = " + rvalue) except: sys.stderr.write( "Failed setting context options from command line string." ) raise else: logEvent("IGNORING CONTEXT OPTION; DECLARE " + lvalue + " IF YOU WANT TO SET IT") #now set named tuple merging optionsList and opts_cli_dihelpct if mutable: ContextOptions = recordtype("ContextOptions", iter(contextOptionsDict.items())) return ContextOptions() else: ContextOptions = namedtuple("ContextOptions", list(contextOptionsDict.keys())) return ContextOptions._make(list(contextOptionsDict.values()))
def get_record(recordtype, record_url): """ Given a record url and a recordtype, fetch the record from the and build the record. Assume there's just one record at the location and everything goes well """ resp = session.get(record_url) new_record = recordtype(**resp.json()) return new_record
def __init__(self, sensor_id, stream_names): """ sensor_id: the ID of the sensor that generates the stream stream_names: list of the stream names that the sensor generates """ Model = recordtype("Stream", "sensor_id timestamp streams") streams = dict((stream_names[i], 0) for i in range(0, len(stream_names))) self.stream = Model(sensor_id=sensor_id, timestamp=0, streams=streams)
class FunctionStats(recordtype('FunctionStatsRecord', 'cc nc tt ct callers')): def __getitem__(self, index): return getattr(self, self.__slots__[index]) @property def percall(self): return float(self.tt) / self.nc if self.nc else 0.0 @property def cumpercall(self): return float(self.ct) / self.cc if self.cc else 0.0
class AAExt(Edit, recordtype.recordtype("AAExt", [("ref", None), ("alt", None), ("aaterm", None), ("length", None), ("uncertain", False)])): def __init__(self, ref, alt, aaterm=None, length=None, uncertain=False): super(AAExt, self).__init__(ref=aa_to_aa1(ref), alt=aa_to_aa1(alt), aaterm=aa_to_aa1(aaterm), length=length, uncertain=uncertain) def format(self, conf=None): p_3_letter, p_term_asterisk = self._format_config(conf) st_alt = self.alt or "" st_aaterm = self.aaterm or "" st_length = self.length or "" if p_3_letter: st_alt = aa1_to_aa3(st_alt) st_aaterm = aa1_to_aa3(st_aaterm) if p_term_asterisk and st_alt == "Ter": st_alt = "*" if p_term_asterisk and st_aaterm == "Ter": st_aaterm = "*" s = "{alt}ext{term}{length}".format(alt=st_alt, term=st_aaterm, length=st_length) return "(" + s + ")" if self.uncertain else s __str__ = format def _set_uncertain(self): """sets the uncertain flag to True; used primarily by the HGVS grammar :returns: self """ self.uncertain = True return self @property def type(self): """return the type of this Edit :returns: edit type (str) """ return "ext" def _del_ins_lengths(self, ilen): """returns (del_len, ins_len). Unspecified ref or alt returns None for del_len or ins_len respectively. """ return (0, abs(self.length))
class HGVSPosition(recordtype.recordtype("HGVSPosition", ["ac", "type", "pos"])): """ HGVSPosition -- Represent partial HGVS tags that refer to a position without alleles :param str ac: sequence accession :param str type: type of sequence and coordinate :param str pos: sequence position """ def __str__(self): return "{self.ac}:{self.type}.{self.pos}".format(self=self)
def setFromModule(moduleIn,mutable=False): """Construct the global context object from a module""" global context fields = {} for key, value in moduleIn.__dict__.iteritems(): if key[:2] != "__": fields[key]=value if mutable: Context = recordtype(moduleIn.__name__.split('.')[-1], fields.iteritems()) context = Context() else: Context = namedtuple(moduleIn.__name__.split('.')[-1], fields.keys()) context = Context._make(fields.values())
def perceptron_algorithm_iter(vector, init_w=None, is_offset=False, max_iter=20): Run = recordtype('Run', 'init_w final_w nb_iter') Weight = recordtype('Weight', 'theta theta_0') if not init_w: w = Weight(np.array([0, 0]), 0) else: init_w_copy = init_w.theta.copy() w = init_w iter = 0 while not is_all_right(vector) and iter < max_iter: for point in vector.points: if is_not_right(point, w): update_weight(point, w) elif is_right(point, w): update_point_status(point) else: iter += 1 return Run(Weight(init_w_copy, 0), w, iter)
class Inv(Edit, recordtype.recordtype('Inv', [('ref', None), ('uncertain', False)])): """Inversion """ def __init__(self, ref=None, uncertain=False, edit=None): if edit: ref = edit.ref uncertain = edit.uncertain super(Inv, self).__init__(ref=ref, uncertain=uncertain) def __str__(self): return "inv" def _set_uncertain(self): """sets the uncertain flag to True; used primarily by the HGVS grammar :returns: self """ self.uncertain = True return self @property def ref_s(self): return self.ref if (isinstance(self.ref, basestring) and self.ref and self.ref[0] in "ACGTUN") else None @property def ref_n(self): """ returns an integer, either from the `seq` instance variable if it's a number, or None otherwise """ try: return int(self.ref) except ValueError: return None @property def type(self): """return the type of this Edit :returns: edit type (str) """ return "inv" def _del_ins_lengths(self, ilen): """returns (del_len, ins_len). Unspecified ref or alt returns None for del_len or ins_len respectively. """ return (ilen, ilen)
def Options(optionsList=None,mutable=False): """Construct an o from proteus.LinearAlgebraToptions object (named tuple) :param optionsList: An iterable of options tuples. Each option is a 3-tuple, with the first entry the option name string, the second entry the default value, and the third entry a help string Example:: opts=Context.Options([("nnx", 11, "number of mesh nodes in x-direction"), ("nny", 21, "number of mesh nodes in y-direction"]) nnx = opts.nnx nny = opts.nny """ import ast, sys global contextOptionsString contextOptionsDict = {} help="Context input options:\n" for optTuple in optionsList: help += """{0}[{1}] {2}\n\n""".format(optTuple[0], optTuple[1], optTuple[2]) contextOptionsDict[optTuple[0]] = optTuple[1] logEvent(help) if contextOptionsString=="?": print(help) contextOptionsString=None if contextOptionsString is not None: option_overides=contextOptionsString.split(" ") for option in option_overides: lvalue, rvalue = option.split("=") if contextOptionsDict.has_key(lvalue): logEvent("Processing context input options from commandline") try: contextOptionsDict[lvalue] = ast.literal_eval(rvalue) logEvent(lvalue+" = "+rvalue) except: sys.stderr.write("Failed setting context options from command line string.") raise else: logEvent("IGNORING CONTEXT OPTION; DECLARE "+lvalue+" IF YOU WANT TO SET IT") #now set named tuple merging optionsList and opts_cli_dihelpct if mutable: ContextOptions = recordtype("ContextOptions", contextOptionsDict.iteritems()) return ContextOptions() else: ContextOptions = namedtuple("ContextOptions", contextOptionsDict.keys()) return ContextOptions._make(contextOptionsDict.values())
def __init__(self, buffer_size, batch_size, device='cpu'): """Initialize a ReplayBuffer object. Params ====== buffer_size (int): maximum size of buffer batch_size (int): size of each training batch """ self.DEVICE = device self.memory = deque(maxlen=buffer_size) self.batch_size = batch_size self.experience = recordtype( 'Experience', ["state", "action", "reward", "next_state", "done"])
def dicts_to_namedrecords(dicts, class_name=None): """ Takes list of dictionaries and converts to list of recordtype objects""" from recordtype import recordtype from random import randint from sets import Set all_keys = [] for dic in dicts: all_keys += dic.keys() unique_keys = list(Set(all_keys)) key_defaults = [(key, None) for key in unique_keys] if not class_name: class_name = 'FB_Record_Type_' Record = recordtype(class_name + str(randint(1,9999999)), key_defaults) data = [Record(**dic) for dic in dicts] return data
def attributes_class_constructor(name, fields, identity=True, *args, **kwargs): if not identity: return recordtype.recordtype(name, fields, *args, **kwargs) # Create the new class, inheriting from the record type and from this # class class IdentityClass(recordtype.recordtype(name, fields, *args, **kwargs)): def __init__(self, id=None, created_at=None, updated_at=None, *init_args, **init_kwargs): super(IdentityClass, self).__init__(*init_args, **init_kwargs) self.id = id self.created_at = created_at self.updated_at = updated_at @property def id(self): return self._id @id.setter def id(self, value): if value is not None: value = int(value) self._id = value @property def created_at(self): return self._created_at @created_at.setter def created_at(self, value): if value is not None and not isinstance(value, datetime): value = dateutil.parser.parse(value) self._created_at = value @property def updated_at(self): return self._updated_at @updated_at.setter def updated_at(self, value): if value is not None and not isinstance(value, datetime): value = dateutil.parser.parse(value) self._updated_at = value return IdentityClass
class SimplePosition( recordtype.recordtype("SimplePosition", field_names=[("base", None), ("uncertain", False)])): def __str__(self): self.validate() s = "?" if self.base is None else str(self.base) return "(" + s + ")" if self.uncertain else s def format(self, conf): return str(self) @property def is_uncertain(self): """return True if the position is marked uncertain or undefined""" return self.uncertain or self.base in None def _set_uncertain(self): "mark this location as uncertain and return reference to self; this is called during parsing (see hgvs.ometa)" self.uncertain = True return self def validate(self): if self.base is not None and self.base < 1: return (ValidationLevel.ERROR, "Position base must be >= 1") return (ValidationLevel.VALID, None) def __sub__(lhs, rhs): assert type(lhs) == type( rhs), "Cannot substract coordinates of different representations" return lhs.base - rhs.base def __eq__(lhs, rhs): assert type(lhs) == type( rhs), "Cannot compare coordinates of different representations" if lhs.uncertain or rhs.uncertain: raise HGVSUnsupportedOperationError( "Cannot compare coordinates of uncertain positions") return lhs.base == rhs.base def __lt__(lhs, rhs): assert type(lhs) == type( rhs), "Cannot compare coordinates of different representations" if lhs.uncertain or rhs.uncertain: raise HGVSUnsupportedOperationError( "Cannot compare coordinates of uncertain positions") return lhs.base < rhs.base
class Conv(Edit, recordtype.recordtype('Conv', [('from_ac', None), ('from_type', None), ('from_pos', None), ('uncertain', False)])): """Conversion """ def __init__(self, from_ac=None, from_type=None, from_pos=None, uncertain=False, edit=None): if edit: from_ac = edit.from_ac from_type = edit.from_type from_pos = edit.from_pos uncertain = edit.uncertain super(Conv, self).__init__(from_ac=from_ac, from_type=from_type, from_pos=from_pos, uncertain=uncertain) def __str__(self): if self.from_ac and self.from_type and self.from_pos: s = "con{self.from_ac}:{self.from_type}.{self.from_pos}".format( self=self) else: s = "con" return "(" + s + ")" if self.uncertain else s def _set_uncertain(self): """sets the uncertain flag to True; used primarily by the HGVS grammar :returns: self """ self.uncertain = True return self @property def type(self): """return the type of this Edit :returns: edit type (str) """ return "con"
from .tools import StringIO, icmp, list, target_from_compact, tuple __all__ = [ 'ChainParameters', 'Output', 'Input', 'Transaction', 'Block', 'ConnectedBlockInfo', ] # ===----------------------------------------------------------------------=== ChainParameters = recordtype('ChainParameters', ['magic', 'port', 'genesis', 'testnet', 'pubkey_hash_prefix', 'script_hash_prefix', 'secret_prefix', 'max_value', 'transient_reward', 'transient_budget', 'perpetual_reward', 'perpetual_budget', 'fee_budget', 'maximum_target', 'next_target', 'alert_keys','checkpoints', 'features']) # ===----------------------------------------------------------------------=== class Output(SerializableMixin): def __init__(self, amount=0, contract=None, *args, **kwargs): if contract is None: contract = self.get_script_class()() super(Output, self).__init__(*args, **kwargs) self.amount = amount self.contract = contract @classmethod def get_script_class(cls):
@event.listens_for(Engine, 'before_cursor_execute') def before_cursor_execute(conn, cursor, statement, parameters, context, executemany): global query_stats query_stats._begin = datetime.now() @event.listens_for(Engine, 'after_cursor_execute') def after_cursor_execute(conn, cursor, statement, parameters, context, executemany): global query_stats query_stats.num_queries += 1 query_stats.time_database += (datetime.now() - query_stats._begin).total_seconds() from recordtype import recordtype TableStatistics = recordtype('TableStatistics', 'num_inserts num_updates num_deletes'.split(), default=0) @event.listens_for(Mapper, 'after_insert') def after_insert(mapper, connection, target): global query_stats query_stats.table_stats.setdefault(target.__table__.name, TableStatistics()) query_stats.table_stats[target.__table__.name].num_inserts += 1 @event.listens_for(Mapper, 'after_update') def after_update(mapper, connection, target): global query_stats query_stats.table_stats.setdefault(target.__table__.name, TableStatistics()) query_stats.table_stats[target.__table__.name].num_updates += 1 @event.listens_for(Mapper, 'after_delete') def after_delete(mapper, connection, target):
import boto.ec2 from recordtype import recordtype from .util import AMI_MAP Network = recordtype('Network', [ "net_name", "root_folder", "AWS_region", "AWS_ACCESS_KEY", "AWS_SECRET_KEY", "AWS_keypair", "AWS_security_group", "sync_node", "sync_node_user", "monitor_node", "bridge_node", "config_node", "mailgun_domain", "mailgun_key", "alert_recipients", "system_alert_recipients", "code_repo", "config_repo", "blobs_repo", ], default=None) def _(s): print(textwrap.dedent(s).strip()) def ask(msg, default): return raw_input("%s [%s]: " % (msg, default)) or default
def _work(self): def update_connected_routers_info(): new_connected_routers = \ connected_routers - prev_connected_routers new_disconnected_routers = \ prev_connected_routers - connected_routers if new_connected_routers: self._logger.debug("Connected to routers: {0}".format( list(new_connected_routers))) if new_disconnected_routers: self._logger.debug("Disconnected from routers: {0}".format( list(new_disconnected_routers))) # Remove disconnected routers from list. for router_name in new_disconnected_routers: assert router_name in connected_rrs_info del connected_rrs_info[router_name] # Set distance to infinity for destination routers route to which # leaded through disconnected routers. for to_router, dest_router_info in dest_routers_info.iteritems(): if dest_router_info.next_router in new_disconnected_routers: dest_router_info.dist = RIPService.inf_distance self._logger.debug( "Remove route: Due to disconnection: " "{dest}:(d={dist}, n={next})".format( dest=to_router, dist=dest_router_info.dist, next=dest_router_info.next_router)) # Add connected hosts to according list. for router_name in new_connected_routers: router_name not in connected_rrs_info connected_rrs_info[router_name] = \ ConnectedRouterInfo(Timer(self._update_period, start_time=time.time() - self._update_period - 1.0)) assert connected_rrs_info[router_name].timer.is_expired() # Update routing information for directly connected destination # routers. for router_name in new_connected_routers: dest_routers_info[router_name] = DestRouterInfo( dist=1, next_router=router_name, timer=DummyTimer()) self._logger.debug( "Add route: Directly connected: " "{dest}:(d={dist}, n={next})".format( dest=router_name, dist=dest_routers_info[router_name].dist, next=dest_routers_info[router_name].next_router)) table_changed = new_connected_routers or new_disconnected_routers if table_changed: update_routing_table() def connected_routers_with_timeout(): for rr_name, connected_rr_info in connected_rrs_info.iteritems(): if connected_rr_info.timer.is_expired(): yield rr_name def set_infinite_timeout_distances(): routing_table_updated = False for dest, dest_router_info in dest_routers_info.iteritems(): if (dest_router_info.dist < RIPService.inf_distance and dest_router_info.timer.is_expired()): dest_router_info.dist = RIPService.inf_distance dest_router_info.timer = Timer(self._remove_timeout) routing_table_updated = True self._logger.debug( "Remove route: Due to timeout: " "{dest}:(d={dist}, n={next})".format( dest=dest, dist=dest_router_info.dist, next=dest_router_info.next_router)) if routing_table_updated: update_routing_table() def remove_timeout_distances(): routing_table_updated = False for dest, dest_router_info in dest_routers_info.items(): if (dest_router_info.dist == RIPService.inf_distance and dest_router_info.timer.is_expired()): del dest_routers_info[dest] routing_table_updated = True self._logger.debug( "Due to big timeout removing target: {dest}".format( dest=dest)) # TODO: Not actually needed. if routing_table_updated: update_routing_table() def distances_for_sending(to_router): distances = [] for dest, dest_router_info in dest_routers_info.iteritems(): if dest_router_info.next_router == to_router: # Rule 1A from [vasilev04netsoft]: # For router R: if packets to destination router X are sent # through router G, then distance to router X that being # sent to router G is infinity. # # R ----------------- G - ... - X # X:(inf, G) -> # d = (RIPService.inf_distance, dest) distances.append(d) else: d = (dest_router_info.dist, dest) distances.append(d) return distances def send_distances(routers): for to_router in routers: # Prepare data to send. distances = distances_for_sending(to_router) raw_data = RIPData(distances).serialize() # Send data. self._service_transmitter.send_data(to_router, raw_data) # Mark time data was sent. connected_rrs_info[to_router].timer.restart() # TODO: Assume that computer is not slow. assert not connected_rrs_info[to_router].timer.is_expired() def handle_receive(): while True: result = self._service_transmitter.receive_data(block=False) if result is None: break src, raw_data = result rip_data = RIPData.deserialize(raw_data) self._logger.debug( "Received vector from {0}:\n {1}".format( src, pprint.pformat(rip_data.distances))) routing_table_updated = False for dist, dest in rip_data.distances: dist = min(dist + 1, RIPService.inf_distance) if dest not in dest_routers_info: # Route to new router. if dist < RIPService.inf_distance: dest_routers_info[dest] = DestRouterInfo( dist=dist, next_router=src, timer=Timer(self._inf_timeout)) routing_table_updated = True self._logger.debug( "Received route to new router: " "{dest}:(d={dist}, n={next})".format( dest=dest, dist=dist, next=src)) else: # Ignore. pass elif dist < dest_routers_info[dest].dist: # Received shorter then all known path to router. dest_routers_info[dest].dist = dist dest_routers_info[dest].next_router = src dest_routers_info[dest].timer = \ Timer(self._inf_timeout) routing_table_updated = True self._logger.debug( "Found shorter path: " "{dest}:(d={dist}, n={next})".format( dest=dest, dist=dist, next=src)) elif (dest_routers_info[dest].next_router == src and dest_routers_info[dest].dist != dist): # Received route update from source. dest_routers_info[dest].dist = dist timer = Timer(self._inf_timeout) \ if dist < RIPService.inf_distance \ else Timer(self._remove_timeout) dest_routers_info[dest].timer = timer routing_table_updated = True self._logger.debug( "Received route update from source: " "{dest}:(d={dist}, n={next})".format( dest=dest, dist=dist, next=src)) else: if dist < RIPService.inf_distance: # Update timer. dest_routers_info[dest].timer.restart() else: # Don't update timer for infinite paths. pass if routing_table_updated: update_routing_table() def update_routing_table(): old_routing_table = self._dynamic_routing_table.table().copy() new_routing_table = {} for dest, dest_rr_info in dest_routers_info.iteritems(): if dest_rr_info.dist < RIPService.inf_distance: assert dest not in new_routing_table new_routing_table[dest] = \ RIPService.RIPRouteToDestination( dest_rr_info.next_router, dest_rr_info.dist) if old_routing_table != new_routing_table: self._logger.debug("New routing table:\n {0}".format( pprint.pformat(new_routing_table))) self._dynamic_routing_table.update(new_routing_table) self._logger.info("Working thread started") DestRouterInfo = recordtype( 'DestRouterInfo', 'dist next_router timer') ConnectedRouterInfo = recordtype('ConnectedRouterInfo', 'timer') # {destination router name: DestRouterInfo()} # `timer' member is for last time information about destination router # was updated, dest_routers_info = {self._router_name: DestRouterInfo(dist=0, next_router=self._router_name, timer=DummyTimer())} # {connected router: ConnectedRouterInfo()} # `timer' member if for last time information packet was sent to # router} connected_rrs_info = {} connected_routers = frozenset() while True: if self._exit_lock.acquire(False): # Obtained exit lock. Terminate. self._exit_lock.release() self._logger.info("Exit working thread") return # Prepare data for detecting changes in current router connectivity. prev_connected_routers = connected_routers connected_routers = \ frozenset(self._link_manager.connected_routers()) # Remove information about disconnected routers and add information # about newly connected routers. update_connected_routers_info() # Send distances information to all who needs it. send_distances(list(connected_routers_with_timeout())) # Update distances according to received packets. handle_receive() set_infinite_timeout_distances() remove_timeout_distances() time.sleep(config.thread_sleep_time)
'<%s type=%s message=%s mark=%s>' % ( str(self.__class__).split('.')[-1][:-2], self.type, self.message, self.mark) ) def __str__(self): return ( super(MarkedIssue, self).__str__() + (' (source "%s" line %d column %d)' % (self.mark.source, self.mark.line + 1, self.mark.column + 1)) ) Rule = recordtype('Rule', ['name', 'description']) class Inspection(object): @classmethod def all_inspections(klass): return [c for c in all_subclasses(klass)] @classmethod def rules(klass): if hasattr(klass, 'name') and hasattr(klass, 'description'): return [Rule(klass.name, klass.description)] else: return []
from collections import namedtuple from os import access, path, W_OK from flask import current_app from recordtype import recordtype from werkzeug.security import generate_password_hash, check_password_hash from flask.ext.login import UserMixin import models_jsonapi as mj from . import db, login_manager, date_util from datetime import timedelta StateWarning = namedtuple('StateWarning', ['limit', 'value', 'created_ts', 'sensor', 'alarming_measurements']) RRDDef = recordtype('RRDDef', 'name step path mmin mmax') class Measurement(object): def __init__(self, sensor_code): self.sensor_code = sensor_code self.sensor = None self.value = None self.read_ts = None self.has_warning = False self.has_notification = False def init_sensor(self): self.sensor = db.session.query(Sensor).filter(Sensor.sensor_code == self.sensor_code).first()
SIL_LABEL = 'SIL' NOISES = set(['SIL', 'SPN']) # FILE1 = 's0101a' # FILE2 = FILE1 # FILE2 = 's2001a' def silentremove(filename): try: os.remove(filename) except OSError as e: if e.errno != errno.ENOENT: # errno.ENOENT = no such file or directory raise LabelledInterval = recordtype('LabelledInterval' ,'label interval') def load_gold(goldfile): res = {} current_file = '' prev_end = -1 with open(goldfile) as fin: for line in fin: splitted = line.strip().split() if not splitted: # empty line continue elif len(splitted) == 1: # New file current_file = splitted[0]
assert 1 <= secret.exponent < SECP256k1.order, (u"encoded exponent " u"must be an integer x such that 1 <= x < 0x%x" % SECP256k1.order) # Return the newly generated Secret return secret # The exponent is stored as a 256-bit big endian integer, the first field # of the payload: exponent = property(lambda self:BigInteger.deserialize(BytesIO(self.payload[:32]), 32)) # A compressed key is requested by suffixing 0x01 to the payload field. Note # that the following comparison only returns true if payload is exactly 33 # bytes in length and the final byte is '\x01'. compressed = property(lambda self:self.payload[32:] == six.int2byte(1)) from recordtype import recordtype BaseSignature = recordtype('BaseSignature', 'r s'.split()) class Signature(SerializableMixin, BaseSignature): def serialize(self): def _serialize_derint(n): n_str = BigNum(n).serialize() return b''.join([ six.int2byte(0x02), six.int2byte(len(n_str)), n_str, ]) r_str = _serialize_derint(self.r) s_str = _serialize_derint(self.s) return b''.join([ six.int2byte(0x30), six.int2byte(len(r_str + s_str)),
def run(self, command, *args, **kwargs): if self.use_sudo: command = ['sudo'] + command result = self.shell.run(command, allow_error=True, *args, **kwargs) self.logger.debug('Executed command: %s, ' 'result code %d, output:\n%s' % (' '.join(command), result.return_code, result.output)) return result def open(self, path, mode='r'): self.logger.debug('Opening file %s mode %s' % (path, mode)) return self.shell.open(path, mode) ProcessInfo = recordtype('ProcessInfo', ['pid', 'command']) class ExtendedNodeClient(object): def __init__(self, client): super(ExtendedNodeClient, self).__init__() self._client = client def run(self, command, *args, **kwargs): return self._client.run(command, *args, **kwargs) def open(self, path, mode='r'): return self._client.open(path, mode) def get_processes(self, reload=False): if not hasattr(self, '_processes') or reload:
# Tolerance on convergence test tol = 1e-2 NUM_PRINCIPLE_COMPONENTS = 5 from recordtype import recordtype #for mutable namedtuple (dict might also work) SettingsStruct = recordtype('SettingsStruct', ['shape_learning', #String representing the shape which the object is learning 'initDatasetFile', #Path to the dataset file that will be used to initialize the matrix for PCA 'updateDatasetFiles', #List of path -- or single path-- to dataset that will be updated with demo shapes 'paramFile', #Path to the dataset file 'params.dat' inside which we save the learned parameters 'paramsToVary', #Natural number between 1 and number of parameters in the associated ShapeModeler, representing the parameter to learn 'doGroupwiseComparison', #instead of pairwise comparison with most recent two shapes 'initialBounds', #Initial acceptable parameter range (if a value is NaN, the initialBounds_stdDevMultiples setting will be used to set that value) 'initialBounds_stdDevMultiples', #Initial acceptable parameter range in terms of the standard deviation of the parameter 'initialParamValue', #Initial parameter value (NaN if to be drawn uniformly from initialBounds) 'minParamDiff']) #How different two shapes' parameters need to be to be published for comparison #@todo: make groupwise comparison/pairwise comparison different implementations of shapeLearner class class ShapeLearner: def __init__(self, settings): self.paramsToVary = settings.paramsToVary #self.numPrincipleComponents = max(self.paramsToVary) self.numPrincipleComponents = NUM_PRINCIPLE_COMPONENTS
from recordtype import recordtype Review = recordtype( "Review", ["review_id", "business_id", "user_id", "date", "type", "text", "stars", "votes"], default=None )
from inspect import isfunction from collections import OrderedDict from recordtype import recordtype from six import iteritems import numpy as np import theano import theano.tensor as T _logger = logging.getLogger(__name__) #------------------------------------------------------------------------------ HyperParam = recordtype('HyperParam', 'value name default help') #------------------------------------------------------------------------------ class HyperBase(object): initialized = False def __init__(self, **hyper_params): self._hyper_params = OrderedDict() self.initialized = True def _ensure_init(self): if not self.initialized: raise ArgumentError("HyperBase base class not initialized yet!" "Call yperBase.__init__() before doing anything else!")
import random import numpy as np from numpy.linalg import norm from collections import namedtuple from recordtype import recordtype Cluster = recordtype('Cluster', ('center', 'members', 'converged')) class KMeans: def __init__(self, X, k, iters = 1): self.X = X self.k = k self.iters = iters self.cost = None self.clusters = [] def fit(self): self.clusters = self.__find_centers(self.X, self.k, self.clusters) self.cost = self.__cost(self.clusters) for _ in xrange(self.iters - 1): new_clusters = self.__find_centers(self.X, self.k, self.clusters) new_cost = self.__cost(self.clusters) if (new_cost < self.cost): self.clusters = new_clusters self.cost = new_cost return self.clusters def __find_centers(self, X, k, clusters):
def attribute_repr(self, indent_level=0): """Pretty print for an attribute.""" indent = '\t' * indent_level return '%s{Attribute: %s = %s}' % (indent, self.key, str(self.value)) def widget_repr(self, indent_level=0): """Pretty print for a widget.""" indent = '\t' * indent_level attrs = '\n'.join([a.repr(indent_level + 1) for a in self.attributes]) child_widgets = '\n\n'.join([c.repr(indent_level + 1) for c in self.child_widgets]) if attrs and child_widgets: attrs += '\n\n' return '%s{Widget: %s\n%s%s\n%s}' % (indent, self.name, attrs, child_widgets, indent) # AST nodes # TODO: Make your changes here ################################################ Attribute = recordtype('Attribute', 'key, value') Widget = recordtype('Widget', 'name, attributes, child_widgets') # Give them a pretty print method Attribute.repr = attribute_repr Widget.repr = widget_repr
using different strategies and different metrics """ import logging; shapeLogger = logging.getLogger("shape_logger") import os.path from recordtype import recordtype import glob import numpy as np from allograph import stroke from allograph.stroke import Stroke from ast import literal_eval # global variables : #------------------- Shape = recordtype('Shape', [('path', None), ('shapeID', None), ('shapeType', None), ('shapeType_code', None), ('paramsToVary', None), ('paramValues', None)]) alphabet = "abcdefghijklmnopqrstuvwxyz0123456789" # learning_manager class : #------------------------- class LearningManager(): def __init__(self, generate_path, demo_path, robot_path, ref_path): self.generate_path = generate_path self.demo_path = demo_path self.robot_path = robot_path self.ref_path = ref_path self.robot_data = read_data(self.robot_path,0)
system. Part of 'Adaptor' framework. Author: Michael Pankov, 2012-2013. Please do not redistribute. """ import recordtype as rt import collections as cl from printable_structure import PrintableStructure CPUInfoBase = rt.recordtype('CPUInfo', 'cpu_name cpu_mhz cache_size flags') class CPUInfo(PrintableStructure, CPUInfoBase): pass HardwareInfoBase = rt.recordtype('HardwareInfo', 'cpu_info') class HardwareInfo(PrintableStructure, HardwareInfoBase): pass BuildSettingsBase = rt.recordtype('BuildSettings',
GHIBLI_URL = "https://ghibliapi.herokuapp.com/" session = requests.session() # We don't want to panic when we see charles custom SSL cert. # I've turned ssl verification off, but you can also pass a file path to charles's cert # There are several ways to handle this. session.verify = False # Here's what passing the cert file would look like. # You can ask charles to save the file somewhere on your machine # session.verify = "/Users/Christopher/charles_sessions/charles-ssl-proxying-certificate.pem" Person = recordtype("Person", ["id", "name", "gender", "age", "eye_color", "hair_color", "films", "species", "url"]) Species = recordtype("Species", ["id", "name", "classification", "eye_colors", "hair_colors", "url", "people", "films", ])
#!/usr/bin/env python import sys from os.path import dirname, realpath # Add the funcparserlib_talk directory to the path to import recordtype sys.path.insert(0, dirname(dirname(realpath(__file__)))) from recordtype import recordtype # AST nodes Calculation = recordtype('Calculation', 'left, operator, right') Operator = recordtype('Operator', 'sign') Number = recordtype('Number', 'value')
from .util import GeoRange import simplejson as json from lxml import etree from lxml.etree import ParseError from markupsafe import Markup RPC_URL = "http://webservices.nextbus.com/service/publicXMLFeed?" # cache durations SHORT = 20 HOUR = 3600 DAY = 86400 resource_uri = Markup("resource_uri") template_id = Markup("{{id}}") Point = recordtype("Point", ['lat', 'lng']) AgencyRecord = recordtype("Agency", ['id', 'title', 'region', ('short_title', None), ('route_ids', [])]) class Agency(AgencyRecord): @property def url(self): return url_for('agency_detail', agency_id=self.id) def _as_url_dict(self): d = self._asdict() d[resource_uri] = self.url detail_uri_template = url_for('route_detail', agency_id=self.id, route_id=template_id) # unescape mustaches detail_uri_template = detail_uri_template.replace("%7B", "{").replace("%7D", "}") d['routes'] = dict(