def __next__(self): """ Return the next error node """ for child in self.children: yield child next(self.parent)
def iterunique(source, key): # assume source is sorted # first need to sort the data it = iter(source) hdr = next(it) yield tuple(hdr) # convert field selection into field indices if key is None: indices = range(len(hdr)) else: indices = asindices(hdr, key) # now use field indices to construct a _getkey function # N.B., this may raise an exception on short rows, depending on # the field selection getkey = operator.itemgetter(*indices) prev = next(it) prev_key = getkey(prev) prev_comp_ne = True for curr in it: curr_key = getkey(curr) curr_comp_ne = curr_key != prev_key if prev_comp_ne and curr_comp_ne: yield tuple(prev) prev = curr prev_key = curr_key prev_comp_ne = curr_comp_ne # last one? if prev_comp_ne: yield prev
def _sparql_query_pattern_part( self, bind=None, values=None, indent=' ', ): assert bind is None or isinstance(bind, dict) assert values is None or ( isinstance(values, dict) and isinstance(next(six.iterkeys(values)), Iterable) and isinstance(next(six.itervalues(values)), Iterable) ) res = '' if values: res = indent + self._sparql_values_part(values, indent) + '\n' res += indent + self._sparql_triples_part(indent) + '\n' if bind: res += '%sFILTER(\n%s\n%s)\n' % ( indent, ' &&\n'.join([ '%s %s=%s' % (indent, k.n3(), self.curify(v)) for k, v in sorted(bind.items()) if k in self.vars_in_graph ]), indent, ) return res
def read_tss_anno(anno, gene_filter): positions = {} g_filter = [] c = 0 if gene_filter: with open(gene_filter) as f: for line in f: line = line.rstrip() word = line.split("\t") g_filter.append(word[0]) with open(anno) as f: next(f) for line in f: line = line.rstrip() word = line.split("\t") if word[1] == "MT": chrom = "chrM" elif word[1] == "X": chrom = "chrX" elif word[1] == "Y": chrom = "chrY" elif word[1].isdigit(): chrom = "chr" + word[1] if word[4] == "1": strand = "+" else: strand = "-" if g_filter: if word[0] in g_filter: positions[word[0]] = (chrom, int(word[2]), strand) c += 1 else: positions[word[0]] = (chrom, int(word[2]), strand) c += 1 return positions
def window(iter, pre_size=1, post_size=1): """ Given an iterable, return a new iterable which yields triples of (pre, item, post), where pre and post are the items preceeding and following the item (or None if no such item is appropriate). pre and post will always be pre_size and post_size in length. >>> example = window(range(10), pre_size=2) >>> pre, item, post = next(example) >>> pre (None, None) >>> post (1,) >>> next(example) ((None, 0), 1, (2,)) >>> list(example)[-1] ((7, 8), 9, (None,)) """ pre_iter, iter = itertools.tee(iter) pre_iter = itertools.chain((None,) * pre_size, pre_iter) pre_iter = nwise(pre_iter, pre_size) post_iter, iter = itertools.tee(iter) post_iter = itertools.chain(post_iter, (None,) * post_size) post_iter = nwise(post_iter, post_size) next(post_iter, None) return six.moves.zip(pre_iter, iter, post_iter)
def test_pqueue_by_servicebus_client_iter_messages_simple(live_servicebus_config, partitioned_queue): client = ServiceBusClient( service_namespace=live_servicebus_config['hostname'], shared_access_key_name=live_servicebus_config['key_name'], shared_access_key_value=live_servicebus_config['access_key'], debug=True) queue_client = client.get_queue(partitioned_queue) with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver: with queue_client.get_sender() as sender: for i in range(10): message = Message("Iter message no. {}".format(i)) sender.send(message) count = 0 for message in receiver: print_message(message) message.complete() with pytest.raises(MessageAlreadySettled): message.complete() with pytest.raises(MessageAlreadySettled): message.renew_lock() count += 1 with pytest.raises(InvalidHandlerState): next(receiver) assert count == 10
def test_post_process_extensions_generator_response(self): class Controller(object): def index(self, req, pants=None): return pants controller = Controller() resource = wsgi.Resource(controller) called = [] def extension1(req): yield called.append(1) def extension2(req): yield called.append(2) yield 'foo' ext1 = extension1(None) next(ext1) ext2 = extension2(None) next(ext2) response = resource.post_process_extensions([ext2, ext1], None, None, {}) self.assertEqual(called, [2]) self.assertEqual(response, 'foo')
def select_map(self, latitude, longitude): """ Find and display a nearby track by latitude / longitude The selection will favor a previously selected track in the nearby area :param latitude :type latitude float :param longitude :type longitude float :returns the selected track, or None if there are no nearby tracks :type Track """ if not latitude or not longitude: return None point = GeoPoint.fromPoint(latitude, longitude) nearby_tracks = self.track_manager.find_nearby_tracks(point) saved_tracks = self.get_pref_track_selections() saved_nearby_tracks = [t for t in nearby_tracks if t.track_id in saved_tracks] # select the saved nearby track or just a nearby track track = next(iter(saved_nearby_tracks), None) track = next(iter(nearby_tracks), None) if track is None else track if self.track != track: # only update the trackmap if it's changing self._select_track(track) return track
def readFile(self): file = "/Users/molgenis/Documents/graduation_project/mendelianViolationFiles/mendelian_violation_allDiploid_Xadjusted.txt" mother_DP = [] father_DP = [] child_DP = [] transmissionProbability = [] with open(file) as f: next(f) for line in f: if line != "": columns = line.split('\t') mother_DP.append(columns[6]) father_DP.append(columns[10]) child_DP.append(columns[14]) transmissionProbability.append(columns[4]) else: next(line) self.countThresholdMother(mother_DP) self.countThresholdFather(father_DP) self.countThresholdChild(child_DP) self.countTP(transmissionProbability)
def unmunch_all(self): self.parse_aff() with codecs.open(self.dic_path, "r", "utf-8") as fp: next(fp) # Skip first line. for line in fp: line = line.split(u" ")[0] self.apply_suffix(u"", line)
def getContents(self, group): if not self._checkFsEndpointPath(): return logger.debug("Scanning for posts (shallow) in: %s" % self.fs_endpoint_path) year_pattern = ShallowPostsSource.YEAR_PATTERN file_pattern = ShallowPostsSource.FILE_PATTERN _, year_dirs, __ = next(osutil.walk(self.fs_endpoint_path)) year_dirs = [d for d in year_dirs if year_pattern.match(d)] for yd in year_dirs: if year_pattern.match(yd) is None: logger.warning( "'%s' is not formatted as 'YYYY' and will be ignored. " "Is that a typo?") continue year = int(yd) year_dir = os.path.join(self.fs_endpoint_path, yd) _, __, filenames = next(osutil.walk(year_dir)) for f in filenames: match = file_pattern.match(f) if match is None: name, ext = os.path.splitext(f) logger.warning( "'%s' is not formatted as 'MM-DD_slug-title.%s' " "and will be ignored. Is that a typo?" % (f, ext)) continue yield self._makeContentItem( os.path.join(yd, f), match.group(3), year, int(match.group(1)), int(match.group(2)))
def get_apreture_dic(): ffline = ff.FortranRecordReader('(3X,a16,3I4,F17.4,F17.10,2F12.3,I4,2x,a16)') dic = {} with open(MIX_FILE) as f: for _ in range(31): next(f) # for i in range(LAST_RING_ELEMENT): while True: try: line = f.readline() if not line: break hh = ffline.read(line) device_type = int(hh[2]) if device_type == 2: # this is a drift space, ignore it continue # name = 'DRIFT' else: name = hh[0].strip() aperture = hh[6] if name not in dic: dic.update({name: aperture}) # print('{},\t{},\t,{}\n'.format(name, device_type, aperture)) # if aperture == 0: # print(name) except: pass return dic
def load_transactions_mock(input_file, **kwargs): """ Mock for apyori.load_transactions. """ eq_(kwargs['delimiter'], delimiter) eq_(next(input_file), inputs[0]) yield iter(input_transactions[0]) eq_(next(input_file), inputs[1]) yield iter(input_transactions[1])
async def async_step_import(self, user_input): """Import a config entry.""" if self.hass.config_entries.async_entries(DOMAIN): return self.async_abort(reason='already_setup') self._scan_interval = user_input[KEY_SCAN_INTERVAL] if user_input[CONF_HOST] != DOMAIN: self._hosts.append(user_input[CONF_HOST]) if not await self.hass.async_add_executor_job( os.path.isfile, self.hass.config.path(TELLDUS_CONFIG_FILE)): return await self.async_step_user() conf = await self.hass.async_add_executor_job( load_json, self.hass.config.path(TELLDUS_CONFIG_FILE)) host = next(iter(conf)) if user_input[CONF_HOST] != host: return await self.async_step_user() host = CLOUD_NAME if host == 'tellduslive' else host return self.async_create_entry( title=host, data={ CONF_HOST: host, KEY_SCAN_INTERVAL: self._scan_interval.seconds, KEY_SESSION: next(iter(conf.values())), })
def sepLine2List(file2sep, sep="-"): """ :param file: default:combine """ try: fhIn = open(file2sep,'r') all = set() for line in fhIn: if line == '': next() line = line.replace(sep,'\n').rstrip() line = line.split('\n') for i in line: all.add(i) fhIn.close() fhOut = open(file2sep+'_sep','w') for i in all: fhOut.write(i+'\n') fhOut.close() print("Entry number left: %s" % len(all)) except: print "error in sepLine2List" return False
def test_pubsub(self): check_pubsub = self.redis.pubsub() check_pubsub.psubscribe("gottwall:*") next(check_pubsub.listen()) cli = RedisClient( private_key=private_key, public_key=public_key, project=project, host=HOST) ts = datetime.utcnow() self.assertEquals("gottwall:{0}:{1}:{2}".format(project, public_key, private_key), cli.channel) cli.incr(name="orders", value=2, timestamp=ts, filters={"current_status": "Completed"}) message = next(check_pubsub.listen()) self.assertEquals(message['channel'], 'gottwall:{0}:{1}:{2}'.format(project, public_key, private_key)) notification_message = json.loads(message['data']) self.assertEquals(notification_message['type'], 'notification') data_dict = json.loads(self.redis.spop(cli.data_key)) self.assertTrue(data_dict['name'], 'orders') self.assertTrue(data_dict['timestamp'], ts.strftime("%Y-%m-%dT%H:%M:%S")) self.assertTrue(data_dict['filters']['current_status'], 'Completed') self.assertEquals(self.redis.scard(cli.data_key), 0)
def __memory_info(self): # Get all memory info and get details with 20 depth size_obj = asizeof.asized(self._node, detail=20) whole_size = size_obj.size size_obj = next(r for r in size_obj.refs if r.name == '__dict__') size_dict = dict() # Sort in descending order to select most 'heavy' collections for num, sub_obj in enumerate(sorted(size_obj.refs, key=lambda v: v.size, reverse=True)): if num > 5: break size_dict[sub_obj.name] = dict() size_dict[sub_obj.name]['size'] = sub_obj.size # Check if this object (which include __dict__ and __class__) or iterable (dict, list, etc ..) if len(sub_obj.refs) <= 2 and any(r.name == '__dict__' for r in sub_obj.refs): sub_obj_ref = next(r for r in sub_obj.refs if r.name == '__dict__') else: sub_obj_ref = sub_obj for num, sub_sub_obj in enumerate(sorted(sub_obj_ref.refs, key=lambda v: v.size, reverse=True)): if num > 5: break size_dict[sub_obj.name][sub_sub_obj.name] = sub_sub_obj.size result_dict = {"whole_node_size": whole_size} result_dict.update(size_dict) return { 'Memory': result_dict }
def get_fluence(e_0=100.0): """ Returns a function representing the electron fluence with the distance in CSDA units. Args: e_0 (float): The kinetic energy whose CSDA range is used to scale the distances. Returns: A function representing fluence(x,u) with x in CSDA units. """ # List of available energies e0_str_list = list(map(lambda x: (os.path.split(x)[1]).split(".csv")[ 0], glob(os.path.join(data_path, "fluence", "*.csv")))) e0_list = sorted(list(map(int, list(filter(str.isdigit, e0_str_list))))) e_closest = min(e0_list, key=lambda x: abs(x - e_0)) with open(os.path.join(data_path, "fluence/grid.csv"), 'r') as csvfile: r = csv.reader(csvfile, delimiter=' ', quotechar='|', quoting=csv.QUOTE_MINIMAL) t = next(r) x = np.array([float(a) for a in t[0].split(",")]) t = next(r) u = np.array([float(a) for a in t[0].split(",")]) t = [] with open(os.path.join(data_path, "fluence", "".join([str(e_closest), ".csv"])), 'r') as csvfile: r = csv.reader(csvfile, delimiter=' ', quotechar='|', quoting=csv.QUOTE_MINIMAL) for row in r: t.append([float(a) for a in row[0].split(",")]) t = np.array(t) f = interpolate.RectBivariateSpline(x, u, t, kx=1, ky=1) # Note f is returning numpy 1x1 arrays return f
def _remove_sig(signature): """ Remove the signature node from payload keeping any tail element. This is needed for eneveloped signatures. :param payload: Payload to remove signature from :type data: XML ElementTree Element :param signature: Signature to remove from payload :type digest_algorithm: XML ElementTree Element """ try: signaturep = next(signature.iterancestors()) except StopIteration: raise ValueError("Can't remove the root signature node") if signature.tail is not None: try: signatures = next(signature.itersiblings(preceding=True)) except StopIteration: if signaturep.text is not None: signaturep.text = signaturep.text + signature.tail else: signaturep.text = signature.tail else: if signatures.tail is not None: signatures.tail = signatures.tail + signature.tail else: signatures.tail = signature.tail signaturep.remove(signature)
def get_cs(e_0=100, z=74): """ Returns a function representing the scaled bremsstrahlung cross_section. Args: e_0 (float): The electron kinetic energy, used to scale u=e_e/e_0. z (int): Atomic number of the material. Returns: A function representing cross_section(e_g,u) in mb/keV, with e_g in keV. """ # NOTE: Data is given for E0>1keV. CS values below this level should be used with caution. # The default behaviour is to keep it constant with open(os.path.join(data_path, "cs/grid.csv"), 'r') as csvfile: r = csv.reader(csvfile, delimiter=' ', quotechar='|', quoting=csv.QUOTE_MINIMAL) t = next(r) e_e = np.array([float(a) for a in t[0].split(",")]) log_e_e = np.log10(e_e) t = next(r) k = np.array([float(a) for a in t[0].split(",")]) t = [] with open(os.path.join(data_path, "cs/%d.csv" % z), 'r') as csvfile: r = csv.reader(csvfile, delimiter=' ', quotechar='|', quoting=csv.QUOTE_MINIMAL) for row in r: t.append([float(a) for a in row[0].split(",")]) t = np.array(t) scaled = interpolate.RectBivariateSpline(log_e_e, k, t, kx=3, ky=1) m_electron = 511 z2 = z * z return lambda e_g, u: (u * e_0 + m_electron) ** 2 * z2 / (u * e_0 * e_g * (u * e_0 + 2 * m_electron)) * ( scaled(np.log10(u * e_0), e_g / (u * e_0)))
def test_select_best_intent_with_domain(self): """Test to make sure that best intent is working with domains.""" self.engine.register_domain('Domain1') self.engine.register_domain('Domain2') # Creating first intent domain parser1 = IntentBuilder("Parser1").require("Entity1").build() self.engine.register_intent_parser(parser1, domain='Domain1') self.engine.register_entity("tree", "Entity1", domain='Domain1') # Creating second intent domain parser2 = IntentBuilder("Parser1").require("Entity2").build() self.engine.register_intent_parser(parser2, domain="Domain2") self.engine.register_entity("house", "Entity2", domain="Domain2") utterance = "Entity1 Entity2 go to the tree house" intents = self.engine.determine_intent(utterance, 2) intent = next(intents) assert intent self.assertEqual(intent['intent_type'], 'Parser1') intent = next(intents) assert intent self.assertEqual(intent['intent_type'], 'Parser1')
def load_athletes(filename): assert(type(filename) == str and len(filename) > 0) athletes = [] with open(filename) as csvfile: athlete_data = csv.reader(csvfile) next(csvfile, None) for row in athlete_data: if row[2] and row[3] and row[4]: row[12] = [row[12], row[13].split(', ')] del row[-1] athletes.append(row) """ Loads athlete data from 'filename' into a list of tuples. Returns a list of tuples of each athlete's attributes, where the last element of each tuple is a list of events the athlete competed in. Hint: Use the csv module to read quoted fields correctly. 1. The header line is skipped 2. Rows are removed if missing a value for the age, height, or weight. 3. All trailing events are placed in a list in position EVENTS_COL For example: [..., ['Zhaoxu Zhang', "People's Republic of China", '24', '221', '110', 'M', '11/18/1987', '', '0', '0', '0', '0', ['Basketball', "Men's Basketball"]], ... ] """ return athletes
def autoscale_rule_create(cmd, client, autoscale_name, resource_group_name, condition, scale, profile_name=DEFAULT_PROFILE_NAME, cooldown=5, source=None, timegrain="avg 1m"): from azure.mgmt.monitor.models import ScaleRule, ScaleAction, ScaleDirection autoscale_settings = client.get(resource_group_name, autoscale_name) profile = next(x for x in autoscale_settings.profiles if x.name == profile_name) condition.metric_resource_uri = source or autoscale_settings.target_resource_uri condition.statistic = timegrain.statistic condition.time_grain = timegrain.time_grain rule = ScaleRule( metric_trigger=condition, scale_action=ScaleAction( direction=scale.direction, type=scale.type, cooldown='PT{}M'.format(cooldown), value=scale.value) ) profile.rules.append(rule) autoscale_settings = client.create_or_update(resource_group_name, autoscale_name, autoscale_settings) profile = next(x for x in autoscale_settings.profiles if x.name == profile_name) # determine if there are unbalanced rules scale_out_rule_count = len([x for x in profile.rules if x.scale_action.direction == ScaleDirection.increase]) scale_in_rule_count = len([x for x in profile.rules if x.scale_action.direction == ScaleDirection.decrease]) if scale_out_rule_count and not scale_in_rule_count: logger.warning("Profile '%s' has rules to scale out but none to scale in. " "Recommend creating at least 1 scale in rule.", profile_name) elif scale_in_rule_count and not scale_out_rule_count: logger.warning("Profile '%s' has rules to scale in but none to scale out. " "Recommend creating at least 1 scale out rule.", profile_name) return rule
def get_cols(self, lines): """Initialize the header Column objects from the table ``lines``. Based on the previously set Header attributes find or create the column names. Sets ``self.cols`` with the list of Columns. This list only includes the actual requested columns after filtering by the include_names and exclude_names attributes. See ``self.names`` for the full list. :param lines: list of table lines :returns: None """ start_line = _get_line_index(self.start_line, self.process_lines(lines)) if start_line is None: # No header line so auto-generate names from n_data_cols if self.names is None: # Get the data values from the first line of table data to determine n_data_cols try: first_data_vals = next(self.data.get_str_vals()) except StopIteration: raise InconsistentTableError('No data lines found so cannot autogenerate column names') n_data_cols = len(first_data_vals) self.names = [self.auto_format % i for i in range(1, n_data_cols+1)] elif self.names is None: # No column names supplied so read them from header line in table. for i, line in enumerate(self.process_lines(lines)): if i == start_line: break else: # No header line matching raise ValueError('No header line found in table') self.names = next(self.splitter([line])) self._set_cols_from_names()
def is_fastq( fqpath ): try: next( SeqIO.parse( fqpath, 'fastq' ) ) return True except: print "{} is not a fastq file".format(fqpath) return False
def decode_item(next, token): if token == b'i': # integer: "i" value "e" data = int(next()) if next() != b'e': raise ValueError elif token == b's': # string: "s" value (virtual tokens) data = next() # Strings in torrent file are defined as utf-8 encoded try: data = data.decode('utf-8') except UnicodeDecodeError: # The pieces field is a byte string, and should be left as such. pass elif token == b'l' or token == b'd': # container: "l" (or "d") values "e" data = [] tok = next() while tok != b'e': data.append(decode_item(next, tok)) tok = next() if token == b'd': data = dict(list(zip(data[0::2], data[1::2]))) else: raise ValueError return data
def test_bison_lalr_repr_automaton_lr0(): ex = grammar_examples.lr0.ex_minimal1 grammar = ex.grammar automaton = compute_automaton(grammar) assert repr(automaton) == '<Automaton with 4 states>' assert repr(automaton._data) == ''' [<StateData #0 with 1 actions, 1 gotos <bison.ItemSet #0, size 2 < $accept → • Root $eof ∥ > < Root → • term ∥ > >>, <StateData #1 with 1 actions, 0 gotos <bison.ItemSet #1, size 1 < Root → term • ∥ { $eof } > >>, <StateData #2 with 1 actions, 0 gotos <bison.ItemSet #2, size 1 < $accept → Root • $eof ∥ > >>, <StateData #3 with 2 actions, 0 gotos <bison.ItemSet #3, size 1 < $accept → Root $eof • ∥ > >>] '''.strip().replace('•', _mdot).replace('∥', _parallel) assert repr(automaton._data[0]._id) == ''' <StateId for <StateData #0 with 1 actions, 1 gotos <bison.ItemSet #0, size 2 < $accept → • Root $eof ∥ > < Root → • term ∥ > >>> '''.strip().replace('•', _mdot).replace('∥', _parallel) assert repr(next(iter(automaton._data[0]._actions.values()))) == 'Shift(<state 1>)' assert repr(next(iter(automaton._data[1]._actions.values()))) == 'Reduce(<rule 1>)' assert repr(next(iter(automaton._data[0]._gotos.values()))) == 'Goto(<state 2>)'
def run(self, infile, label, outfile, existing=None): existing_rows = {} if existing: with open(existing, 'rU') as csvfile: reader = csv.reader(csvfile) existing_rows = dict([(x[0], x[1:]) for x in reader]) with open(infile, 'rU') as csvfile: reader = csv.reader(csvfile) # Ignore the header next(reader) for file_name, true_val, pred_val in reader: if existing and file_name not in existing_rows: raise Exception( "The file name ({0}) doesn't exist in the existing file.".format(file_name)) if not existing: existing_rows[file_name] = ['', ''] existing_rows[file_name] = ( _combine_values(existing_rows[file_name][0], true_val, label), _combine_values(existing_rows[file_name][1], pred_val, label) ) with open(outfile, 'w') as csvfile: writer = csv.writer(csvfile) writer.writerow(['file_name', 'true', 'predicted']) for k, v in existing_rows.items(): writer.writerow((k, *v))
def test_stratified_kfold_no_shuffle(): # Manually check that StratifiedKFold preserves the data ordering as much # as possible on toy datasets in order to avoid hiding sample dependencies # when possible X, y = np.ones(4), [1, 1, 0, 0] splits = StratifiedKFold(2).split(X, y) train, test = next(splits) assert_array_equal(test, [0, 2]) assert_array_equal(train, [1, 3]) train, test = next(splits) assert_array_equal(test, [1, 3]) assert_array_equal(train, [0, 2]) X, y = np.ones(7), [1, 1, 1, 0, 0, 0, 0] splits = StratifiedKFold(2).split(X, y) train, test = next(splits) assert_array_equal(test, [0, 1, 3, 4]) assert_array_equal(train, [2, 5, 6]) train, test = next(splits) assert_array_equal(test, [2, 5, 6]) assert_array_equal(train, [0, 1, 3, 4]) # Check if get_n_splits returns the number of folds assert_equal(5, StratifiedKFold(5).get_n_splits(X, y))
def get_single_if_any(iterable, exception_on_multiple=Exception('More than one value ' 'not allowed.')): ''' Get the single item of `iterable`, if any. If `iterable` has one item, return it. If it's empty, get `None`. If it has more than one item, raise an exception. (Unless `exception_on_multiple=None`.) ''' assert isinstance(exception_on_multiple, Exception) or \ exception_on_multiple is None iterator = iter(iterable) try: first_item = next(iterator) except StopIteration: return None else: if exception_on_multiple: try: second_item = next(iterator) except StopIteration: return first_item else: raise exception_on_multiple else: # not exception_on_multiple return first_item