def upload(data): """Upload a new Pcap File""" tmpPath = app.config["UPLOAD_FOLDER"] + "tmp.cap" with open(tmpPath, "w") as f: f.write(data["fileContent"]) parse(tmpPath) os.remove(tmpPath) reloadData() socketio.emit("successfullUpload", {"success": "Got it !"})
def upload(data): """Upload a new Pcap File""" tmpPath = app.config['UPLOAD_FOLDER'] + "tmp.cap" with open(tmpPath, 'w') as f: f.write(data['fileContent']) parse(tmpPath) os.remove(tmpPath) reloadData() socketio.emit('successfullUpload', {'success': 'Got it !'})
def stream_logs(app_name, source, dyno): while True: # Main Thread Loop try: for line in HerokuInterface().stream_log(app_name=app_name, source=source, dyno=dyno, timeout=100): # Search for the required keywords in this line logging.debug(line.decode('utf-8')) exit = parse(line.decode('utf-8'), app_name, source, dyno) if exit: break root = app_name + settings.SEPERATOR + source + settings.SEPERATOR + dyno exit = True if root not in settings.RULES else False if exit: break except Exception: logging.error(traceback.format_exc()) # TODO: Handle specific exceptions here # Cooling period in case of errors time.sleep(1) logging.info("Stopping log thread: {}:{}:{}".format( app_name, source, dyno))
def main(argc, argv): visual = False native = False if "-v" in argv: visual = True if "-n" in argv: native = True try: f_content = read_all(argv[argv.index("-f") + 1]) except: print("Usage: python main.py [-v] -f file_name") exit() tokens = lex(f_content) parsed = parse(tokens) # print(json.dumps(parsed, indent=4)) question_facts = parsed["question_facts"] Rules = parsed["rules"] check_rules(Rules) Facts = parsed["facts"] Graph = nx.Graph(parsed["graph_body"]) config.init(Rules, Facts, Graph, visual, native) init_pos() if config.visual: draw_graph() solve() if config.visual: draw_graph() # Result for q in question_facts: print(q, Facts[q])
def match_wind_fname(wind_fname_list, query_body, max_sec_bound=21960): # If there is wind file, then return the closest one within the max_sec_bound (in seconds) time_objs = [] trash_holder = [] wind_fname_list.sort() for item in wind_fname_list: if item.endswith('.npz'): time_string = re.findall('\d\d\d\d\d\d\d\d_\d\d\d\d_\d\d\d', item)[0] time_obj = parser.parse('%s %s'%(time_string[:8], time_string[9:13])) + \ datetime.timedelta(hours = int(time_string[-3:])) time_diff = (time_obj - baseline_time).total_seconds() if time_diff not in trash_holder: trash_holder.append(time_diff) time_objs.append([item, time_diff]) else: time_objs.pop(-1) time_objs.append([item, time_diff]) else: pass time_objs = np.array(time_objs, dtype=np.object) wind_ftime_tree = cKDTree(time_objs[:, -1].reshape(-1, 1)) query_dist, query_index = wind_ftime_tree.query( query_body.reshape(-1, 1), p=1, distance_upper_bound=max_sec_bound) valid_query = query_index < time_objs.shape[0] # binary array return query_index, valid_query, time_objs, wind_ftime_tree
def test_parse2(self): sentence = "return x*y" gram, tokenList, exeToken, param_list = parser.parse(sentence) print(gram) print(tokenList) print(exeToken) print(param_list)
def test_parse3(self): sentence = "nodes = graphFromParam.V #set" gram, tokenList, exeToken, param_list = parser.parse(sentence) print(gram) print(tokenList) print(exeToken) print(param_list)
def test_parse4(self): sentence = "for i = 0 to 9 step 2" gram, tokenList, exeToken, param_list = parser.parse(sentence) print(gram) print(tokenList) print(exeToken) print(param_list)
def random_solver_solution(filename, trials_max, error_max): """ Génère la solution de l'algorithme aléatoire :param: filename : Nom du fichier (sans extension) :param: trials_max : Nombre d'essai de l'application de l'algorithme aléatoire :param: error_max : Nombre d'erreur maximal pour le placement des bâtiments """ max_score = 0 trials_count = 0 path_out = os.path.join(os.path.curdir, 'data', 'output') while trials_count < trials_max: if not os.path.exists(path_out): os.makedirs(path_out) cityplan, project_list = parser.parse( filename) # Génère un CityPlan vide et une liste de Project cityplan, replica_list = _random_solver( cityplan, project_list, error_max) # Rempli le CityPlan et renvoi une liste de Replica score = scoring.scoring_from_replica_list(replica_list, cityplan, project_list) trials_count += 1 if score >= max_score: max_score = score parser.imgify(filename, cityplan, project_list, replica_list) parser.textify(replica_list, filename) _print_solution(filename, trials_max, max_score)
def test_parse5(self): sentence = "else if y < 0" gram, tokenList, exeToken, param_list = parser.parse(sentence) print(gram) print(tokenList) print(exeToken) print(param_list)
def upload(): if request.method == "POST": tmpPath = app.config["UPLOAD_FOLDER"] + "tmp.cap" request.files["files"].save(tmpPath) pcap = parse(tmpPath) os.remove(tmpPath) # except: # flash(u"Impossible to download ", "error") # return jsonify(error='An error occured') return jsonify(success="Pcap uploaded successfully !")
def upload(): if request.method == "POST": tmpPath = app.config['UPLOAD_FOLDER'] + "tmp.cap" request.files['files'].save(tmpPath) pcap = parse(tmpPath) os.remove(tmpPath) # except: # flash(u"Impossible to download ", "error") # return jsonify(error='An error occured') return jsonify(success='Pcap uploaded successfully !')
def match_ncwf_fname(start_time, query_body, max_sec_bound=7200): # If there is any weather instance within the max_sec_bound, then return only the closest one (w.r.t. time) time_obj_wx = [] time_diff_wx = [] ncwf_fname_hourly = [] for obj in start_time: tmp_fname = '%d_%s_%s_%s00Z.npz' % (obj[0], str( obj[1]).zfill(2), str(obj[2]).zfill(2), str(obj[3]).zfill(2)) tmp_time = parser.parse('%d/%d/%d %d:00:00' % (obj[1], obj[2], obj[0], obj[3])) ncwf_fname_hourly.append(tmp_fname) time_obj_wx.append(tmp_time) time_diff_wx.append((tmp_time - baseline_time).total_seconds()) ncwf_fname_hourly = np.array(ncwf_fname_hourly) time_diff_wx = np.array(time_diff_wx) time_obj_wx = np.array(time_obj_wx) wx_ftime_tree = cKDTree(time_diff_wx.reshape(-1, 1)) query_dist, query_index = wx_ftime_tree.query( query_body.reshape(-1, 1), p=1, distance_upper_bound=max_sec_bound) valid_query = query_index < time_diff_wx.shape[0] return query_index, valid_query, time_obj_wx, ncwf_fname_hourly, wx_ftime_tree # test_wind_npz = np.load('../../DATA/filtered_weather_data/namanl_small_npz/namanl_218_20130101_0000_000.npz') # grbs_common_info = np.load('/media/storage/DATA/filtered_weather_data/grbs_common_info.npz') # basegrid_lat = grbs_common_info['basegrid_lat'] # basegrid_lon = grbs_common_info['basegrid_lon'] # basegrid = grbs_common_info['basegrid'] # smallgrid = grbs_common_info['smallgrid'] # small_idx = grbs_common_info['small_idx'] # lvls = grbs_common_info['levels'] # lvls_dict = {} # i = 0 # for lvl in lvls: # lvls_dict[lvl] = i # i += 1 # with open('/media/storage/DATA/filtered_weather_data/grbs_level_common_info.pkl', 'rb') as pfile: # lvls_dict = pickle.load(pfile) # with open('/media/storage/DATA/filtered_weather_data/grbs_smallgrid_kdtree.pkl', 'rb') as pfile: # smallgrid_tree = pickle.load(pfile) # wx_pointer = np.load('../../DATA/NCWF/gridded_storm.npz') # ncwf_arr = wx_pointer['ncwf_arr'] # start_time = wx_pointer['start_time'] # unique_alt = wx_pointer['unique_alt'] # with open('../../DATA/NCWF/alt_dict.pkl', 'rb') as pfile: # alt_dict = pickle.load(pfile)
def clean(self, *args, **kwargs): sys.path.append(os.path.realpath('.')) from utils import parser cleaned_data = super().clean() url = cleaned_data.get('url') title = cleaned_data.get('title') if url!='': if parser.parse(url): return super(TaskCreateForm, self).clean(*args, **kwargs) else: print("Check url") raise forms.ValidationError("Проверьте ссылку") # TODO: добавить некорректность ссылки как ошибку elif title=='': print("No title") raise forms.ValidationError("Название или ссылка на ресурс должны быть обязательно") return super(TaskCreateForm, self).clean(*args, **kwargs)
def match_ncwf_fname(start_time, query_body, max_sec_bound=7200): # If there is any weather instance within the max_sec_bound, then return only the closest one (w.r.t. time) time_obj_wx = [] time_diff_wx = [] ncwf_fname_hourly = [] for obj in start_time: tmp_fname = '%d_%s_%s_%s00Z.npz' % (obj[0], str( obj[1]).zfill(2), str(obj[2]).zfill(2), str(obj[3]).zfill(2)) tmp_time = parser.parse('%d/%d/%d %d:00:00' % (obj[1], obj[2], obj[0], obj[3])) ncwf_fname_hourly.append(tmp_fname) time_obj_wx.append(tmp_time) time_diff_wx.append((tmp_time - baseline_time).total_seconds()) ncwf_fname_hourly = np.array(ncwf_fname_hourly) time_diff_wx = np.array(time_diff_wx) time_obj_wx = np.array(time_obj_wx) wx_ftime_tree = cKDTree(time_diff_wx.reshape(-1, 1)) query_dist, query_index = wx_ftime_tree.query( query_body.reshape(-1, 1), p=1, distance_upper_bound=max_sec_bound) valid_query = query_index < time_diff_wx.shape[0] return query_index, valid_query, time_obj_wx, ncwf_fname_hourly, wx_ftime_tree
from gen_utils import * from nin_model import NiNModel from utils.parser import parse FLAGS = parse() model = NiNModel(FLAGS) with tf.Session() as sess: model.train(sess)
def elitist_solver_solution(filename, error_max, generation_max): """ Algorithme élitiste de notre projet :param: filename : Nom du fichier (sans extension) :param: trials_max : Nombre d'essai de l'application de l'algorithme aléatoire :param: error_max : Nombre d'erreur maximal pour le placement des bâtiments :return: Affichage d'infomrations et génération de l'output :rtype: String """ cityplan, project_list = parser.parse( filename) # Génère un CityPlan vide et une liste de Project best_building_with_points = [] taille_matrix = cityplan.matrix.shape for generation_number in range(1, generation_max + 1): buildings_with_points = [] configuration_list = [] # on récupère un cityplan et un replica_list avec les anciens meilleurs batiments cityplan, replica_list = _copy_best_buildings_in_matrix( cityplan, project_list, best_building_with_points, taille_matrix) # réinitialisation de la variable best_building_with_points = [] print("Elitist solver for :", cityplan.name_project) print("...") # Génération d'une population aléatoire cityplan, replica_list = _advanced_random_solver( cityplan, project_list, error_max, replica_list) # Rempli le CityPlan et renvoi une liste de Replica parser.imgify(filename + str(generation_number), cityplan, project_list, replica_list) parser.textify(replica_list, filename + str(generation_number)) begin_time = time.time() tested_replica = 0 len_replica_list = len(replica_list) # score_total correspond au score total d'une génération score_total = 0 # Lecture des repliques placées dans la map for building in replica_list: project_number = int(building[0]) if type(project_list[project_number]) is Residential: if (tested_replica % 500) == 0 and tested_replica != 0: scoring._affichage_score(tested_replica, len_replica_list, score_total, begin_time, False) row = building[1][0] col = building[1][1] building_score = scoring.building_score( cityplan, row, col, project_list, project_number, replica_list) # Calcul des scores de chaque batiments score_total += building_score plan = project_list[project_number].matrix resid_adapted_coordinates = scoring._coordinates_adaptation( plan, row, col) used_surface = project_list[ project_number].get_manhattan_surface( int(cityplan.dist_manhattan_max), cityplan.matrix, resid_adapted_coordinates) list_used_surface = list(used_surface) # Récupération de toutes les cases remplies pour notre configuration id_utility_list = [] cases_configuration = [] for cases in list_used_surface: if str(cityplan.matrix[cases]) != ".": number_replica = int(cityplan.matrix[cases]) build = project_list[int(replica_list[int( cityplan.matrix[cases])][0])] if type(build) is Utility: if not (number_replica in id_utility_list): id_utility_list.append(number_replica) building_coordinates = scoring._coordinates_adaptation( build.matrix, replica_list[number_replica][1][0], replica_list[number_replica][1][1]) for coor in building_coordinates: cases_configuration.append(coor) # Calcul de l'espace utilisée par la configuration if cases_configuration: cases_configuration.sort(key=lambda x: (x[0], x[1])) row_top = int(cases_configuration[0][0]) row_bottom = int( cases_configuration[len(cases_configuration) - 1][0]) cases_configuration.sort(key=lambda x: (x[1], x[0])) col_top = int(cases_configuration[0][1]) col_bottom = int( cases_configuration[len(cases_configuration) - 1][1]) taille = [ row_bottom - row_top + 1, col_bottom - col_top + 1 ] taille_reelle = taille[0] * taille[1] densite = building_score / taille_reelle configuration_list.append([ densite, (row, col), project_number, generation_number, taille_reelle ]) # Ajout des scores de chaque batiments tested_replica += 1 print(" =-=-=-=-=-= =-=-=-=-=-=") print("Total score Generation ", generation_number, "------------------------> ", score_total) print("--- %s seconds ---" % (time.time() - begin_time)) print(" =-=-=-=-=-= =-=-=-=-=-=") # Triage des scores par ordre décroissant de la densitées configuration_list.sort(reverse=True) # Suppression des résidences qui rapportent zéro points for idx in range(0, len(configuration_list)): if configuration_list[idx][0] > 0: buildings_with_points.append(configuration_list[idx]) # Garde les meilleurs generation_number/generation_max for idx in range( 0, int((generation_number / generation_max) * len(buildings_with_points))): best_building_with_points.append(buildings_with_points[idx])
def test_parse(self): #Test1: function sentence = "function sort(array)" gram, tokenList, exeToken, param_list = parser.parse(sentence) self.assertEquals(gram, 'function_def') self.assertEquals(tokenList, ((12, 'function'), (1, 'sort'), (54, '('), (0, 'array'), (55, ')'))) self.assertEquals(param_list, ['sort', ('array',)]) sentence = "function sort()" gram, tokenList, exeToken, param_list = parser.parse(sentence) print(len(param_list[1])) #Test2: variable definition in TYPE VAR = XXX format sentence = "Stack x = [1,2]" gram, tokenList, exeToken, param_list = parser.parse(sentence) self.assertEquals(gram, 'variable_def') self.assertEquals(exeToken, 'x = Stack([ 1 , 2 ] )') self.assertEquals(tokenList, ((1, 'Stack'), (0, 'x'), (51, '='), (66, '['), (2, '1'), (64, ','), (2, '2'), (67, ']'))) self.assertEquals(param_list, ['x']) #Test3: variable definition expression sentence = "x = 'fang'" gram, tokenList, exeToken, param_list = parser.parse(sentence) self.assertEquals(gram, 'expression') self.assertEquals(exeToken, "x = 'fang' ") self.assertEquals(tokenList, ((0, 'x'), (51, '='), (2, "'fang'"))) self.assertEquals(param_list, []) #Test4: statements:for loop sentence = "for x in range(4)" gram, tokenList, exeToken, param_list = parser.parse(sentence) self.assertEquals(gram, 'statement') self.assertEquals(exeToken, "") self.assertEquals(tokenList, ((5, 'for'), (0, 'x'), (14, 'in'), (1, 'range'), (54, '('), (2, '4'), (55, ')'))) # execute function not finished yet # self.assertEquals(param_list, ['x', 0]) sentence = "for x = 0 to 9" # gram, tokenList, exeToken, param_list = parser.parse(sentence) # self.assertEquals(gram, 'statement') # self.assertEquals(exeToken, "") # self.assertEquals(tokenList, ((5, 'for'), (0, 'x'), (51, '='), (2, '0'), (18, 'to'), (2, '9'))) # #execute function not finished yet # self.assertEquals(param_list, ['x', range(0, 0)]) # sentence = "for x = 0 to 9 step 2" print(parser.lexical_analyze(sentence)) # # gram, tokenList, exeToken, param_list = parser.parse(sentence) # # self.assertEquals(gram, 'statement') # # self.assertEquals(exeToken, "") # # self.assertEquals(tokenList, ((5, 'for'), (0, 'x'), (51, '='), (2, '0'), (18, 'to'), (2, '9'), (19, 'step'), (2, '2'))) # #execute function not finished yet # # self.assertEquals(param_list, ['x', range(0, 9, 2)]) # # sentence = "while x < 9" gram, tokenList, exeToken, param_list = parser.parse(sentence) self.assertEquals(gram, 'statement') self.assertEquals(exeToken, "x < 9 ") self.assertEquals(tokenList, ((6, 'while'), (0, 'x'), (45, '<'), (2, '9'))) #execute function not finished yet self.assertEquals(param_list, ["x < 9 "])
self.lon) + "," + str(self.alt) + '\n' def parse(self, string): m = self.regex.match(string) if not m: return try: self.time = utils.parser.parseDate(int(m.group(2)), int(m.group(3))) self.startTime = self.time - datetime.timedelta( seconds=int(m.group(1)) / 1000.0) self.lat = utils.parser.parseFloat(m.group(5)) self.lon = utils.parser.parseFloat(m.group(4)) self.alt = utils.parser.parseFloat(m.group(6)) self.numSats = int(m.group(7)) self.hdop = int(m.group(8)) self.millis = int(m.group(1)) return (self.millis, self.time, (self.lat, self.lon, self.alt), self.numSats) except Exception as e: print e if __name__ == "__main__": parser = Parser() print parser.parse("hi") print parser.parse( "#GPS:1329604,80415,18163100,f:E8D91542,f:4B8CF4C2,f:9A196A43,6,132")
import re, datetime, utils.parser class Parser: def __init__(self): self.type = "PRS" self.millis = 0 self.temperature = 0 self.pressure = 0 def __str__(self): return str(self.millis) + "," + str(self.pressure) + "," + str(self.temperature) + '\n' regex = re.compile(r'#PRS:(\d+),([-+]?\d+\.\d+),([-+]?\d+\.\d+)') def parse(self, string): m = self.regex.match(string) if not m: return millis = int(m.group(1)) self.temperature = float(m.group(2)) self.pressure = float(m.group(3)) return (self.millis, self.pressure, self.temperature) if __name__ == "__main__": parser = Parser() print parser.parse("hi") print parser.parse("#PRS:182794,23.10,992.5100")
import time, datetime import argparse import random import os, sys import subprocess import cv2 import matplotlib.pyplot as plt import matplotlib #matplotlib.use('Agg') # to generate plot without X server from utils import data_tool, model_tool, general_tool from utils.parser import parse from builders import model_builder args = parse() ####################################################################################### # prepare model and dataset ####################################################################################### dataset_dir = (args.dataset_path if args.dataset_path != None else "dataset/" + args.dataset) class_names_list, label_values_list, class_names_str = data_tool.get_label_info( dataset_dir) nb_class = len(class_names_list) dataset_file_name = data_tool.get_dataset_file_name(dataset_dir=dataset_dir) input_size = (data_tool.get_minimal_size(dataset_dir=dataset_dir) if (not args.crop_height and not args.crop_width) else { 'height': args.crop_height,
from time import ctime class Parser: regex = re.compile(r'#HTU:(\d+),([-+]?\d+\.\d+),([-+]?\d+\.\d+)') def __init__(self): self.type = "HTU" self.millis = -1 self.temperature = -1 self.humidity = -1 def __str__(self): return str(self.millis) + "," + str(self.temperature) + "," + str( self.humidity) + '\n' def parse(self, string): m = self.regex.match(string) if not m: return self.millis = int(m.group(1)) self.temperature = float(m.group(2)) self.humidity = float(m.group(3)) return (self.millis, self.temperature, self.humidity) if __name__ == "__main__": parser = Parser() print parser.parse("hi") print parser.parse("#HTU:3412302,15.40,59.60")
def stop(self): case_recorder = caseRecorder(self._ansible_ctl.get_data_path_per_case()) self._ansible_ctl.collect_data() case_recorder.write_end() parser.parse(self._ansible_ctl.get_data_path_per_case())
import re, datetime, utils.parser class Parser: regex = re.compile(r'#DHT:(\d+),([-+]?\d+\.\d+),([-+]?\d+\.\d+)') def __init__(self): self.type = "DHT" self.millis = -1 self.temperature = -1 self.humidity = -1 def __str__(self): return str(self.millis) + "," + str(self.temperature) + "," + str(self.humidity) + '\n' def parse(self, string): m = self.regex.match(string) if not m: return self.millis = int(m.group(1)) self.temperature = float(m.group(2)) self.humidity = float(m.group(3)) return (self.millis, self.temperature, self.humidity) if __name__ == "__main__": parser = Parser() print parser.parse("hi") print parser.parse("#DHT:3412302,15.40,59.60")
def recursive(content, index, module): """ recursively execute sentences Grammar structure: definition: Define variables or functions. Assignment statements are also considered as definition Expression: Operations Statement: Including if, while, for and repeat/until, break, continue, return. """ if module.end_recursive: return else: # code compilation in progress if index < len(content): glb.current_line = module.line + index # empty line or comment line if not content[index].split("#")[0] or content[index].split("#")[0].isspace(): index += 1 else: # console output on server side # print("compile content: {}".format(content[index])) # lexicial analyze the statement grammar_type, tokenList, exeToken, param_list = parser.parse(content[index]) # Case1: function definition if grammar_type == "function_def": lineCount = get_block_count(content, index) module_content = content[index + 1 : index + lineCount + 1] func_name = param_list[0] func_param_list = param_list[1] glb.current_line += 1 # navigate to the next line funcModule = functionmodule(func_name, func_param_list, module_content, glb.current_line) module._func_inc(func_name, funcModule) index += lineCount + 1 # Case2: expression elif grammar_type == "expression": from utils.consoleManager import stdoutIO with stdoutIO() as s: execute(exeToken) consoleOutput = s.getvalue() if consoleOutput: glb.console_output.append(consoleOutput) plot.plot() index += 1 # Case3: statement elif grammar_type == "statement": # continue, break, return # 3.1 return statement if tokenList[0][1] == "return": try: for item in reversed(glb.variable_stack): if isinstance(item, functionmodule): item.return_list = evaluate(exeToken) break except AttributeError: raise Exception("SyntaxError: return statement must be used inside function.") # set end_recursive to true for item in reversed(glb.variable_stack): if isinstance(item, functionmodule): break elif isinstance(item, basemodule): item.setEnd() # TODO plot.printVar() #print variable status before return return # terminate the function # 3.2 break/continue statement elif tokenList[0][1] == "break" or tokenList[0][1] == "continue": for item in reversed(glb.variable_stack): if isinstance(item, functionmodule): raise Exception("Break/continue can only be used in while and for loops") # terminate the modules inside loops if isinstance(item, basemodule): if not isinstance(item, loopType): item.setEnd() else: item.setEnd() if tokenList[0][1] == "continue": item.setContinue() break # TODO plot.printVar() #print variable status return # 3.3 if, while, for statement else: lineCount = get_block_count(content, index) module_content = content[index + 1 : index + lineCount + 1] if tokenList[0][1] == "if": conditionList = [param_list[0]] contentList = [module_content] index += lineCount + 1 if index < len(content): grammar_type, tokenList, exeToken, param_list = parser.parse(content[index]) while len(tokenList) > 0 and tokenList[0][1] == "else": lineCount = get_block_count(content, index) contentList.append(content[index + 1 : index + lineCount + 1]) index += lineCount + 1 conditionList.append(param_list[0]) # continue looping if index >= len(content): break grammar_type, tokenList, exeToken, param_list = parser.parse(content[index]) ifModule = ifelsemodule(conditionList, contentList, glb.current_line) ifModule.run() elif tokenList[0][1] == "for": forModule = formodule(param_list, module_content, glb.current_line) forModule.run() index += lineCount + 1 elif tokenList[0][1] == "while": whileModule = whilemodule(param_list[0], module_content, glb.current_line) whileModule.run() index += lineCount + 1 else: raise Exception( 'Unsupported keyword: {} in statement "{}"'.format(tokenList[0][1], content[index]) ) # recursively compile the content recursive(content, index, module)
def recursive(content, index, module): """ recursively execute sentences Grammar structure: definition: Define variables or functions. Assignment statements are also considered as definition Expression: Operations Statement: Including if, while, for and repeat/until, break, continue, return. """ if module.end_recursive: return else: #code compilation in progress if index < len(content): glb.current_line = module.line + index #empty line or comment line if not content[index].split("#")[0] or content[index].split( "#")[0].isspace(): index += 1 else: #console output on server side # print("compile content: {}".format(content[index])) #lexicial analyze the statement grammar_type, tokenList, exeToken, param_list = parser.parse( content[index]) #Case1: function definition if grammar_type == 'function_def': lineCount = get_block_count(content, index) module_content = content[index + 1:index + lineCount + 1] func_name = param_list[0] func_param_list = param_list[1] glb.current_line += 1 #navigate to the next line funcModule = functionmodule(func_name, func_param_list, module_content, glb.current_line) module._func_inc(func_name, funcModule) index += (lineCount + 1) #Case2: expression elif grammar_type == 'expression': from utils.consoleManager import stdoutIO with stdoutIO() as s: execute(exeToken) consoleOutput = s.getvalue() if consoleOutput: glb.console_output.append(consoleOutput) plot.plot() index += 1 #Case3: statement elif grammar_type == 'statement': #continue, break, return #3.1 return statement if tokenList[0][1] == 'return': try: for item in reversed(glb.variable_stack): if isinstance(item, functionmodule): item.return_list = evaluate(exeToken) break except AttributeError: raise Exception( "SyntaxError: return statement must be used inside function." ) #set end_recursive to true for item in reversed(glb.variable_stack): if isinstance(item, functionmodule): break elif isinstance(item, basemodule): item.setEnd() # TODO plot.printVar() #print variable status before return return #terminate the function #3.2 break/continue statement elif tokenList[0][1] == 'break' or tokenList[0][ 1] == 'continue': for item in reversed(glb.variable_stack): if isinstance(item, functionmodule): raise Exception( "Break/continue can only be used in while and for loops" ) #terminate the modules inside loops if isinstance(item, basemodule): if not isinstance(item, loopType): item.setEnd() else: item.setEnd() if tokenList[0][1] == 'continue': item.setContinue() break #TODO plot.printVar() #print variable status return #3.3 if, while, for statement else: lineCount = get_block_count(content, index) module_content = content[index + 1:index + lineCount + 1] if tokenList[0][1] == 'if': conditionList = [param_list[0]] contentList = [module_content] index += (lineCount + 1) if index < len(content): grammar_type, tokenList, exeToken, param_list = parser.parse( content[index]) while len(tokenList ) > 0 and tokenList[0][1] == 'else': lineCount = get_block_count(content, index) contentList.append( content[index + 1:index + lineCount + 1]) index += (lineCount + 1) conditionList.append(param_list[0]) #continue looping if index >= len(content): break grammar_type, tokenList, exeToken, param_list = parser.parse( content[index]) ifModule = ifelsemodule(conditionList, contentList, glb.current_line) ifModule.run() elif tokenList[0][1] == 'for': forModule = formodule(param_list, module_content, glb.current_line) forModule.run() index += (lineCount + 1) elif tokenList[0][1] == 'while': whileModule = whilemodule(param_list[0], module_content, glb.current_line) whileModule.run() index += (lineCount + 1) else: raise Exception( "Unsupported keyword: {} in statement \"{}\"". format(tokenList[0][1], content[index])) #recursively compile the content recursive(content, index, module)
def recursive(content, index, module): """ recursively execute sentences Grammer structure: Defination: Define variables or functions, because the character of psudocode, assignment statement are also considered as defination Expression: Operations Statement: Including if, while, for and repeat/until, break, continue, return. """ if module.end_recursive: return else: if (index < len(content)): if not content[index]: index += 1 else: # and (content[index]): glb.current_content = content[index] glb.current_line = module.line + index print('compile content : {}'.format(content[index])) # preprocess should remove all annotations and useless whitespaces as well as blank lines gramm_type, tokens, extoken, param_list = parser.parse( content[index], module) #----------DEFINATION--------- if gramm_type == 'defination': if tokens[0][1] == 'function': count = get_module_index(content, index) module_content = [ content[index + i] for i in range(1, count) ] func_name = param_list[0] param_list = param_list[1] glb.current_line += 1 funcModule = funcmodule(func_name, param_list, module_content, glb.current_line) module._func_inc(func_name, funcModule) index += count else: var_name = param_list[0] module._var_inc(var_name, 0) execute(extoken, module) index += 1 #---------EXPRESSION---------- elif gramm_type == 'exp': execute(extoken, module) index += 1 #---------STATEMENT---------- elif gramm_type == 'statement': # continue, break, and return # haven't tested yet, waiting for debug # deal with "return" statement: # reverse stop modules in module_stack until meet last function module if tokens[0][1] == 'return': try: # test return multiple values module.return_list = eval(extoken, glb.global_var_list, module.var_list) except AttributeError: print( 'SyntaxError: return statement should be in a function' ) sys.exit(1) for module in reversed(glb.module_stack): if not isinstance(module, function_module): module.setEnd() else: break return # deal with "break" and "continue "statement: # similiar with "return" statement if (tokens[0][1] == 'break') or (tokens[0][1] == 'continue'): for module in reversed(glb.module_stack): if not isinstance(module, loop_module): module.setEnd() else: # first "not loop" module module.setEnd() if tokens[0][1] == 'continue': module.setContinue() break return # if, while, and for count = get_module_index(content, index) module_content = [ content[index + i] for i in range(1, count) ] exp = param_list[0] if tokens[0][1] == 'if': exps = [exp] contents = [module_content] index += count # find better way to write this part, a little bit ugly if index < len(content): gramm_type, tokens, extoken, param_list = parser.parse( content[index], module) while tokens[0][1] == 'else': count = get_module_index(content, index) contents.append([ content[index + i] for i in range(1, count) ]) index += count exp = param_list[0] exps.append(exp) if index >= len(content): break gramm_type, tokens, extoken, param_list = parser.parse( content[index], module) glb.current_line += 1 ifModule = ifelsemodule(module.var_list, module.func_list, exps, contents, glb.current_line) ifModule.run() index -= count elif tokens[0][1] == 'for': glb.current_line += 1 forModule = formodule(module.var_list, module.func_list, exp, module_content, glb.current_line) forModule.run() elif tokens[0][1] == 'while': # glb.current_line+=1 whileModule = whilemodule(module.var_list, module.func_list, exp, module_content, glb.current_line) whileModule.run() # elif tokens[0][1] == 'repeat': # pass index += count recursive(content, index, module)
async def inline_kb_answer_callback_handler(query: types.CallbackQuery): await bot.send_message(query.from_user.id, parse())
self.numSats = 0 def __str__(self): return str(self.time) + "," + str(self.lat) + "," + str(self.lon) + "," + str(self.alt) + "\n" def parse(self, string): m = self.regex.match(string) if not m: return try: self.time = utils.parser.parseDate(int(m.group(2)), int(m.group(3))) self.startTime = self.time - datetime.timedelta(seconds=int(m.group(1)) / 1000.0) self.lat = utils.parser.parseFloat(m.group(5)) self.lon = utils.parser.parseFloat(m.group(4)) self.alt = utils.parser.parseFloat(m.group(6)) self.numSats = int(m.group(7)) self.hdop = int(m.group(8)) self.millis = int(m.group(1)) return (self.millis, self.time, (self.lat, self.lon, self.alt), self.numSats) except Exception as e: print e if __name__ == "__main__": parser = Parser() print parser.parse("hi") print parser.parse("#GPS:1329604,80415,18163100,f:E8D91542,f:4B8CF4C2,f:9A196A43,6,132")
import numpy as np import matplotlib.pyplot as plt import utils.parser as parser # parse args args = parser.parse() import keras from keras.models import Model from keras.layers import Input, Dense, Dropout, Lambda, Activation, Reshape from keras import backend as K import utils.data_loader as data_loader from autoencoders.models import * import utils.viz as viz # load data data1, data2 = data_loader.load(args) x_train_orig, y_train_orig, x_test_orig, y_test_orig = data1 x_train, y_train, xy_train, x_xy_y_train, x_test, y_test_gen = data2 IMG_SIZE = x_train_orig.shape[1] INPUT_SIZE = x_train.shape[1] LATENT_SIZE = 32 EPOCHS = 50 EPOCHS_COMPLETE = 5 BATCH_SIZE = 64 ############## # Autoencoder if args['model'] == 'flatten':
def stop(self): case_recorder = caseRecorder( self._ansible_ctl.get_data_path_per_case()) self._ansible_ctl.collect_data() case_recorder.write_end() parser.parse(self._ansible_ctl.get_data_path_per_case())
def recursive(content, index, module): """ recursively execute sentences Grammer structure: Defination: Define variables or functions, because the character of psudocode, assignment statement are also considered as defination Expression: Operations Statement: Including if, while, for and repeat/until, break, continue, return. """ if module.end_recursive: return else: if (index < len(content)): if not content[index]: index += 1 else:# and (content[index]): glb.current_content = content[index] glb.current_line = module.line + index print('compile content : {}'.format(content[index])) # preprocess should remove all annotations and useless whitespaces as well as blank lines gramm_type, tokens, extoken, param_list = parser.parse(content[index], module) #----------DEFINATION--------- if gramm_type == 'defination': if tokens[0][1] == 'function': count = get_module_index(content, index) module_content = [content[index+i] for i in range(1, count)] func_name = param_list[0] param_list = param_list[1] glb.current_line+=1 funcModule = funcmodule(func_name, param_list, module_content,glb.current_line) module._func_inc(func_name, funcModule) index += count else: var_name = param_list[0] module._var_inc(var_name, 0) execute(extoken, module) index += 1 #---------EXPRESSION---------- elif gramm_type == 'exp': execute(extoken, module) index += 1 #---------STATEMENT---------- elif gramm_type == 'statement': # continue, break, and return # haven't tested yet, waiting for debug # deal with "return" statement: # reverse stop modules in module_stack until meet last function module if tokens[0][1] == 'return': try: # test return multiple values module.return_list = eval(extoken, glb.global_var_list, module.var_list) except AttributeError: print('SyntaxError: return statement should be in a function') sys.exit(1) for module in reversed(glb.module_stack): if not isinstance(module, function_module): module.setEnd() else: break return # deal with "break" and "continue "statement: # similiar with "return" statement if (tokens[0][1] == 'break') or (tokens[0][1] == 'continue'): for module in reversed(glb.module_stack): if not isinstance(module, loop_module): module.setEnd() else: # first "not loop" module module.setEnd() if tokens[0][1] == 'continue': module.setContinue() break return # if, while, and for count = get_module_index(content, index) module_content = [content[index+i] for i in range(1, count)] exp = param_list[0] if tokens[0][1] == 'if': exps = [exp] contents = [module_content] index += count # find better way to write this part, a little bit ugly if index < len(content): gramm_type, tokens, extoken, param_list = parser.parse(content[index], module) while tokens[0][1] == 'else': count = get_module_index(content, index) contents.append([content[index+i] for i in range(1, count)]) index += count exp = param_list[0] exps.append(exp) if index >= len(content): break gramm_type, tokens, extoken, param_list = parser.parse(content[index], module) glb.current_line+=1 ifModule = ifelsemodule(module.var_list, module.func_list, exps, contents, glb.current_line) ifModule.run() index -= count elif tokens[0][1] == 'for': glb.current_line+=1 forModule = formodule(module.var_list, module.func_list, exp, module_content, glb.current_line) forModule.run() elif tokens[0][1] == 'while': # glb.current_line+=1 whileModule = whilemodule(module.var_list, module.func_list, exp, module_content, glb.current_line) whileModule.run() # elif tokens[0][1] == 'repeat': # pass index += count recursive(content, index, module)
import re, datetime, utils.parser class Parser: regex = re.compile(r'#GPS:(\d+),(\d+),([-+]?\d+\.\d+),([-+]?\d+\.\d+),([-+]?\d+\.\d+),(\d+),(\d+)') def parse(self, string): m = self.regex.match(string) if not m: return millis = int(m.group(1)) return (millis) if __name__ == "__main__": parser = Parser() print parser.parse("hi") print parser.parse("#GPS:2136,12,37.462688,-122.274070,229.20,9,114")
import re, datetime, utils.parser class Parser: def __init__(self): self.type = "PRS" self.millis = 0 self.temperature = 0 self.pressure = 0 def __str__(self): return str(self.millis) + "," + str(self.pressure) + "," + str( self.temperature) + '\n' regex = re.compile(r'#PRS:(\d+),([-+]?\d+\.\d+),([-+]?\d+\.\d+)') def parse(self, string): m = self.regex.match(string) if not m: return millis = int(m.group(1)) self.temperature = float(m.group(2)) self.pressure = float(m.group(3)) return (self.millis, self.pressure, self.temperature) if __name__ == "__main__": parser = Parser() print parser.parse("hi") print parser.parse("#PRS:182794,23.10,992.5100")
def setUp(self): self.test_list = parse("D:/Progs/IB/utils/9.2.3.Camellia.vectors1.txt")