def GetActivities(self, account, start, end): response = self.session.post( 'https://ssl.grsaccess.com/english/member/activity_reports_details.aspx', data={ 'MbrPlanId': account.account_id, 'txtEffStartDate': start.format('%m/%d/%Y'), 'txtEffEndDate': end.format('%m/%d/%Y'), 'Submit': 'Submit' }) response.raise_for_status() """ Activities are returned in an html table, with the first few rows being headers. Example activity row: <TR> <TD class='activities-d-lit1'>01-FEB-17</TD> <TD class='activities-d-lit2'>New contribution</TD> <TD class='activities-d-transamt'>123.45</TD> <TD class='activities-d-netunitvalamt'>22.123456</TD> <TD class='activities-d-unitnum'>5.58005</TD> </TR> """ soup = BeautifulSoup(response.text, 'html.parser') tags = soup.find_all(class_=re.compile('activities-d-*')) if not tags: return [] for activity_list in split_before( tags, lambda tag: tag.attrs['class'][0] == tags[0].attrs[ 'class'][0]): yield [a.text for a in activity_list]
def lines_to_programs(lines: List[str]) -> List[Tuple[str, List[dict]]]: """ Programs will be represented as two-part tuples. The first part is the mask, a string. The second part is a list of registers and values, represented by a dict with the keys "r" and "v". """ return lmap(parse_group, split_before(lines, lambda s: s[:4] == "mask"))
def get_sp1_history(self): """ This function gets the history of speaker 1 (chatbot) from the relevant input_ids, by padding the history of speaker2. :return: history of speaker 1 """ inp = self.input_ids sp1, sp2, pad = self.tokenizer.convert_tokens_to_ids( ['<speaker1>', '<speaker2>', '<pad>']) flatten = lambda l: [item for sublist in l for item in sublist] # get history of speaker1 (so pad all history of speaker2) hist1 = torch.zeros(inp.size(), device='cuda', dtype=torch.long) # for each training example in batch, get sp1 history for index, example in enumerate(inp): splitted = list( split_before(example.cpu().numpy(), lambda x: x == sp1 or x == sp2)) for i, z in enumerate(splitted): # replace sp1 tag with pad tag z = [x if x != sp1 else pad for x in z] splitted[i] = z # if sp2 or last sp1, replace with pad if sp2 in z or i == len(splitted) - 1: splitted[i] = [pad] * len(z) hist1[index] = torch.tensor(flatten(splitted), dtype=torch.long) # also return sp1_ids in last sentence of each batch idxs = [] for example in hist1: idxs.append((example != pad).nonzero().view(-1)) return hist1.view(inp.size()), idxs
def get_one_neighbor(filename): with open(filename) as f: neighbors = split_before(f, lambda x: "Device ID" in x) next(neighbors) # избавляемся от текста до соседей for lines in neighbors: neighbor = "".join(lines) yield neighbor
def process_file(f): fileobj = open(f, 'r') content = fileobj.read().split() fileobj.close() for pieces in more_itertools.split_before( content, lambda x: not x.startswith('##')): insert_pieces(pieces)
def headlined_sections(string, headline_pattern): """ return sections with headlines matching a pattern """ lines = string.splitlines() join_lines = '\n'.join pattern_matcher = apf.matcher(headline_pattern) lines = mit.lstrip(lines, pred=lambda line: not pattern_matcher(line)) sections = list(map(join_lines, mit.split_before(lines, pattern_matcher))) return sections
def sections_with_headline(pattern, string): """ return sections with headlines matching a pattern """ lines = string.splitlines() join_lines = '\n'.join pattern_matcher = matcher(pattern) lines = lstrip(lines, pred=lambda line: not pattern_matcher(line)) sections = list(map(join_lines, split_before(lines, pattern_matcher))) return sections
def _get_stanzas(self, config_text: str): whitespace_comment = " #\n" lines = [ line.strip(whitespace_comment) for line in config_text.split("\n") if line.strip(whitespace_comment) ] stanzas = list( split_before(lines, lambda line: line.lower().startswith("host "))) print(f"Stanzas: {stanzas}") return stanzas
def toc_tree(self): toc = self.fitz_doc._ebook.get_toc(simple=False) sect_count = len(toc) root = Section( title=self.metadata.title, pager=Pager(first=0, last=sect_count - 1), level=1, ) stack = TreeStackBuilder(root) all_html_files = self.get_html_file_list() for (idx, (level, title, __, data)) in enumerate(toc): href = data["name"] section = stack.push( Section( title=title, pager=Pager(first=idx, last=idx), level=level + 1, data=dict(href=href), )) # ---------------- filename, html_id = (href, None) if "#" not in href else href.split("#") self._filename_to_section[filename] = section # ---------------- if html_id is not None: self._split_section_anchor_ids.setdefault(filename, []).append(html_id) # ---------------- section_filename = (href if "#" not in href else href.split("#")[0]).strip() if section_filename not in all_html_files: continue all_html_files[all_html_files.index(section_filename)] = section # End loop additional_html_files = ((sect, html_files) for ( sect, *html_files) in more_itertools.split_before( all_html_files, pred=lambda item: isinstance(item, Section)) if html_files and isinstance(sect, Section)) for (sect, additional_html_file_list) in additional_html_files: sect.data["additional_html_files"] = additional_html_file_list for aditional_file in additional_html_file_list: self._filename_to_section[aditional_file] = sect # ------------ if sect_count == 0: href = (it(self.epub.items).find( lambda item: "html" in item.media_type).file_name) stack.push( Section( title=_("Book contents"), pager=Pager(first=0, last=0), level=2, data=dict(href=href), )) object.__setattr__(root.pager, "last", 0) return root
def create_subCells(self): '''This function splits all of the cell data into subcell objects to do this I find the length of the list before a fission even occurs I then take the length of the list till a fission event occurs and use it to slice the original data''' subcell_list = list(split_before(self.daughters, lambda x: x != 0)) subcell_list_lengths = [ len(length_subcell) for length_subcell in subcell_list ] all_subcells = [] current_position = 0 subcell_number_tracker = 1 #Here I slice the original cell data and put it into subcell objects for number_of_frames_in_subcell in subcell_list_lengths: end_position = current_position + number_of_frames_in_subcell subcell_framenbs = np.asarray( self.framenbs[current_position:end_position]) subcell_length = np.asarray( self.length[current_position:end_position]) subcell_width = np.asarray( self.width[current_position:end_position]) subcell_area = np.asarray(self.area[current_position:end_position]) subcell_fluorescence = np.asarray( self.fluorescence[current_position:end_position]) subcell_fluorescence_by_area = np.asarray( self.fluorescence_by_area[current_position:end_position]) subcell_length_growth = np.asarray( self.length_growth[current_position:end_position - 1]) subcell_width_growth = np.asarray( self.width_growth[current_position:end_position - 1]) subcell_area_growth = np.asarray( self.area_growth[current_position:end_position - 1]) subcell_fluorescence_growth = np.asarray( self.fluorescence_growth[current_position:end_position - 1]) subcell_fluorescence_growth_by_area = np.asarray( self. fluorescence_growth_by_area[current_position:end_position - 1]) current_subcell = SubCell( subcell_number_tracker, subcell_framenbs, subcell_length, subcell_width, subcell_area, subcell_fluorescence, subcell_fluorescence_by_area, subcell_length_growth, subcell_width_growth, subcell_area_growth, subcell_fluorescence_growth, subcell_fluorescence_growth_by_area) current_position = end_position all_subcells.append(current_subcell) subcell_number_tracker += 1 self.subcells = all_subcells return self.subcells
def get_movies_showtimes(theater, date): """Get movie names and times from Showtimes' website :theater: str :date: str (yyyy-mm-dd) (default: today) :returns: (list of movie names, list of lists of movie times) """ BASE_URL = 'https://www.showtimes.com/movie-theaters/{}' D_THEATERS = { 'regal fenway': lambda *args: 'regal-fenway-stadium-13-rpx-6269', 'ua court st': lambda *args: 'ua-court-street-stadium-12-rpx-6608' } try: soup = soup_me( BASE_URL.format( D_THEATERS.get(theater.lower(), get_theaterpg_showtimes)( theater))) # fallback for unlisted theater # (phrased as functions, so theaterpg scraper won't run until necessary) movies = soup('li', class_='movie-info-box') except (Exception) as e: print(error_str.format(e)) # error msg only movies = [] # no matching theater movie_names = [ ''.join((re.sub('[\r\n].*', '', name.text.strip()) for name in m('h2', class_='media-heading'))) for m in movies ] nested_buttons = [ # [[day, time, time, day, time], ..] -> [[[day, time, time], [day, time]], ..] list( split_before((button.text for button in m('button', type='button')), lambda txt: ',' in txt)) for m in movies ] movie_datetimes = [ flatten( [['{} @ {}'.format(day.replace(':', ''), time) for time in times] for day, *times in buttons if (convert_date(day.replace(':', '')) == date)]) for buttons in nested_buttons ] movie_times = filter_past(movie_datetimes) movie_names, movie_times = combine_times( *filter_movies(movie_names, movie_times)) return movie_names, movie_times
async def validator(): cache_data = validator_TTCache.get(VALIDATOR_CACHE_KEY) if cache_data: resp: ValidatorsResponse = cache_data else: async with lock: cache_data = validator_TTCache.get(VALIDATOR_CACHE_KEY) if cache_data: return cache_data else: latest_block_number_tasks = [] for validator in setting.validator_list: latest_block_number_tasks.append(get_latest_block(validator)) latest_infos = await asyncio.gather(*latest_block_number_tasks, return_exceptions=True) latest_infos_no_exception = list(filter(lambda x: x.block_number != NO_LATEST_BLOCK, latest_infos)) latest_num_dict: Dict[str, LatestInfo] = {i.validator.host: i for i in latest_infos} # get latest blocks from all the validators failed then randomly return the `nextToPropose` if len(latest_infos_no_exception) == 0: best = random.choice(setting.validator_list) max_block_numbers = NO_LATEST_BLOCK else: max_block_numbers = max([i.block_number for i in latest_infos_no_exception]) latest = first_true(latest_infos_no_exception, lambda x: x.block_number == max_block_numbers) index = one(locate(setting.validator_list, lambda x: x.pub_key == latest.sender)) # why +2 ? # actually index validator should be the latest proposed validator # but it is possible that at this moment, the next validator is already trying # to propose a new block. So choosing the +2 validator is more reliable best = nth(ncycles(setting.validator_list, 2), index + 2) split_validators = list(split_before(setting.validator_list, lambda x: x.host == best.host)) if len(split_validators) == 1: sorted_validators = one(split_validators) else: sorted_validators = last(split_validators) + first(split_validators) validators = list(map(lambda x: Validator(host=x.host, grpc_port=x.grpc_port, http_port=x.http_port, latestBlockNumber=latest_num_dict.get(x.host).block_number, timestamp=latest_num_dict.get(x.host).timestamp), sorted_validators)) nextToPropose = NextToPropose(host=best.host, grpcPort=best.grpc_port, httpPort=best.http_port, latestBlockNumber=max_block_numbers) resp = ValidatorsResponse(nextToPropose=nextToPropose, validators=validators) validator_TTCache[VALIDATOR_CACHE_KEY] = resp return resp.dict()
def headlined_sections(string, headline_pattern): """ Returns sections with headlines matching a pattern. :param string: string to return sections :type string: str :param headline_pattern: pattern to demarcate strings into sections :type headline_pattern: str :rtype: str """ lines = string.splitlines() join_lines = '\n'.join pattern_matcher = apf.matcher(headline_pattern) lines = mit.lstrip(lines, pred=lambda line: not pattern_matcher(line)) sections = list(map(join_lines, mit.split_before(lines, pattern_matcher))) return sections
def generate_joints_parts_idxs(self, num_channels, invis_aug=False, entire_body=False): len_joints = BodyPart(*(np.asarray(self._nr_joints_entire_body) * num_channels)) if entire_body \ else BodyPart(*(np.asarray(self._nr_joints) * num_channels)) if invis_aug: len_joints = BodyPart( *(list(len_joints[:-1]) + [len_joints[-1] - 1])) # remove visibility on velocity # BodyPartWithVelocity idxs for coordinates + (opt. visibility) body_parts = BodyPart(*more_itertools.split_before( range(sum(len_joints)), lambda i: i in list(itertools.accumulate(len_joints)))) return len_joints, body_parts
writer.writerow([pais]) writer.writerow(rows_title_list[1:]) # XPath de les dades de les taules:'//*[@id='iid')]/tbody//tr//td' xpath = '//*[@id="' + iid + '"]/tbody//tr//td' rows_data = driver.find_elements_by_xpath( xpath) # Obtenim les dades de les taules rows_data_list = [ ] # Inicialitzem la llista on aniran les dades de les taules # Afegim el text (les dades) a la llista: for rd in range(len(rows_data)): rows_data_list.append(rows_data[rd].text) by_rows_data = list( split_before(rows_data_list, lambda x: x == ' ')) # Tallem la llista per files (rows) # Escribim les rows al document csv: for row in by_rows_data: if len(row) != 1: writer.writerow(row[1:len(row)]) #Afegim una fila en blanc per a separar les taules: writer.writerow(' ') c += 1 # Obtenim el moment en el que hem extret les dades i l'afegim al final del dataset: data = datetime.now() ara = [data.strftime("%d/%m/%Y %H:%M:%S")] writer.writerow(ara)
def camel_to_phrase(name: str) -> str: """Convert camel/Pascal-case into a phrase with space-separated lowercase words.""" return " ".join("".join(w).lower() for w in mitt.split_before(name, str.isupper))
def token_ranges(seq): for t in more_itertools.split_before(enumerate(seq), lambda x: not x[1].startswith('#')): token = ''.join(map(lambda x: x[1], t)).replace('#', '') yield (token, t[0][0], t[-1][0])
def matchups_by_day_time(self): matchups_day_time = [ list(split_before(day, lambda x: ':' in x)) for day in self.games_times_by_day() ] return matchups_day_time
def parseTries(tries): t = list( mit.split_before(tries, lambda x: x.attrs['class'][1] == 'typography-slash')) return [typographyToInt(t[0]), typographyToInt(t[1])]
def parse_svg_path_commands(expr: str, initial = SVGPoint(0, 0)) -> Iterator[SVGPoint]: for name, *args in split_before(expr.split(" "), is_path_command): for point in parse_path_command(name, *args, initial=initial): yield (initial := point)
def shchain(s): chars = list(SH_BINARY_OPS_EDGEAWARE.keys()) chars.extend(SH_BINARY_OPS.keys()) chars.extend(SH_UNARY_SUFFIX_PROPS) chars.extend(SH_UNARY_SUFFIX_FUNCS) chars.append(">") chars.append("Ƨ") cs = ["".join(x) for x in split_before(s, lambda x: x in chars) if x[0] != ">"] out = cs[0] spre = re.compile(",|—") skip = False for c in cs[1:]: f = c[0] if f == "Ƨ": skip = True continue elif skip: skip = False continue if f in SH_BINARY_OPS: fn = SH_BINARY_OPS[f] d = None if c[1] in ["X", "Y"]: d = c[1] args = spre.split(c[2:]) else: args = spre.split(c[1:]) if d: fn += "_" + d.lower() for i, a in enumerate(args): if a == "auto" or a == "a": args[i] = '"auto"' out += f".{fn}({','.join(args)})" elif f in SH_BINARY_OPS_EDGEAWARE: fn = SH_BINARY_OPS_EDGEAWARE[f] d = "XY" if c[1] in ["X", "Y"]: d = c[1] args = spre.split(c[2:]) else: args = spre.split(c[1:]) for i, a in enumerate(args): if a[0] == "-": e = "mn" elif a[0] == "=": e = "md" elif a[0] == "+": e = "mx" else: raise Exception("Edge not matched", args[0]) if d == "XY": args[i] = (a[1:], '"'+e+"xy"[i]+'"') else: args[i] = (a[1:], '"'+e+d.lower()+'"') out += f".{fn}({','.join(args[i])})" elif f in SH_UNARY_SUFFIX_PROPS: fn = SH_UNARY_SUFFIX_PROPS[f] out += f".{fn}" #+ c[1:] elif f in SH_UNARY_SUFFIX_FUNCS: fn = SH_UNARY_SUFFIX_FUNCS[f] out += f".{fn}()" #+ c[1:] return out
def compute_parts(annotations): return [ part for part in more_itertools.split_before( enumerate(annotations), lambda x: x[1][1][0] == 'B') if part[0][1][1][0] == 'B' ]
def sh(s, ctx:SHContext=None, dps=None, subs={}): from drafting.pens.draftingpen import DraftingPen #print("SH>", s, subs) if ctx is None: ctx = SHContext() evaled = [] last_locals = {**ctx.locals} s = s.replace("_", "") s = "ƒ"+re.sub(r"[\s\n]+", "ƒ", s).strip() def expand_multisuffix(m): out = [] arrows = list(m.group(2)) for a in arrows: out.append(m.group(1)+a) return "ƒ".join(out) def do_eval(phrase): py = (shgroup(phrase)) if not py: return None for k, v in SH_PATH_OPS.items(): py = py.replace(k, '"' + v + '"') for k, v in ctx.lookups.items(): py = py.replace(v.symbol, f"ctx.{k}.") for k, v in ctx.subs.items(): py = py.replace(k, v(ctx) if callable(v) else v) for k, v in subs.items(): py = py.replace(k, str(v)) #print("EVAL<", py) try: res = eval(py, dict( ctx=ctx, _last=evaled[-1] if len(evaled) > 0 else None, _dps=dps, Point=Point, Line=Line, Rect=Rect, DraftingPen=DraftingPen) , last_locals) #print("LOCALS", last_locals) return res except SyntaxError as e: print("SYNTAX ERROR", e, phrase, py) return None #s = re.sub(r"([\$\&]{1}[a-z]+)([↖↑↗→↘↓↙←•⍺⍵µ]{2,})", expand_multisuffix, s) # for k, v in SH_PATH_OPS.items(): # s = s.replace(k, '"' + v + '"') join_to_path = False splits = ["ƒ"] splits.extend(SH_EXPLODES.keys()) s = re.sub("ƒ\-[^ƒ]+", "", s) for phrase in split_before(s, lambda x: x in splits): phrase = "".join(phrase).strip() #print("PHRASE", phrase) last = None if not phrase: continue if phrase[0] in SH_EXPLODES: phrase = "_last"+phrase[1:] # last = evaled[-1] if phrase[0] == "ƒ": phrase = phrase[1:] if not phrase: continue if phrase == "∫": phrase = "'∫'" more = [] if "ø" in phrase: phrase = phrase.replace("ø", "") elif "|" in phrase: tuple = phrase.split("|") for i, t in enumerate(tuple): if isinstance(t, str): if "∑" in t: t = ",".join([f"'{c}'" for c in t]) elif len(t) > 1: if t[0] in SH_UNARY_TO_STRING: tuple[i] = [SH_UNARY_TO_STRING[x] for x in t] continue else: if t in SH_UNARY_TO_STRING: tuple[i] = SH_UNARY_TO_STRING[t] continue tuple[i] = do_eval(t) more = tuple phrase = tuple[-1] if more: evaled.append(more) else: evaled.append(do_eval(phrase)) if dps is not None: dps.append(evaled[-1]) ctx.locals = {**ctx.locals, **last_locals} return evaled