def check(process_output, judge_output, split_on='lines', **kwargs): split_pattern = { 'lines': b'[\r\n]', 'whitespace': b'[\s]', }.get(split_on) if not split_pattern: raise InternalError('invalid `split_on` mode') process_lines = list( filter(None, resplit(split_pattern, utf8bytes(process_output)))) judge_lines = list( filter(None, resplit(split_pattern, utf8bytes(judge_output)))) if len(process_lines) != len(judge_lines): return False if split_on == 'lines': process_lines = list(map(six.binary_type.split, process_lines)) judge_lines = list(map(six.binary_type.split, judge_lines)) process_lines.sort() judge_lines.sort() for process_line, judge_line in zip(process_lines, judge_lines): if process_line != judge_line: return False return True
def check(process_output, judge_output, precision, **kwargs): process_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(process_output)))) judge_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(judge_output)))) if len(process_lines) != len(judge_lines): return False epsilon = 10**-int(precision) try: for process_line, judge_line in zip(process_lines, judge_lines): process_tokens = process_line.split() judge_tokens = judge_line.split() if len(process_tokens) != len(judge_tokens): return False for process_token, judge_token in zip(process_tokens, judge_tokens): try: judge_float = float(judge_token) except: if process_token != judge_token: return False else: process_float = float(process_token) # since process_float can be nan, this is NOT equivalent to (process_float - judge_float) > epsilon # the code below will always reject nan, even if judge_float is nan if not abs(process_float - judge_float) <= epsilon: return False except: return False return True
def check(process_output: bytes, judge_output: bytes, point_value: float, feedback: bool = True, match: Callable[[bytes, bytes], bool] = lambda p, j: p.strip() == j.strip(), **kwargs) -> Union[CheckerResult, bool]: process_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(process_output)))) judge_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(judge_output)))) if len(process_lines) > len(judge_lines): return False if not judge_lines: return True if isinstance(match, str): match = eval(match) cases = [verdict[0]] * len(judge_lines) count = 0 for i, (process_line, judge_line) in enumerate(zip(process_lines, judge_lines)): if match(process_line, judge_line): cases[i] = verdict[1] count += 1 return CheckerResult(count == len(judge_lines), point_value * (1.0 * count / len(judge_lines)), ''.join(cases) if feedback else "")
def check(process_output: bytes, judge_output: bytes, point_value: float = 1, point_distribution: List[int] = [1], filler_lines_required: bool = True, **kwargs) -> Union[CheckerResult, bool]: judge_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(judge_output)))) if len(judge_lines) != len(point_distribution): raise InternalError( 'point distribution length must equal to judge output length') if sum(point_distribution) == 0: raise InternalError('sum of point distribution must be positive') process_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(process_output)))) if filler_lines_required and len(process_lines) != len(judge_lines): return False points = 0 for process_line, judge_line, line_points in zip(process_lines, judge_lines, point_distribution): if process_line == judge_line: points += line_points return CheckerResult(points > 0, point_value * (points / sum(point_distribution)))
def check(process_output, judge_output, split_on='lines', **kwargs): split_pattern = { 'lines': b'[\r\n]', 'whitespace': b'[\s]', }.get(split_on) if not split_pattern: raise InternalError('invalid `split_on` mode') process_lines = list(filter(None, resplit(split_pattern, utf8bytes(process_output)))) judge_lines = list(filter(None, resplit(split_pattern, utf8bytes(judge_output)))) if len(process_lines) != len(judge_lines): return False if split_on == 'lines': process_lines = list(map(six.binary_type.split, process_lines)) judge_lines = list(map(six.binary_type.split, judge_lines)) process_lines.sort() judge_lines.sort() for process_line, judge_line in zip(process_lines, judge_lines): if process_line != judge_line: return False return True
def check(process_output: bytes, judge_output: bytes, point_value: float, feedback: bool = True, **kwargs) -> Union[CheckerResult, bool]: process_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(process_output)))) judge_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(judge_output)))) if len(process_lines) > len(judge_lines): return False if not judge_lines: return True cases = [verdict[0]] * len(judge_lines) count = 0 for i, (process_line, judge_line) in enumerate(zip(process_lines, judge_lines)): if process_line.strip() == judge_line.strip(): cases[i] = verdict[1] count += 1 return CheckerResult(count == len(judge_lines), point_value * count / len(judge_lines), extended_feedback='Case Feedback:\n' + ''.join(cases) if feedback else '')
def check(process_output, judge_output, precision=6, error_mode='default', **kwargs): # Discount empty lines process_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(process_output)))) judge_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(judge_output)))) if len(process_lines) != len(judge_lines): return False verify_float = { 'absolute': verify_absolute, 'relative': verify_relative, 'default': verify_default, }.get(error_mode) if not verify_float: raise InternalError('invalid `error_mode` value') epsilon = 10**-int(precision) try: for process_line, judge_line in zip(process_lines, judge_lines): process_tokens = process_line.split() judge_tokens = judge_line.split() if len(process_tokens) != len(judge_tokens): return False for process_token, judge_token in zip(process_tokens, judge_tokens): # Allow mixed tokens, for lines like "abc 0.68 def 0.70" try: judge_float = float(judge_token) except: # If it's not a float the token must match exactly if process_token != judge_token: return False else: process_float = float(process_token) if not verify_float(process_float, judge_float, epsilon): return False except: return False return True
def picRead(pics): temp = [] tempDict = dict() if isinstance(pics, list): for eachPic in pics: tempDict = dict() tempDict['pic'] = imreadCH(eachPic) tempDict['obj'] = resplit(r'[\\ /]', eachPic)[-1] temp.append(tempDict) return temp else: tempDict['pic'] = imreadCH(pics) tempDict['obj'] = resplit(r'[\\ /]', pics)[-1] return tempDict
def check(process_output, judge_output, **kwargs): process_lines = resplit(b'[\r\n]', utf8bytes(process_output)) judge_lines = resplit(b'[\r\n]', utf8bytes(judge_output)) if 'filter_new_line' in kwargs: process_lines = list(filter(None, process_lines)) judge_lines = list(filter(None, judge_lines)) if len(process_lines) != len(judge_lines): return False for process_line, judge_line in zip(process_lines, judge_lines): if process_line.rstrip() != judge_line.rstrip(): return False return True
def href_resolve(root, path, href): protocol_split = resplit("(\\:\\/\\/|\\:)", href, maxsplit=1) if len(protocol_split) > 1: return href if href.startswith("/"): return root+href return root+"/"+path+"/"+href
def _qual_subbuttons(task_id, qual, msg): buttons = button_build.ButtonMaker() task_info = listener_dict[task_id] formats_dict = task_info[6] qual_fps_ext = resplit(r'p|-', qual, maxsplit=2) height = qual_fps_ext[0] fps = qual_fps_ext[1] ext = qual_fps_ext[2] tbrs = [] for tbr in formats_dict[qual]: tbrs.append(tbr) tbrs.sort(reverse=True) for index, br in enumerate(tbrs): if index == 0: tbr = f">{br}" else: sbr = index - 1 tbr = f"<{tbrs[sbr]}" if fps != '': video_format = f"bv*[height={height}][fps={fps}][ext={ext}][tbr{tbr}]" else: video_format = f"bv*[height={height}][ext={ext}][tbr{tbr}]" size = formats_dict[qual][br] buttonName = f"{br}K ({get_readable_file_size(size)})" buttons.sbutton(str(buttonName), f"qu {task_id} {video_format}") buttons.sbutton("Back", f"qu {task_id} back") buttons.sbutton("Cancel", f"qu {task_id} cancel") SUBBUTTONS = InlineKeyboardMarkup(buttons.build_menu(2)) editMessage(f"Choose Video Bitrate for <b>{qual}</b>:", msg, SUBBUTTONS)
def configure(self): """Reload the configuration.""" self.configuration['cfgfile'] = self.cfgname try: with open(self.cfgname) as f: for l in f: line = l.strip() try: if line[0] == '#': continue k, v = resplit(' |\t', line, 1) self.configuration[k] = v.strip() except IndexError: continue # empty line try: self.logger.setLogfile(self.configuration['log_filename']) except KeyError: self.logger.setLogfile('./pcm.log') self.logger.log( 'Configuration reloaded for ' + self.configuration['name'] + '.', 1) return self.configuration except Exception as e: self.logger.log(' *** Configuration error! − ' + str(e) + ' ***', 4) return False
def matchImg(imgsrc, imgobj, confidencevalue=0.8, targetSize=(1440, 810)): #imgsrc=原始图像,imgobj=待查找的图片 '用于查找原始图片中的单一目标图片,如果原始图片中可找到多个目标图片,则随机返回一个匹配的结果,返回值为一个字典' try: if isinstance(imgsrc, str): imsrc = imreadCH(imgsrc) else: imsrc = imgsrc except RuntimeError: return None #imobj = imread(imgobj) if isinstance(imgobj, str): imobj = imreadCH(imgobj) else: imobj = imgobj['pic'] #现在此情况传入的一定是字典 if targetSize != (0, 0): imsrc = resize(imsrc, targetSize) match_result = find_template(imsrc, imobj, confidencevalue) #match_result = None if match_result != None: if isinstance(imgobj, str): match_result['obj'] = resplit(r'[\\ /]', imgobj)[-1] else: match_result['obj'] = imgobj['obj'] #delImg(imgsrc) return match_result
def check(process_output, judge_output, **kwargs): process_lines = resplit(b'[\r\n]', utf8bytes(process_output)) judge_lines = resplit(b'[\r\n]', utf8bytes(judge_output)) if kwargs.get('filter_new_line'): process_lines = list(filter(None, process_lines)) judge_lines = list(filter(None, judge_lines)) if len(process_lines) != len(judge_lines): return False for process_line, judge_line in zip(process_lines, judge_lines): if process_line.rstrip() != judge_line.rstrip(): return False return True
def wellBoreDataLineAnalysis(line): line = line.replace("\t"," ") #lineList = line.split(" ") lineList = resplit("=| ",line) lineList = [a for a in lineList if a != ""] #print (lineList) if ("Real" in lineList) and ("!" in lineList): pythonString = lineList[0]+" = "+lineList[2].split("!")[0] #print ("dbg wellbore int",pythonString) #print ("dbg wellbore lineList[0]",lineList[0]) #print ("dbg wellbore lineList[2]",lineList[2].split("!")[0]) #raw_input() return pythonString,lineList[0],lineList[2].split("!")[0], "Real",lineList[4].replace("\n","") elif "Real" in lineList: pythonString = lineList[0]+" = "+lineList[2] #print ("dbg wellbore int",pythonString) #print ("dbg wellbore lineList[0]",lineList[0]) #print ("dbg wellbore lineList[2]",lineList[2].split("!")[0]) return pythonString,lineList[0],lineList[2].split("!")[0], "Real","! Int. coef" elif "Int" in lineList and ("!" in lineList): #print(" line list int: ",lineList) pythonString = lineList[0]+" = "+lineList[2].split("!")[0] return pythonString,lineList[0],lineList[2].split("!")[0], "Int","".join(lineList[4:]).replace("\n","") elif "Int" in lineList: #print(" line list int: ",lineList) pythonString = lineList[0]+" = "+lineList[2].split("!")[0] return pythonString,lineList[0],lineList[2].split("!")[0], "Int","! Int. coef" elif "Logical" in lineList: return lineList[0], lineList[1], lineList[2] elif "Material" in lineList: return lineList[lineList.index('Material')+1].replace("\n","") elif "Variable" in lineList: pythonString = lineList[0]+" = "+lineList[2].split("!")[0] return pythonString,lineList[0],lineList[2].split("!")[0], "Variable",lineList[4].replace("\n","")
def _ids(self, box='INBOX', search='ALL', charset=None, byUid=False): """""" status, resp = self.cnx.select(box) if status == self.KO : self.createBox(box) self.cnx.select(box) status, resp = self.cnx.search(charset, '(%s)' % search) return resplit(' ',Io.str(resp[self.K_HEAD]))
def most_recent_configsets(self): """Issue HTTP Get Request to SolrCloud API to retrieve Recent ConfigSets.""" configs = defaultdict(set) for configset in self.get_configsets(): split = resplit(r'-(\d+)', configset) if len(split) > 1: config, version, *_ = split configs[config].add(int(version)) return [f"{configset}-{max(versions)}" for (configset, versions) in configs.items()]
def check(process_output, judge_output, **kwargs): process_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(process_output)))) judge_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(judge_output)))) if len(process_lines) != len(judge_lines): return False process_lines = list(map(six.binary_type.split, process_lines)) judge_lines = list(map(six.binary_type.split, judge_lines)) process_lines.sort() judge_lines.sort() for process_line, judge_line in zip(process_lines, judge_lines): if process_line != judge_line: return False return True
def check(process_output, judge_output, precision=6, error_mode='default', **kwargs): # Discount empty lines process_lines = list(filter(None, resplit(b'[\r\n]', utf8bytes(process_output)))) judge_lines = list(filter(None, resplit(b'[\r\n]', utf8bytes(judge_output)))) if len(process_lines) != len(judge_lines): return False verify_float = { 'absolute': verify_absolute, 'relative': verify_relative, 'default': verify_default, }.get(error_mode) if not verify_float: raise InternalError('invalid `error_mode` value') epsilon = 10 ** -int(precision) try: for process_line, judge_line in zip(process_lines, judge_lines): process_tokens = process_line.split() judge_tokens = judge_line.split() if len(process_tokens) != len(judge_tokens): return False for process_token, judge_token in zip(process_tokens, judge_tokens): # Allow mixed tokens, for lines like "abc 0.68 def 0.70" try: judge_float = float(judge_token) except: # If it's not a float the token must match exactly if process_token != judge_token: return False else: process_float = float(process_token) if not verify_float(process_float, judge_float, epsilon): return False except: return False return True
def check(process_output: bytes, judge_output: bytes, **kwargs) -> bool: process_lines = resplit(b'[\r\n]', utf8bytes(process_output)) judge_lines = resplit(b'[\r\n]', utf8bytes(judge_output)) #l'usuari fara una sola linea d'output, el nom del seu fitxer filename = process_lines[0].decode('utf-8') #fitxer esperat passat a caracters utf8 enjin = [x.decode('utf-8') for x in list(filter(None, judge_lines))] strexpected = '\n'.join(map(str, enjin)) print(strexpected) #rescato el nom del fitxer i l'obro myfile = open("/outputfiles/" + filename, "rb").read() file_lines = resplit(b'[\r\n]', utf8bytes(myfile)) #fitxer de l'usuari passat a caracters utf8 enjin = [x.decode('utf-8') for x in list(filter(None, file_lines))] data_to_read = '\n'.join(map(str, enjin)) print(data_to_read) #comparacio print(file_lines) print(judge_lines) #pots esborrar ja el fitxer i que no ocupi memòria (no hi ha risc de fitxer de 3GB, perque donaria MLE) os.remove("/outputfiles/" + filename) if len(file_lines) != len(judge_lines): #print("ep") return CheckerResult(False, 0, "Els fitxers no tenen les mateixes línees", strexpected + "\u2719" + data_to_read) for process_line, judge_line in zip(file_lines, judge_lines): if process_line.rstrip() != judge_line.rstrip(): #print("aaa",process_line.rstrip,judge_line.rstrip()) return CheckerResult(False, 0, "Els fitxers no son iguals", strexpected + "\u2719" + data_to_read) return True
def status(self, box='INBOX'): """""" status, resp = self.cnx.status(box, '(MESSAGES RECENT UIDNEXT UIDVALIDITY UNSEEN)') if status == self.OK : data = research(self.REG_SATUS, Io.str(resp[self.K_HEAD])) l = resplit(' ',data.group(2)) dic = {'BOX' : box} for i in range(len(l)): if i%2 == 0 : dic[l[i]] = int(l[i+1]) else : dic = {} return dic
def get_voter_id(href): _id = "" join = False for part in href.split("/"): part = resplit("(\\?|\\#)", part)[0] if not join: if part == "biografien": join = True continue _id += part+"/" return _id[:len(_id)-1]
def check(process_output, judge_output, precision, **kwargs): # Discount empty lines process_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(process_output)))) judge_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(judge_output)))) if len(process_lines) != len(judge_lines): return False epsilon = 10**-int(precision) try: for process_line, judge_line in zip(process_lines, judge_lines): process_tokens = process_line.split() judge_tokens = judge_line.split() if len(process_tokens) != len(judge_tokens): return False for process_token, judge_token in zip(process_tokens, judge_tokens): # Allow mixed tokens, for lines like "abc 0.68 def 0.70" try: judge_float = float(judge_token) except: # If it's not a float the token must match exactly if process_token != judge_token: return False else: process_float = float(process_token) # process_float can be nan # in this case, we reject nan as a possible answer, even if judge_float is nan if not abs(process_float - judge_float) <= epsilon and \ (not abs(judge_float) >= epsilon or not abs(1.0 - process_float / judge_float) <= epsilon): return False except: return False return True
def check(process_output, judge_output, precision, **kwargs): process_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(process_output)))) judge_lines = list( filter(None, resplit(b'[\r\n]', utf8bytes(judge_output)))) if len(process_lines) != len(judge_lines): return False epsilon = 10**-int(precision) try: for process_line, judge_line in zip(process_lines, judge_lines): process_tokens = process_line.split() judge_tokens = judge_line.split() if len(process_tokens) != len(judge_tokens): return False for process_token, judge_token in zip(process_tokens, judge_tokens): try: judge_float = float(judge_token) except: if process_token != judge_token: return False else: process_float = float(process_token) p1 = min(judge_float * (1 - epsilon), judge_float * (1 + epsilon)) p2 = max(judge_float * (1 - epsilon), judge_float * (1 + epsilon)) # since process_float can be nan, this is NOT equivalent to (process_float < p1 or process_float > p2) if not (p1 <= process_float <= p2): return False except: return False return True
def get_wiki_snippet(res): if res['query']['searchinfo']['totalhits'] > 0: # get title title = res['query']['search'][0]['title'] # make parser object parser = htmlParser() # feed snippet to htmlparser parser.feed(res['query']['search'][0]['snippet']) # get cleaned snippet and split by sentence text = resplit( r'(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)\s', parser.get_data()) return "Results for {}: \n{}".format(title, text[0]) else: return "No results found."
def select_format(update, context): query = update.callback_query user_id = query.from_user.id data = query.data msg = query.message data = data.split(" ") task_id = int(data[1]) try: task_info = listener_dict[task_id] except: return editMessage("This is old task", msg) uid = task_info[1] if user_id != uid: return query.answer(text="Don't waste your time!", show_alert=True) elif data[2] == "dict": query.answer() qual = data[3] return _qual_subbuttons(task_id, qual, msg) elif data[2] == "back": query.answer() return editMessage('Choose Video Quality:', msg, task_info[4]) elif data[2] == "audio": query.answer() if len(data) == 4: playlist = True else: playlist = False return _audio_subbuttons(task_id, msg, playlist) elif data[2] != "cancel": query.answer() listener = task_info[0] link = task_info[2] name = task_info[3] args = task_info[5] qual = data[2] if qual.startswith( 'bv*[' ): # To not exceed telegram button bytes limits. Temp solution. height = resplit(r'\[|\]', qual, maxsplit=2)[1] qual = qual + f"+ba/b[{height}]" if len(data) == 4: playlist = True else: playlist = False ydl = YoutubeDLHelper(listener) Thread(target=ydl.add_download, args=(link, f'{DOWNLOAD_DIR}{task_id}', name, qual, playlist, args)).start() del listener_dict[task_id] query.message.delete()
def getTaskList(self, taskName): task = self.run('tasklist') taskList = task.split('\n') taskAdb = [] for eachTask in taskList: if taskName in eachTask: taskAdb.append(eachTask) pidList = [] if taskAdb != []: for eachAdb in taskAdb: pid = resplit(r'\s+', eachAdb)[1] pidList.append(pid) return pidList
def check(process_output, judge_output, point_value, feedback=True, match=lambda p, j: p.strip() == j.strip(), **kwargs): process_lines = list(filter(None, resplit(b'[\r\n]', utf8bytes(process_output)))) judge_lines = list(filter(None, resplit(b'[\r\n]', utf8bytes(judge_output)))) if len(process_lines) > len(judge_lines): return False if not judge_lines: return True if isinstance(match, six.string_types): match = eval(match) cases = [verdict[0]] * len(judge_lines) count = 0 for i, (process_line, judge_line) in enumerate(zip(process_lines, judge_lines)): if match(process_line, judge_line): cases[i] = verdict[1] count += 1 return CheckerResult(count == len(judge_lines), point_value * (1.0 * count / len(judge_lines)), ''.join(cases) if feedback else "")
def parselines(lines, tol=TOL, projective=False, as_set=False): """ Keyword arguments: lines -- iterable of strings, first entry the number of points; the rest, "%s %s" % real, imag tol -- optional float, smallest allowable nonzero value """ from re import split as resplit from naglib.core.misc import dps lines = striplines(lines) points = [] numpoints = int(lines[0]) if numpoints == 0: return points lines = lines[1:] length = len(lines) numvar = length // numpoints for i in range(0, length, numvar): point = lines[i:i + numvar] point = [resplit(r'\s+', p) for p in point] newpoint = [] for p in point: real, imag = p if imag[-1] == ';': imag = imag[:-1] real = Float(real, dps(real)) imag = Float(imag, dps(imag)) if abs(real) < tol: real = 0 if abs(imag) < tol: imag = 0 newpoint.append(real + I * imag) if projective: points.append(ProjectivePoint(newpoint)) else: points.append(AffinePoint(newpoint)) if as_set: points = list(set(points)) return points
def shell(dps): with open(session.LOG_FILENAME) as file: for entry in file: entry = entry.rstrip() cmd = resplit(r'[^\\],', entry)[5] if cmd != "" and cmd != "What": # remove CSV line head dps.prompt_session.history.append_string(cmd.rstrip()) try: last_string = dps.prompt_session.prompt( auto_suggest=AutoSuggestFromHistory()) dps_cmd.hook(last_string, dpsrc, session, prompt_ui, dps) dps.update_prompt() except KeyboardInterrupt: #exit_gracefully() pass except EOFError: exit_gracefully()
def post(self, request, *args, **kwargs): form = self.form_class(data=request.POST) if not form.is_valid(): return render(request, self.template_name, {'form': form}) tag_titles = resplit(r'[, ]', form.cleaned_data['tags'.lower()]) new_quest = form.save(commit=False) new_quest.author_id = request.user.id new_quest.save() for title in tag_titles: try: tag = Tag.objects.get(title=title) except ObjectDoesNotExist: tag = Tag.objects.create(title=title) new_quest.tags.add(tag) return redirect('/question/id' + str(new_quest.pk))
def sanitizer_opts(env_data): """Parse the values defined in given *SAN_OPTIONS environment variable. For example "ASAN_OPTIONS=debug=false:log_path='/test/file.log'" would return {"debug": "false", "log_path": "'/test/file.log'"} Args: env_var (str): *SAN_OPTIONS environment variable to parse. Returns: dict: Sanitized values from environment. """ opts = dict() for opt in resplit(r":(?![\\|/])", env_data): if not opt: continue key, val = opt.split("=") opts[key] = val return opts
def get_domains(topology, signalp=[]): domains = [] for sp in signalp: if sp != "OTHER" and sp != '': domains.append({'c': 0, 'class': sp, 'shape': 'circle'}) if len(topology) > 1: tms = resplit('[io]', str(topology).strip()) for t in tms: if not t: continue start, end = t.split('-') domains.append({ 'start': start, 'end': end, 'class': 'helix', 'shape': 'rect' }) return domains
def main(): # Read the command line options parser = ArgumentParser( description='Highly configurable prompt decoration for ZSH and Bash.') parser.add_argument('-v', '--version', help='show version and exit', action='store_true') parser.add_argument('-r', '--right', help='build right hand side prompt', action='store_true') parser.add_argument('RC', nargs='?', help='return code of the executed command') args = parser.parse_args() if args.version: print("PBT v%s" % VERSION) exit(0) if version_info < (3, 0): import sys reload(sys) sys.setdefaultencoding('utf8') if args.right: cars_str = getenv('PBT_RCARS', "Time") else: cars_str = getenv('PBT_CARS', "Status, Os, Hostname, Dir, Git, Sign") cars_names = resplit(r'\s*,\s*', cars_str) cars = [] for car in cars_names: try: cars.append( getattr(import_module('pbt.cars.%s' % car), '%sCar' % car)()) except Exception: stderr.write("ERROR: Cannot import module %sCar.\n" % car) if getenv('PBT_DEBUG', False) in BOOL_TRUE: print_exc(file=stderr) print_train(cars, args.right)
def reconcile_samples(self, samples, samples_file, allow_all=False): if samples is None: samples = [] if hasattr(samples_file, "read"): keep_samples = [] for line in samples_file: if line.startswith("#"): continue else: iid = line.strip().split().pop(0) if not iid in self.samples: self.log.warning( "Sample '{}' in populations file but not in VCF; skpping it." .format(iid)) continue keep_samples.append(iid) self.log.info("Read {} samples from file <{}>".format( len(keep_samples), samples_file.name)) elif len(samples): keep_samples = [] for iid in samples: keep_samples.extend(resplit("[,;|]", iid)) self.log.info("Read {} samples from command line".format( len(keep_samples))) else: if not allow_all: self.log.error("Must specify at least one focal sample.") raise ValueError else: self.log.info("No samples specified, so keeping all of them.") keep_samples = self.samples keep_samples = set(self.samples) & set(keep_samples) keep_samples = list(keep_samples) nsamples = len(keep_samples) self.log.info( "Retained {} distinct samples that were verified in VCF header.". format(nsamples)) self._working_samples = keep_samples return keep_samples
def parse_variable(user_input): user_var = resplit(' *= *', user_input) # check the var name for validity, returns dictionary with variables for char in user_var[0]: if char not in ascii_letters: print('Invalid identifier') return # check if more than 1 '=' signs if len(user_var) != 2: print('Invalid assignment1') return # check if new var value is existing var if user_var[1] in variables: variables[user_var[0]] = variables[user_var[1]] else: try: variables[user_var[0]] = int(user_var[1]) except ValueError: print('Invalid assignment2')
def wellBoreDataLineAnalysis(line): line = line.replace("\t", " ") #lineList = line.split(" ") lineList = resplit("=| ", line) lineList = [a for a in lineList if a != ""] #print (lineList) if ("Real" in lineList) and ("!" in lineList): pythonString = lineList[0] + " = " + lineList[2].split("!")[0] #print ("dbg wellbore int",pythonString) #print ("dbg wellbore lineList[0]",lineList[0]) #print ("dbg wellbore lineList[2]",lineList[2].split("!")[0]) #raw_input() return pythonString, lineList[0], lineList[2].split( "!")[0], "Real", lineList[4].replace("\n", "") elif "Real" in lineList: pythonString = lineList[0] + " = " + lineList[2] #print ("dbg wellbore int",pythonString) #print ("dbg wellbore lineList[0]",lineList[0]) #print ("dbg wellbore lineList[2]",lineList[2].split("!")[0]) return pythonString, lineList[0], lineList[2].split( "!")[0], "Real", "! Int. coef" elif "Int" in lineList and ("!" in lineList): #print(" line list int: ",lineList) pythonString = lineList[0] + " = " + lineList[2].split("!")[0] return pythonString, lineList[0], lineList[2].split( "!")[0], "Int", "".join(lineList[4:]).replace("\n", "") elif "Int" in lineList: #print(" line list int: ",lineList) pythonString = lineList[0] + " = " + lineList[2].split("!")[0] return pythonString, lineList[0], lineList[2].split( "!")[0], "Int", "! Int. coef" elif "Logical" in lineList: return lineList[0], lineList[1], lineList[2] elif "Material" in lineList: return lineList[lineList.index('Material') + 1].replace("\n", "") elif "Variable" in lineList: pythonString = lineList[0] + " = " + lineList[2].split("!")[0] return pythonString, lineList[0], lineList[2].split( "!")[0], "Variable", lineList[4].replace("\n", "")
def prepare_query_frags(self): """ Construit self.api_strs et self.api_toks (permettent d'utiliser les infos structurées de l'elt XML dans une query API type Lucene) api_strs --- re-dispatch d'un dict de str[] provenant du XML vers un dict de str[] rangé par champs API (permet les comparaisons strictes avec un hit API) api_toks --- même structure mais avec les chaînes de cara tokenisées par re.split('\W'). et filtrées sur longueur >= 4 sauf exceptions (volume, pages) (permet des requêtes efficaces dans l'API) On utilise record() pour mettre à jour les dict en filtrant les [] et les [""] """ # pour la forme tokénisée on comptera les tokens retenus total_kept = 0 # dictionnaire {k => [strs]} d'expressions relevées # (rangé ici par xpath via préalable subvalues()) for bibxpath in self.tei_subvals: # todo clarifier pourquoi parfois dans les natives on a direcement du texte dans monogr/imprint # debug #~ if bibxpath == "monogr/imprint": #~ warn ("DEBUG: infos directement sous imprint ? %s" % str(self.tei_subvals)) # traduction des clés TEI => API # -------------------------------- # ex: monogr/author/surname => host.author.name champ = self.xpath_to_api_field(bibxpath) # un même point source peut avoir plusieurs chaînes # (notamment les noms d'auteurs) donc on a une mini boucle for whole_str in self.tei_subvals[bibxpath]: # on ignore certaines valeurs (ex: les initiales de prénoms) if champ == '__IGNORE__': continue # on stocke chaque chaîne avec cette nouvelle clé else: # 1 - sous forme intacte # ------------------ self.api_strs = self.record(self.api_strs, champ, whole_str) # 2 - sous forme tokénisée # -------------------- # from re import split as resplit # on utilise [^\w?*] au lieu de \W parce qu'on ne # veut pas couper sur les jokers lucene # cf. text_to_query_fragment dans bib_subvalues qui # a le droit d'ajouter des '?' et '*' for tok in resplit(r'[^\w?*]', whole_str): # warn("TOK %s" % tok) # champs ayant le droit d'être courts if champ in ['host.volume', 'host.issue','host.pages.first','host.pages.last']: # si API demande des valeurs numériques -------->8---- # ---------------------------------------------------- # on doit intercepter les cas rares non numériques # ex: cas volumes = "12 B" ou issue = "suppl 1" if search(r'[^0-9]', tok): # la partie num la plus longue grep_partie_num = search(r'([0-9]+)', tok) if grep_partie_num is not None: tok = grep_partie_num.groups()[0] else: # s'il n'y a rien de numérique on skip ce token continue # ---------------------------------------------------- # ---------------------------------------------->8---- # en tout cas enregistrement même si le token est court self.api_toks = self.record(self.api_toks, champ, tok) total_kept += 1 # champs ayant le droit à des tokens plus courts elif champ in ['host.title', 'author.name'] and (len(tok) >= 2 or tok in ['j','J',']']): self.api_toks = self.record(self.api_toks, champ, tok) total_kept += 1 # autres champs: tokens suffisemment longs uniquement elif len(tok) >= 4: self.api_toks = self.record(self.api_toks, champ, tok) total_kept += 1 # à la fin de chaque bib on vérifie si on a bien des tokens if total_kept == 0: msg = "WARNING: filtrage des tokens courts a tout supprimé (valeurs d'origine: '%s')" % self.tei_subvals warn(msg) self.log.append(msg)
def read(file_name, mode, key_col, val_cols, split_re, has_header=False, header_dict={}, ignore_chars=[], map_fs={}, reduce_fs={}, filter_f=None, state={}, update_state=None): lineno = 0 headers = header_dict key_val_dict = {} current_state = state.copy() with open(file_name, mode) as file: for line in file: if line[0] in ignore_chars: continue a = resplit(split_re, line[:-1]) if has_header: if lineno == 0: if headers == {}: headers[key_col] = a[key_col] for val_col in val_cols: headers[val_col] = a[val_col] lineno += 1 continue if update_state != None: update_state(current_state, a) if filter_f != None and not filter_f(current_state, a): lineno += 1 continue if key_col == None: key = check_and_apply_2(map_fs, 'key', current_state, lineno) else: key = check_and_apply_2(map_fs, 'key', current_state, a[key_col]) for val_col in val_cols: val_name = headers[val_col] if val_col in headers else val_col if type(val_col) is str: if val_col in current_state: val = check_and_apply_2(map_fs, val_col, current_state, current_state[val_col]) else: print('Error:' + val_col + ' not ' + 'in states', file=sys.stderr) sys.exit() else: val = check_and_apply_2(map_fs, val_col, current_state, a[val_col]) if key in key_val_dict: if val_name in key_val_dict[key]: current_val = key_val_dict[key][val_name] reduced_val = check_and_apply_2(reduce_fs, val_col, current_val, val) key_val_dict[key][val_name] = reduced_val else: key_val_dict[key][val_name] = val else: key_val_dict[key] = {} key_val_dict[key][val_name] = val lineno += 1 return (key_val_dict, current_state)
def convertPcToPdc(deffile, particlesName, startframe, endframe, pdcIncrements, outputDirectory, questionasked): '''Converts Houdini's Point Cache file to Maya's Point Disc Cach file''' print "time(): %f " % time() print 'ReadFile:' dataType = {'Integer': 0, 'Integer Array': 1, 'Double': 2, 'Double Array': 3, 'Vector': 4, 'Vector Array': 5} readFile = open(str(deffile), 'r', buffering=1024*10) fileContent = readFile.read() content = resplit('\[|\]| |', fileContent) readFile.close() count = 0 del fileContent vartest = 0 vartest1 = 0 vartesta = 0 vartestb = 0 vartestc = 0 vartestd = 0 noIds = 0 noCoords = 0 for count, item in enumerate(content): if search('\"P\"', item): index1 = count vartest = 1 if search('\"id\"', item): index2 = count vartest1 = 1 if vartest == 1: if vartesta == 0: if search('$^', item): if count > index1: index3 = count vartesta = 1 if vartesta == 1: if vartestb == 0: if search('\"', item): if count > index3: index4 = count vartestb = 1 if vartest1 == 1: if vartestc == 0: if search('$^', item): if count > index2: index5 = count vartestc = 1 if vartestc == 1: if vartestd == 0: if search('\"', item): if count > index5: index6 = count vartestd = 1 if vartest == 1: coords = content[(index3 + 1):index4] if vartest == 0: raise RuntimeError('No Coords found in file, is this a .pc.classic or .bgeo.classic file?') print "time(): %f " % time() print 'Grouping:' tempString = ','.join(str(n) for n in coords) del coords running = True while running: if tempString[-1].isdigit() == False: tempString = tempString[:-1] else: running = False tempString += ',,,' print "time(): %f " % time() print 'Coords: ' s = ''.join(tempString.split()) del tempString split = s.split(",") outputs = [' '.join(split[6*i:6*i+3]) for i in range(len(split)//6)] outputs = ' '.join(outputs) outputs = outputs.split(' ') coords = tuple(float(f) for f in outputs) del outputs if vartest1 == 0: noIds = 1 numberofids = len(coords)/3 ids = range(numberofids) ids = [float(x) for x in ids] ids = tuple(ids) if vartest1 == 1: ids = content[index5:index6] print "time(): %f " % time() print 'Ids: ' tempString2 = ','.join(str(n) for n in ids) running = True while running: if tempString2[-1].isdigit() == False: tempString2 = tempString2[:-1] else: running = False tempString2 = tempString2[1:] ids = tempString2.split(',') del tempString2 ids = [float(x.strip()) for x in ids] ids = tuple(ids) print "time(): %f " % time() print 'Set Attributes:' scaleFactor = 1 particlecount = (len(coords)) count = 0 num = range(len(coords)) attributes = ['position','particleId'] fileType = 'PDC ' formatVersion = 1 byteOrder = 1 offset = -1 extra1 = 0 extra2 = 0 particlesTotal = len(coords)/3 print "time(): %f " % time() print 'Set Header Values and records2:' attributesTotal = 2 headerValues = (fileType, formatVersion, byteOrder, extra1, extra2, particlesTotal, attributesTotal) recordsValues2 = (len(attributes[1 + offset]), attributes[1 + offset], dataType['Vector Array']) recordsValues2 += coords scaleFactor = 1 print "time(): %f " % time() print 'Set Records 3:' recordsValues3 = (len(attributes[2 + offset]), attributes[2 + offset], dataType['Double Array']) recordsValues3 += ids recordsForm = ' i{0}si{1}d i{2}si{3}d'.format(str(len(attributes[1 + offset])), str(3* particlesTotal), str(len(attributes[2 + offset])), str(len(ids))) headerForm = '>4sii2iii' form = Struct(headerForm + recordsForm) allValues = headerValues + recordsValues2 + recordsValues3 del headerValues del recordsValues2 del recordsValues3 del headerForm del recordsForm packedData = form.pack(*allValues) del allValues del form print "time(): %f " % time() print 'Writing File: \n' fileName = particlesName + '.' + str(pdcIncrements) + ".pdc" outputPDCfile = open(outputDirectory + '\\Data\\' + fileName, 'wb') outputPDCfile.write(packedData) outputPDCfile.close() del packedData print 'done' print "time(): %f " % time() if noIds == 1: warn(('No Id Values were included\n' 'Id values were assigned based on order of particles\n' 'This may cause unexpected results, to fix add a id attribute in houdini'), DeprecationWarning)
def read_eclipse_file(filename): def parse_line(line): words = line.split() starttime = words[0][4:] + ':' + words[0][:3] + ':' + words[1] stoptime = words[2][4:] + ':' + words[2][:3] + ':' + words[3] returndict = {'Start Time': starttime, 'Stop Time': stoptime, 'Duration': words[4], 'Current Condition': words[5], 'Obstruction': words[6], 'durationsec': npdouble(words[4]), 'startsec': DateTime(starttime).secs, 'stopsec': DateTime(stoptime).secs} if len(words) == 9: returndict.update({'Entry Timer': words[7], 'timersec': npdouble(words[7]), 'Type': words[8]}) return returndict with open(filename, 'rb') as fid: datalines = fid.readlines() # The first line includes the year and day the file was generated # # Note: This entry may be manually created and could be a source of error # if read incorrectly. words = datalines.pop(0).split() #eclipse = {'epoch':dict(zip(('year','day'), (words[-2][:4],words[-2][5:])))} eclipse = {'epoch': {'year': words[2]}} eclipse['epoch'].update({'dom': words[0]}) eclipse['epoch'].update({'month': words[1]}) eclipse['epoch'].update({'time': words[3]}) hosc = DateTime(words[2] + words[1] + words[0] + ' at ' + words[3]).date eclipse['epoch'].update({'doy': hosc[5:8]}) # Remove spacing lines line = datalines.pop(0) while len(line.strip()) < 50: line = datalines.pop(0) headers = resplit("\s{2,5}", line.strip()) # Truncate the Start Time, Stop Time and Duration header names headers[0] = headers[0][:10] headers[1] = headers[1][:9] headers[2] = headers[2][:8] # Remove the dashed lines separating the header from the eclipse data entries line = datalines.pop(0) # This is the eclipse number; it is used to index all eclipses in the # file. It has no other significance. n = -1 eclipse.update({'eclipse_nums': []}) while len(datalines) > 0: line = datalines.pop(0).strip() # All eclipse entries start wth at least 7 "words" if len(line.split()) == 7: # increment the eclipse number and create a placeholder dict n = n + 1 eclipse['eclipse_nums'].append(n) eclipse.update({n: {}}) # Add the entrance penumbra data, there will always be an entrance # penumbra eclipsedata = parse_line(line) eclipse[n].update({'entrancepenumbra': eclipsedata}) # If this is a full eclipse, then there will also be umbra and # exit penumbra phases. if len(datalines) > 0: if 'Umbra' in datalines[0]: line = datalines.pop(0) eclipsedata = parse_line(line) eclipse[n].update({'umbra': eclipsedata}) line = datalines.pop(0) eclipsedata = parse_line(line) eclipse[n].update({'exitpenumbra': eclipsedata}) return eclipse
#Parse dataset input names if options.dsinputs=='' or options.TR==0: dep_check() print "*+ Need at least dataset inputs and TE. Try meica.py -h" sys.exit() if os.path.abspath(os.path.curdir).__contains__('meica.'): print "*+ You are inside a ME-ICA directory! Please leave this directory and rerun." sys.exit() #Parse shorthand input file specification and TEs tes=split(options.tes,',') outprefix=options.prefix if '[' in options.dsinputs: shorthand_dsin = True dsinputs=dsprefix(options.dsinputs) prefix=resplit(r'[\[\],]',dsinputs)[0] datasets=resplit(r'[\[\],]',dsinputs)[1:-1] trailing=resplit(r'[\]+]',dsinputs)[-1] isf= dssuffix(options.dsinputs) setname=prefix+''.join(datasets)+trailing+options.label else: #Parse longhand input file specificiation shorthand_dsin = False datasets_in = options.dsinputs.split(',') datasets = [str(vv+1) for vv in range(len(tes))] prefix = dsprefix(datasets_in[0]) isf = dssuffix(datasets_in[0]) if '.nii' in isf: isf='.nii' trailing='' setname=prefix+options.label