return json.loads(devices_contents)["devices"] def translate_device_ip_to_sysname(self, device): """If hostname is an IPv4, return the sysname, that might be more descriptive""" hostname = device["hostname"] if is_ipv4(hostname): return device["sysName"] return device["hostname"] librenms_api = LibreNMSAPI(auth_token=auth_token, request_headers=request_headers, api_url=api_url) alerts = librenms_api.get_alerts() devices = librenms_api.get_devices() icmp_down_devices = PrettyTable() icmp_down_devices.field_names = ["Hostname", "Notes", "Down since", "Location"] critical_alerts = PrettyTable() critical_alerts.field_names = ["Hostname", "Alert rule", "OS Version", "Location"] warning_alerts = PrettyTable() warning_alerts.field_names = ["Hostname", "Alert rule", "OS Version", "Location"] for device in devices: if device["status_reason"] == "icmp": if device["ignore"] == 0 or device["disabled"] == 0: device_down_since = device["last_ping"] device_location = re.sub(r'\[.*\]', '', device["location"]) # remove gps coords device_hostname = librenms_api.translate_device_ip_to_sysname(device) device_purpose = device["purpose"].rstrip() icmp_down_devices.add_row([device_hostname, device_purpose, device_down_since, device_location])
if row == 2: axes[row, o].xaxis.set_ticks(np.arange(0, 10, 1)) else: axes[row, o].xaxis.set_ticks([]) ## from list to matrix A_list = [] for pb in bigprob: A_list.append([x[1] for x in pb]) #A_list.append([(x[1]+0.0001)/sum([i[1] for i in pb]) for x in pb]) # flipped_A_list=zip(*A_list) # print flipped_A_list A = np.array([pp for pp in A_list]) #the matrix p = PrettyTable() #prettyprint matrix for roar in A: p.add_row(roar) print p.get_string(header=False, border=True) vals, vecs = eigen(A) vals[0] np.set_printoptions(suppress=True) # supress scientific notation on screen print "Stationary distribution: ", norm(vecs[:, 0]) bigprob = [] #plots fig = matplotlib.pyplot.gcf() fig.set_size_inches(16, 8)
disp_dict = {} for x in range(1, 9): disp_dict["disp{0}".format(x)] = 0 for i in range(m): ctr = 1 for key, value in disp_dict.items(): row = y_dict[f'y_row{ctr}'] disp_dict[key] += ((row[i] - np.average(row))**2) / m ctr += 1 disp_sum = sum(disp_dict.values()) disp_list = [round(disp, 3) for disp in disp_dict.values()] column_names = [ "X0", "X1", "X2", "X3", "X1X2", "X1X3", "X2X3", "X1X2X3", "Y1", "Y2", "Y3", "Y", "S^2" ] pt = PrettyTable() factors.extend([y1, y2, y3, Y_average, disp_list]) for k in range(len(factors)): pt.add_column(column_names[k], factors[k]) print(pt, "\n") print( "y = {} + {} * X1 + {} * X2 + {} * X3 + {} * X1X2 + {} * X1X3 + {} * X2X3 + {} * X1X2X3 \n" .format(list_bi[0], list_bi[1], list_bi[2], list_bi[3], list_bi[4], list_bi[5], list_bi[6], list_bi[7])) pt = PrettyTable() x_arr.extend([y1, y2, y3, Y_average, disp_list]) for k in range(len(factors)): pt.add_column(column_names[k], x_arr[k]) print(pt, "\n") list_ai = [round(i, 5) for i in solve(a_list, Y_average)] print(
def format_diag_matrix(matrix): mols = R.molecule_names() table = PrettyTable(field_names=mols) for row in matrix: table.add_row(row) return str(table)
data = results['data'] ticker_url_pairs = {} for currency in data: symbol = currency['symbol'] url = currency['id'] ticker_url_pairs[symbol] = url print() print('MY Cryptocurrency PORTFOLIO') print() portfolio_value = 0.00 last_updated = 0 table = PrettyTable(['Asset', 'Amount Owned', convert + ' Value', 'Price', '1h', '24h', '7d']) with open('portfolio.txt') as inp: for line in inp: ticker, amount = line.split() ticker = ticker.upper() ticker_url = 'https://api.coinmarketcap.com/v2/ticker/' + str(ticker_url_pairs[ticker]) + '/' + url_end request = requests.get(ticker_url) results = request.json() currency = results['data'][0] rank = currency['rank'] name = currency['name'] last_updated = currency['last_updated']
import numpy as np from scipy.optimize import minimize, Bounds import math from prettytable import PrettyTable import seaborn as sns banana_pt = PrettyTable(["x1", "x2"]) egg_pt = PrettyTable(["x1", "x2"]) gol_pt = PrettyTable(["x1", "x2", "x3", "x4", "x5", "x6", "x7"]) # Rosenbrok function def banana(x): print(x) x1, x2 = list(x) return 100 * (x2 - x1**2)**2 + (1 - x1)**2 def banana_callback(xp): x1, x2 = list(xp) banana_pt.add_row([x1, x2]) def eggcrate(x): x1, x2 = list(x) return x1**2 + x2**2 + 25 * (math.sin(x1)**2 + math.sin(x2)**2) def egg_callback(xp): x1, x2 = list(xp)
if paramvariations.has_key(designator): curr_value = paramvariations[designator] else: curr_value = {} curr_value.update({d['ParameterName']: d['VariantValue']}) paramvariations.update({designator: curr_value}) with open(args.pnp[0], 'r') as f: reader = csv.reader(f) for row in reader: do_print = True # skip header lines if reader.line_num < 3: if reader.line_num == 1: t = PrettyTable(row) continue try: designator = row[0] if variations.has_key(designator): kind = variations[designator] if kind == '0': row[10] = paramvariations[designator]['Comment'] elif kind == '1': do_print = False if do_print: t.add_row(row) except IndexError: pass if args.output:
from prettytable import PrettyTable year = PrettyTable() year.field_names = ["Category", "Tammi", "Helmi", "Maalis", "Huhti", "Touko", "Kesa", "Heina", "Elo", "Syys", "Loka", "Marras", "Joulu", "YHT", "KA"] #year.add_row(["Ruoka", 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, -12, "paljon", "ka"]) print(year) print(year.field_names) import json import random with open('nordea_categories.json', 'r') as handle: parsed = json.load(handle) for cat in parsed.keys(): line = [cat] amounts = random.sample(range(-1000,0), 12) total = int(sum(amounts)) average = int(sum(amounts)/len(amounts)) line.extend(amounts) line.append(total) line.append(average) print(line) year.add_row(line) print(year) def print_year(year_transactions): """ orderedDict: {year : { Jan: {cat1: <amount>, cat2: <amount>},
import sys import utils from prettytable import PrettyTable table = PrettyTable([ 'Player', 'Total Games', 'Ascensions', 'Pct', 'Avg. Turns', 'Fastest', 'Slowest', 'Total Turns', 'Total Points', 'Avg. Points', 'Time Spent' ]) def process_ascensions(player_dict): for p in player_dict: if len(player_dict[p]['ascension_games']) == 0: print "No ascensions for %s. Total games: %s" % ( p, len(player_dict[p]['dates'])) sys.exit(99) roles = [str(g['role']) for g in player_dict[p]['ascension_games']] race = [str(g['race']) for g in player_dict[p]['ascension_games']] gender0 = [ str(g['gender0']) for g in player_dict[p]['ascension_games'] ] gender = [str(g['gender']) for g in player_dict[p]['ascension_games']] align0 = [str(g['align0']) for g in player_dict[p]['ascension_games']] align = [str(g['align']) for g in player_dict[p]['ascension_games']] points = [int(g['points']) for g in player_dict[p]['ascension_games']] turns = [ int(g['turns']) if g['turns'] else 0 for g in player_dict[p]['ascension_games'] ] dates = [
import csv import pickle import smtplib from email.mime.multipart import MIMEMultipart from email.mime.text import MIMEText import time from prettytable import PrettyTable window = Tk() #tkinter window instance window.title("Estados de Cuenta Epcot") window.geometry('510x410') var1 = StringVar() sentEmails = StringVar() statement = PrettyTable(['Fecha', 'Numero','Factura', 'Abono', 'Saldo']) frameCSV = Frame(window, width = 500, height = 200, bd = 5, relief = RAISED) frameCSV.grid(row = 0, column = 0, sticky = N+E+W, padx = 5) frameCSV.grid_propagate(False) frameSend = Frame(window, width = 500, height = 200, bd = 5, relief = RAISED) frameSend.grid(row = 1, column = 0, sticky = N+S+E+W, padx = 5) frameSend.grid_propagate(False) with open('config.dat', 'rb') as f: outgoingServer, port, myEmail, myPassword = pickle.load(f) server = smtplib.SMTP_SSL(outgoingServer, port) server.ehlo() user = myEmail password = myPassword
import gradient as gr import levels as lvl if __name__ == '__main__': sp.init_printing(wrap_line=False, use_unicode=True) init() f_k: Tuple[float, float, float, float, float] = (4.0, 2.0, 1.0, -2.0, -3.0) # f_k: Tuple[float, float, float, float, float] = (7.0, 4.0, 2.0, 10.0, 0.0) a, b, c, d, e = f_k N: int = 25 extra_dots: List[Tuple[List[Tuple[float, float]], str, str]] = [] t1: PrettyTable = PrettyTable( [ f"{Fore.YELLOW}Method{Fore.RESET}", f"{Fore.CYAN}X{Fore.RESET}", f"{Fore.CYAN}Y{Fore.RESET}", f"{Fore.CYAN}No of Iterations{Fore.RESET}", ], title="f(x)") t2: PrettyTable = PrettyTable( [ f"{Fore.YELLOW}Method{Fore.RESET}", f"{Fore.CYAN}X{Fore.RESET}", f"{Fore.CYAN}Y{Fore.RESET}", f"{Fore.CYAN}No of Iterations{Fore.RESET}", ], title="g(x)") x = sp.Symbol('x') y = sp.Symbol('y') f: sp.Add = a*x**2 + b*x*y + c*y**2 + d*x + e*y
def single_source_path_table(distances): distance_table = PrettyTable() distance_table.field_names = ["Destination Vertex", "Distance (hops)"] for destination_vertex, distance in distances.items(): distance_table.add_row([destination_vertex, distance]) return distance_table
def evaluate(model, actor3D, range_, loader, is_info_dicts=False, dump_dir=None): #face un numpy array de 3 dimensiuni. actor3D e un array care are alti 3 array, fiecare din ei cu dimensiunea (2000,1). #asadar check_result are shape-ul (2000,3,10) check_result = np.zeros ( (len ( actor3D[0] ), len ( actor3D ), 10), dtype=np.int32 ) accuracy_cnt = 0 error_cnt = 0 for idx, imgs in enumerate ( tqdm ( loader ) ): img_id = range_[idx] try: if is_info_dicts: info_dicts = numpify ( imgs ) model.dataset = MemDataset ( info_dict=info_dicts, camera_parameter=camera_parameter, template_name='Unified' ) poses3d = model._estimate3d ( 0, show=False ) else: #face exact acelasi lucru ca si la demo # imgs e o lista cu 3 tensori. # un img_batch e un tensor din acestia 3, si are dimensiunea (288,360,3) si mai trebuie sa aflu de unde vine this_imgs = list () for img_batch in imgs: this_imgs.append ( img_batch.squeeze ().numpy () ) poses3d = model.predict ( imgs=this_imgs, camera_parameter=camera_parameter, template_name='Unified', show=False ) except Exception as e: logger.critical ( e ) poses3d = False for pid in range ( len ( actor3D ) ): if actor3D[pid][img_id][0].shape == (1, 0) or actor3D[pid][img_id][0].shape == (0, 0): continue if not poses3d: check_result[img_id, pid, :] = -1 logger.error ( f'Cannot get any pose in img:{img_id}' ) continue model_poses = np.stack ( [coco2shelf3D ( i ) for i in deepcopy ( poses3d )] ) gt_pose = actor3D[pid][img_id][0] dist = vectorize_distance ( np.expand_dims ( gt_pose, 0 ), model_poses ) model_pose = model_poses[np.argmin ( dist[0] )] bones = [[0, 1], [1, 2], [3, 4], [4, 5], [6, 7], [7, 8], [9, 10], [10, 11], [12, 13]] for i, bone in enumerate ( bones ): start_point, end_point = bone if is_right ( model_pose[start_point], model_pose[end_point], gt_pose[start_point], gt_pose[end_point] ): check_result[img_id, pid, i] = 1 accuracy_cnt += 1 else: check_result[img_id, pid, i] = -1 error_cnt += 1 gt_hip = (gt_pose[2] + gt_pose[3]) / 2 model_hip = (model_pose[2] + model_pose[3]) / 2 if is_right ( model_hip, model_pose[12], gt_hip, gt_pose[12] ): check_result[img_id, pid, -1] = 1 accuracy_cnt += 1 else: check_result[img_id, pid, -1] = -1 error_cnt += 1 bone_group = OrderedDict ( [('Head', np.array ( [8] )), ('Torso', np.array ( [9] )), ('Upper arms', np.array ( [5, 6] )), ('Lower arms', np.array ( [4, 7] )), ('Upper legs', np.array ( [1, 2] )), ('Lower legs', np.array ( [0, 3] ))] ) total_avg = np.sum ( check_result > 0 ) / np.sum ( np.abs ( check_result ) ) person_wise_avg = np.sum ( check_result > 0, axis=(0, 2) ) / np.sum ( np.abs ( check_result ), axis=(0, 2) ) bone_wise_result = OrderedDict () bone_person_wise_result = OrderedDict () for k, v in bone_group.items (): bone_wise_result[k] = np.sum ( check_result[:, :, v] > 0 ) / np.sum ( np.abs ( check_result[:, :, v] ) ) bone_person_wise_result[k] = np.sum ( check_result[:, :, v] > 0, axis=(0, 2) ) / np.sum ( np.abs ( check_result[:, :, v] ), axis=(0, 2) ) tb = PrettyTable () tb.field_names = ['Bone Group'] + [f'Actor {i}' for i in range ( bone_person_wise_result['Head'].shape[0] )] + [ 'Average'] list_tb = [tb.field_names] for k, v in bone_person_wise_result.items (): this_row = [k] + [np.char.mod ( '%.4f', i ) for i in v] + [np.char.mod ( '%.4f', np.sum ( v ) / len ( v ) )] list_tb.append ( [float ( i ) if isinstance ( i, type ( np.array ( [] ) ) ) else i for i in this_row] ) tb.add_row ( this_row ) this_row = ['Total'] + [np.char.mod ( '%.4f', i ) for i in person_wise_avg] + [ np.char.mod ( '%.4f', np.sum ( person_wise_avg ) / len ( person_wise_avg ) )] tb.add_row ( this_row ) list_tb.append ( [float ( i ) if isinstance ( i, type ( np.array ( [] ) ) ) else i for i in this_row] ) if dump_dir: np.save ( osp.join ( dump_dir, time.strftime ( str ( model_cfg.testing_on ) + "_%Y_%m_%d_%H_%M", time.localtime ( time.time () ) ) ), check_result ) with open ( osp.join ( dump_dir, time.strftime ( str ( model_cfg.testing_on ) + "_%Y_%m_%d_%H_%M.csv", time.localtime ( time.time () ) ) ), 'w' ) as f: writer = csv.writer ( f ) writer.writerows ( list_tb ) writer.writerow ( [model_cfg] ) print ( tb ) print ( model_cfg ) return check_result, list_tb
def dataxes_alias_change(self, new=True): """ 索引名约定规则: {$index_name}(@{$partition})@{$version} $index_name: 索引名,会作为别名指向 $partition: 分区名,约定的概念,可有可无,用于扩充同一索引 $version: yyyyMMddhhmmss的时间,为作业的end_time """ alias = self.dataxes_alias_name() candidate_indices = self._es_get_candidate_indices(new) current_indices = self._es_get_current_indices() backup_indices = self._es_get_candidate_indices(not new) assert new or not backup_indices, "回滚时不应该有待切换的新索引: {}".format( ','.join(backup_indices)) actions_ = [] relations_ = {} if candidate_indices: for index in candidate_indices: index_partition = '@'.join(index.split('@')[:-1]) assert not relations_.get( index_partition), "待切换索引(分区){}有多个".format(index_partition) relations_[index_partition] = [index] old_aliases = self._es_get_index_aliases(index) for old_alias in old_aliases: actions_.append( {"remove": { "index": index, "alias": old_alias }}) actions_.append({"add": {"index": index, "alias": alias}}) if len(index.split('@')) == 3: partition = index.split('@')[1] actions_.append({ "add": { "index": index, "alias": '{}@{}'.format(alias, partition) } }) # remove current for index in current_indices: index_partition = '@'.join(index.split('@')[:-1]) old_aliases = self._es_get_index_aliases(index) relations_[index_partition] = relations_.get( index_partition, [""]) relations_[index_partition].append(index) for old_alias in old_aliases: actions_.append( {"remove": { "index": index, "alias": old_alias }}) actions_.append({ "add": { "index": index, "alias": ".{}@{}".format(alias, "old" if new else "new") } }) for relation_ in relations_.values(): if len(relation_) == 1: relation_.append("") if backup_indices: for index in backup_indices: index_partition = '@'.join(index.split('@')[:-1]) relations_[index_partition] = relations_.get( index_partition, ["", ""]) relations_[index_partition].append(index) for relation_ in relations_.values(): if len(relation_) == 2: relation_.append("") # print change table if not new: x = PrettyTable( ["index / partition", "old -> current", "current -> new"]) elif backup_indices: x = PrettyTable([ "index / partition", "new -> current", "current -> old", "old -> delete" ]) else: x = PrettyTable( ["index / partition", "new -> current", "current -> old"]) x.padding_width = 1 # One space between column edges and contents (default) for alias_, relation_ in relations_.items(): relation_ = [alias_] + relation_ x.add_row(relation_) logging.info("根据DataXes别名规则与配置,将按如下动作切换索引别名:\n{}".format(x)) self.alias_actions = """{}""".format(x) self._es_change_aliases(actions_) if backup_indices: for index in backup_indices: logging.info("删除旧版本的备份索引: {}".format(index)) self.client.indices.delete(index) else: logging.info("未发现待切换索引,不做任何切换")
def train(self, train, val, test = None, verbose = True): if len(train.Label.unique()) == 2: self.binary = True self.config['binary'] = True lr = self.config['LR'] decay = self.config['decay'] BATCH_SIZE = self.config['batch_size'] train_epoch = self.config['train_epoch'] if 'test_every_X_epoch' in self.config.keys(): test_every_X_epoch = self.config['test_every_X_epoch'] else: test_every_X_epoch = 40 loss_history = [] self.model = self.model.to(self.device) # support multiple GPUs if torch.cuda.device_count() > 1: if verbose: print("Let's use " + str(torch.cuda.device_count()) + " GPUs!") self.model = nn.DataParallel(self.model, dim = 0) elif torch.cuda.device_count() == 1: if verbose: print("Let's use " + str(torch.cuda.device_count()) + " GPU!") else: if verbose: print("Let's use CPU/s!") # Future TODO: support multiple optimizers with parameters opt = torch.optim.Adam(self.model.parameters(), lr = lr, weight_decay = decay) if verbose: print('--- Data Preparation ---') params = {'batch_size': BATCH_SIZE, 'shuffle': True, 'num_workers': self.config['num_workers'], 'drop_last': False} if (self.drug_encoding == "MPNN"): params['collate_fn'] = mpnn_collate_func training_generator = data.DataLoader(data_process_loader_Property_Prediction(train.index.values, train.Label.values, train, **self.config), **params) validation_generator = data.DataLoader(data_process_loader_Property_Prediction(val.index.values, val.Label.values, val, **self.config), **params) if test is not None: info = data_process_loader_Property_Prediction(test.index.values, test.Label.values, test, **self.config) params_test = {'batch_size': BATCH_SIZE, 'shuffle': False, 'num_workers': self.config['num_workers'], 'drop_last': False, 'sampler':SequentialSampler(info)} if (self.drug_encoding == "MPNN"): params_test['collate_fn'] = mpnn_collate_func testing_generator = data.DataLoader(data_process_loader_Property_Prediction(test.index.values, test.Label.values, test, **self.config), **params_test) # early stopping if self.binary: max_auc = 0 else: max_MSE = 10000 model_max = copy.deepcopy(self.model) valid_metric_record = [] valid_metric_header = ["# epoch"] if self.binary: valid_metric_header.extend(["AUROC", "AUPRC", "F1"]) else: valid_metric_header.extend(["MSE", "Pearson Correlation", "with p-value", "Concordance Index"]) table = PrettyTable(valid_metric_header) float2str = lambda x:'%0.4f'%x if verbose: print('--- Go for Training ---') t_start = time() for epo in range(train_epoch): for i, (v_d, label) in enumerate(training_generator): if self.drug_encoding == "MPNN" or self.drug_encoding == 'Transformer': v_d = v_d else: v_d = v_d.float().to(self.device) #score = self.model(v_d, v_p.float().to(self.device)) score = self.model(v_d) label = Variable(torch.from_numpy(np.array(label)).float()).to(self.device) if self.binary: loss_fct = torch.nn.BCELoss() m = torch.nn.Sigmoid() n = torch.squeeze(m(score), 1) loss = loss_fct(n, label) else: loss_fct = torch.nn.MSELoss() n = torch.squeeze(score, 1) loss = loss_fct(n, label) loss_history.append(loss.item()) opt.zero_grad() loss.backward() opt.step() if verbose: if (i % 100 == 0): t_now = time() if verbose: print('Training at Epoch ' + str(epo + 1) + ' iteration ' + str(i) + \ ' with loss ' + str(loss.cpu().detach().numpy())[:7] +\ ". Total time " + str(int(t_now - t_start)/3600)[:7] + " hours") ### record total run time ##### validate, select the best model up to now with torch.set_grad_enabled(False): if self.binary: ## binary: ROC-AUC, PR-AUC, F1 auc, auprc, f1, logits = self.test_(validation_generator, self.model) lst = ["epoch " + str(epo)] + list(map(float2str,[auc, auprc, f1])) valid_metric_record.append(lst) if auc > max_auc: model_max = copy.deepcopy(self.model) max_auc = auc if verbose: print('Validation at Epoch '+ str(epo + 1) + ' , AUROC: ' + str(auc)[:7] + \ ' , AUPRC: ' + str(auprc)[:7] + ' , F1: '+str(f1)[:7]) else: ### regression: MSE, Pearson Correlation, with p-value, Concordance Index mse, r2, p_val, CI, logits = self.test_(validation_generator, self.model) lst = ["epoch " + str(epo)] + list(map(float2str,[mse, r2, p_val, CI])) valid_metric_record.append(lst) if mse < max_MSE: model_max = copy.deepcopy(self.model) max_MSE = mse if verbose: print('Validation at Epoch '+ str(epo + 1) + ' , MSE: ' + str(mse)[:7] + ' , Pearson Correlation: '\ + str(r2)[:7] + ' with p-value: ' + str(p_val)[:7] +' , Concordance Index: '+str(CI)[:7]) table.add_row(lst) #### after training prettytable_file = os.path.join(self.result_folder, "valid_markdowntable.txt") with open(prettytable_file, 'w') as fp: fp.write(table.get_string()) # load early stopped model self.model = model_max if test is not None: if verbose: print('--- Go for Testing ---') if self.binary: auc, auprc, f1, logits = self.test_(testing_generator, model_max, test = True, verbose = verbose) test_table = PrettyTable(["AUROC", "AUPRC", "F1"]) test_table.add_row(list(map(float2str, [auc, auprc, f1]))) if verbose: print('Testing AUROC: ' + str(auc) + ' , AUPRC: ' + str(auprc) + ' , F1: '+str(f1)) else: mse, r2, p_val, CI, logits = self.test_(testing_generator, model_max, test = True, verbose = verbose) test_table = PrettyTable(["MSE", "Pearson Correlation", "with p-value", "Concordance Index"]) test_table.add_row(list(map(float2str, [mse, r2, p_val, CI]))) if verbose: print('Testing MSE: ' + str(mse) + ' , Pearson Correlation: ' + str(r2) + ' with p-value: ' + str(p_val) +' , Concordance Index: '+str(CI)) np.save(os.path.join(self.result_folder, str(self.drug_encoding) + '_logits.npy'), np.array(logits)) ######### learning record ########### ### 1. test results prettytable_file = os.path.join(self.result_folder, "test_markdowntable.txt") with open(prettytable_file, 'w') as fp: fp.write(test_table.get_string()) if verbose: ### 2. learning curve fontsize = 16 iter_num = list(range(1,len(loss_history)+1)) plt.figure(3) plt.plot(iter_num, loss_history, "bo-") plt.xlabel("iteration", fontsize = fontsize) plt.ylabel("loss value", fontsize = fontsize) pkl_file = os.path.join(self.result_folder, "loss_curve_iter.pkl") with open(pkl_file, 'wb') as pck: pickle.dump(loss_history, pck) fig_file = os.path.join(self.result_folder, "loss_curve.png") plt.savefig(fig_file) if verbose: print('--- Training Finished ---')
def cleanDesktop(fileExtensions): clear = lambda: os.system('clear') directory = os.path.join(os.path.join(os.environ['HOME']), 'Documents/Desktop Files') # print(directory) if not os.path.exists(directory): os.makedirs(directory) # desktopFiles = defaultdict(list) desktop = os.path.join(os.path.join(os.environ['HOME']), 'Desktop') print (desktop) shortcutExt = ["ini","lnk","db"] # extensions = [] global rollback rowCount =0 result = PrettyTable(["FileName","ActualPath",r"NewPath(Documents/DesktopFiles/)"]) for root, dirs, files in os.walk(desktop): try: for fi in files: # desktopFiles[join(root, fi)] = join(root, fi).split(".")[-1] if "." not in fi: ext = "noExt" else: ext = join(root, fi).split(".")[-1][0:15] print(ext) locOld = '/'.join(root.split("/")[3:]) #handled shortcut and hidden autosaved files if ext not in shortcutExt and "~$" not in fi[0:3]: # extensions.append(ext) newFolder = "" for key in fileExtensions: if ext in fileExtensions[key]: newFolder = os.path.join(os.path.join(os.environ['HOME']), 'Documents/Desktop Files/'+key) if not os.path.exists(newFolder): os.makedirs(newFolder) move(join(root, fi),join(newFolder,fi)) rollback.append([join(newFolder,fi),join(root, fi)]) print([join(newFolder,fi),join(root, fi)]) locNew = '/'.join(newFolder.split("/")[5:]) result.add_row([fi,locOld,locNew]) rowCount = rowCount + 1 except Exception as e: print (e) if rowCount == 0: # clear() print("\n\t\t\t\tFILE MANAGER\n") print("Desktop Already Cleaned\n") return 0 result.align = "r" global logHistory with open("fileManager.log", "a") as myfile: myfile.write("\nDESKTOP MOVES\n") myfile.write(str(result)) myfile.close() logHistory.append("DESKTOP MOVES\n") logHistory.append(str(result)) # clear() print("\n\t\t\t\tFILE MANAGER\n") print (result) return 1
def repurpose(X_repurpose, model, drug_names = None, result_folder = "./result/", convert_y = False, output_num_max = 10, verbose = True): # X_repurpose: a list of SMILES string fo = os.path.join(result_folder, "repurposing.txt") print_list = [] with open(fo, 'w') as fout: print('repurposing...') df_data, _, _ = data_process(X_repurpose, drug_encoding = model.drug_encoding, split_method='repurposing_VS') y_pred = model.predict(df_data) if convert_y: y_pred = convert_y_unit(np.array(y_pred), 'p', 'nM') print('---------------') if verbose: print('Drug Repurposing Result') if model.binary: table_header = ["Rank", "Drug Name", "Interaction", "Probability"] else: ### regression table_header = ["Rank", "Drug Name", "Binding Score"] table = PrettyTable(table_header) if drug_names is not None: f_d = max([len(o) for o in drug_names]) + 1 for i in range(len(X_repurpose)): if model.binary: if y_pred[i] > 0.5: string_lst = [drug_names[i], "YES", "{0:.2f}".format(y_pred[i])] else: string_lst = [drug_names[i], "NO", "{0:.2f}".format(y_pred[i])] else: #### regression #### Rank, Drug Name, Target Name, binding score string_lst = [drug_names[i], "{0:.2f}".format(y_pred[i])] string = 'Drug ' + '{:<{f_d}}'.format(drug_names[i], f_d =f_d) + \ ' predicted to have binding affinity score ' + "{0:.2f}".format(y_pred[i]) #print_list.append((string, y_pred[i])) print_list.append((string_lst, y_pred[i])) if convert_y: print_list.sort(key = lambda x:x[1]) else: print_list.sort(key = lambda x:x[1], reverse = True) print_list = [i[0] for i in print_list] for idx, lst in enumerate(print_list): lst = [str(idx + 1)] + lst table.add_row(lst) fout.write(table.get_string()) if verbose: with open(fo, 'r') as fin: lines = fin.readlines() for idx, line in enumerate(lines): if idx < 13: print(line, end = '') else: print('checkout ' + fo + ' for the whole list') break return y_pred
def viewDuplicates(hash=hashlib.sha1): clear = lambda: os.system('clear') clear() print(" ") print("\n\t\t\t\tFILE MANAGER\n") print("ALERT: TO AVOID LONG RUN ONLY \"Desktop,Downloads,Music and Pictures\" FOLDERS WILL BE CHECKED") print(" ") paths = [] paths.append(os.path.join(os.path.join(os.environ['HOME']), 'Desktop')) paths.append(os.path.join(os.path.join(os.environ['HOME']), 'Downloads')) # paths.append(os.path.join(os.path.join(os.environ['USERPROFILE']), 'Documents')) paths.append(os.path.join(os.path.join(os.environ['HOME']), 'Music')) paths.append(os.path.join(os.path.join(os.environ['HOME']), 'Pictures')) # paths.append(os.path.join(os.path.join(os.environ['USERPROFILE']), 'Videos')) hashes = {} results = [] Sno = 1 for path in paths: for dirpath, dirnames, filenames in os.walk(path): if "." not in dirpath: for filename in filenames: try: full_path = os.path.join(dirpath, filename) hashobj = hash() for chunk in chunk_reader(open(full_path, 'rb')): hashobj.update(chunk) file_id = (hashobj.digest(), os.path.getsize(full_path)) duplicate = hashes.get(file_id, None) if duplicate: results.append([Sno,full_path,duplicate]) Sno = Sno + 1 # print ("Duplicate found: %s and %s" % (full_path, duplicate)) else: hashes[file_id] = full_path except: continue if len(results) == 0: print("No Duplicate Found :)") else: result = PrettyTable(["Sno","(Same File)First Location","(Same File)Second Location"]) result.align = "r" # print (results) for row in results: result.add_row(row) print(result) print("ENTER FILENO(Sno) TO DELETE ANY DUPLICATE FILE") print("PRESS 0 TO GO BACK") try: num = int(input()) if num > len(results): print("ENTER CORRECT NUMBER") except: print("ENTER NUMBER ONLY") if num==0: print(" ") return # print(results[num-1][1]) print("PRESS 1 TO CONFIRM DELETE(PERMANENT)") print("PRESS 2 TO CANCEL AND MOVE BACK") if int(input())==1: os.remove(results[num-1][1]) result = result.del_row(num-1) print("FILE REMOVED") return 1 else: print(" ") return 0
from sklearn.naive_bayes import BernoulliNB from sklearn.metrics import accuracy_score # Multinomial Naive Bayes nb = MultinomialNB() # Logistic Regression lreg = LogisticRegression() # SVM svc = LinearSVC() # perform TF.IDF conversion tfidf = TfidfVectorizer() t0 = PrettyTable(['','Multinomial Naive Bayes','Logistic Regression','Support Vector Machines']) t1 = PrettyTable(['','Multinomial Naive Bayes','Logistic Regression','Support Vector Machines']) t2 = PrettyTable(['','Multinomial Naive Bayes','Logistic Regression','Support Vector Machines']) t3 = PrettyTable(['','Multinomial Naive Bayes','Logistic Regression','Support Vector Machines']) # ###################################################################################################################### # WITHOUT STOPWORD REMOVAL # ###################################################################################################################### reviews = pandas.read_csv("without_stopwords.csv") df = pandas.DataFrame(reviews) df.dropna(inplace = True) # fetch 'score' and 'summary' of the review X = df[['Summary']] y = df[['Score']]
auth = OAuthHandler( CONSUMER_KEY, CONSUMER_SECRET ) auth.set_access_token( OAUTH_TOKEN, OAUTH_TOKEN_SECRET ) api = tweepy.API( auth ) count = 50 query = 'Weather' # Get all tweet for the seach query results = [status for status in tweepy.Cursor(api.search, q=query).items(count)] status_texts = [ status._json['text'] for status in results ] screen_names = [ status._json['user']['screen_name'] for status in results for mention in status._json['entities']['user_mentions'] ] hashtags = [ hashtag['text'] for status in results for hashtag in status._json['entities']['hashtags'] ] words = [ w for t in status_texts for w in t.split() ] for label, data in (('Text', status_texts), ('Screen Name', screen_names), ('Word', words)): table = PrettyTable(field_names=[label, 'Count']) counter = Counter(data) [ table.add_row(entry) for entry in counter.most_common()[:10] ] table.align[label], table.align['Count'] = '1', 'r' #align the columns print table
def format_balance(coeffs): coeffs = [int(x) for x in coeffs] mols = R.molecule_names() table = PrettyTable(field_names=mols) table.add_row(coeffs) return str(table)
print(json.dumps(screen_names[0:5], indent=1)) print(json.dumps(hashtags[0:5], indent=1)) print(json.dumps(words[0:5], indent=1)) from collections import Counter for item in [words, screen_names, hashtags]: c = Counter(item) print(c.most_common()[:10]) # top 10 print() from prettytable import PrettyTable for label, data in (('Word', words), ('Screen Name', screen_names), ('Hashtag', hashtags)): pt = PrettyTable(field_names=[label, 'Count']) c = Counter(data) [pt.add_row(kv) for kv in c.most_common()[:10]] pt.align[label], pt.align['Count'] = 'l', 'r' # Set column alignment print(pt) # A function for computing lexical diversity def lexical_diversity(tokens): return len(set(tokens)) / len(tokens) # A function for computing the average number of words per tweet def average_words(statuses): total_words = sum([len(s.split()) for s in statuses]) return total_words / len(statuses)
def usage(): print "Usage: python gen_sp500_report.py <format>" if len(sys.argv) > 1: format = sys.argv[1] else: format = "text" con = lite.connect('ingest.db') col_names = [ 'Company Name', 'Number of Issues', 'Number of Common Stocks', 'Number of Notes' ] pt = PrettyTable(col_names) with con: cur = con.cursor() cur.execute("select company from sp500_companies") rows = cur.fetchall() companies = [row[0] for row in rows] companies.sort() for company in companies: cur.execute( "select count(*) from valid_items where issuer_name = :CompanyName", {'CompanyName': company}) row = cur.fetchone() num_issues = row[0]
#Script to automate Logging, SNMP and NTP configuration on IOS XE devices. import json import csv from getpass import getpass from prettytable import PrettyTable from ntp import ntp from snmp import snmp from syslog import syslog # Enter credentials via Prompt username = input("Username: "******"Password: "******"1", "NTP"]) menu.add_row(["2", "SNMP"]) menu.add_row(["3", "LOGGING"]) print(menu) choice = int(input("Please select an option: ")) #Replace the following directory with personal directory where the script is located. with open('/Users/amanueli/Documents/DevNet/Scripts/DevNet/SNMP_NTP_SYSLOG/devices.csv', mode='r') as csv_file: #Reading CSV file csv_reader = csv.DictReader(csv_file) line_count = 0 for row in csv_reader: #Setting up variables ip_addr = row["ipaddr"] restconf_port= row["port"]
""" __license__ = "Apache 2.0" #!/usr/bin/python # -*- coding: utf-8 -*- import requests import time import sys from datetime import datetime from datetimerange import DateTimeRange from planet.api.auth import find_api_key from prettytable import PrettyTable x = PrettyTable() try: PL_API_KEY = find_api_key() except Exception as e: print("Failed to get Planet Key") sys.exit() SESSION = requests.Session() SESSION.auth = (PL_API_KEY, "") def handle_page(page, start, end): for things in page["orders"]: s = datetime.strptime(things["created_on"].split("T")[0], "%Y-%m-%d") if s in DateTimeRange(start, end): try:
def setUpClass(self): #入参 self.userID = '132316' self.AccountIndex = 4 #连接beta环境的MongoDB mongoUrl = "mongodb://%s:%s@%s" % (statisticData["mongo_userName"], statisticData["mongo_passwd"], statisticData["mongo_host"]) mongoDB = FMCommon.mongoDB_operater_data( host=mongoUrl, port=statisticData["mongo_port"]) #获取MT4账号 self.mt4Account = Statistic.getMt4Account(userID=str(self.userID), accountIndex=str( self.AccountIndex)) print(self.mt4Account) '''获取个人展示页的月分析报告数据''' self.profitAndLossAnalysis = Datastatistic.getProfitAndLossAnalysis( webAPIData['hostName'] + datastatisticData['getProfitAndLossAnalysis_url'] + str(self.userID) + "_" + str(self.AccountIndex) + datastatisticData["getProfitAndLossAnalysis_url2"], params="timeType=TimeTypeWeek", printLogs=0) # self.assertEqual(monthAnalysisReport.status_code, webAPIData['status_code_200']) self.weekList = [] self.moneyList = [] self.moneyProfitLongList = [] self.moneyLossLongList = [] self.moneyProfitShortList = [] self.moneyLossShortList = [] self.pipsList = [] self.pipsProfitLongList = [] self.pipsLossLongList = [] self.pipsProfitShortList = [] self.pipsLossShortList = [] self.standardLotsLongList = [] self.standardLotsShortList = [] self.money_close_MongoList = [] for self.item in json.loads( self.profitAndLossAnalysis.text)["data"]["HourAndWeekList"]: #遍历返回数据的所有周 self.weekList.append(self.item["Week"]) #遍历返回数据的所有收益 self.moneyList.append(self.item["Money"]) #遍历返回数据的所有做多盈利收益 self.moneyProfitLongList.append(self.item["MoneyProfitLong"]) #遍历返回数据的所有做多亏损收益 self.moneyLossLongList.append(self.item["MoneyLossLong"]) #遍历返回数据的所有做空盈利收益 self.moneyProfitShortList.append(self.item["MoneyProfitShort"]) #遍历返回数据的所有做空亏损收益 self.moneyLossShortList.append(self.item["MoneyLossShort"]) #遍历返回数据的所有点数 self.pipsList.append(self.item["Pips"]) #遍历返回数据的所有做多盈利点数 self.pipsProfitLongList.append(self.item["PipsProfitLong"]) #遍历返回数据的所有做多亏损点数 self.pipsLossLongList.append(self.item["PipsLossLong"]) #遍历返回数据的所有做空盈利点数 self.pipsProfitShortList.append(self.item["PipsProfitShort"]) #遍历返回数据的所有做空亏损点数 self.pipsLossShortList.append(self.item["PipsLossShort"]) #遍历返回数据的所有做多手数 self.standardLotsLongList.append(self.item["StandardLotsLong"]) #遍历返回数据的所有做空手数 self.standardLotsShortList.append(self.item["StandardLotsShort"]) # #转换时间戳,把时间戳转换为时间 # timeStamp = int(self.item["Month"]) # timeArray = time.localtime(timeStamp) # otherStyleMonth = time.strftime("%Y-%m", timeArray) # print(otherStyleMonth) self.money_close_MongoList = [] self.money_profit_long_close_MongoList = [] self.money_loss_long_close_MongoList = [] self.money_profit_short_close_MongoList = [] self.money_loss_short_close_MongoList = [] self.money_loss_long_close_MongoList = [] self.point_close_MongoList = [] self.point_profit_long_close_MongoList = [] self.point_loss_long_close_MongoList = [] self.point_profit_short_close_MongoList = [] self.point_loss_short_close_MongoList = [] self.standardlots_long_close_MongoList = [] self.standardlots_short_close_MongoList = [] # for i in mongoDB.fm.mg_result_Week.find({"_id":str(self.mt4Account) + "_" + str(self.brokerid) + str(otherStyleMonth) + str(self.item["Week"])}): for i in mongoDB.datastatistic.mg_result_week.find({ "login": str(self.mt4Account), "close_week": self.item["Week"] }): self.mongoList = {} for key in statisticData["mongoKeyListAll"]: try: value = i[key] except KeyError: value = statisticData["keyErr"] self.mongoList[key] = value #获取MongoDB的平仓收益 self.money_close_MongoList.append( self.mongoList["money_close"]) # print("888888888888") # print(self.mongoList["money_close"]) #获取MongoDB的平仓做多盈利收益 self.money_profit_long_close_MongoList.append( self.mongoList["money_profit_long_close"]) #获取MongoDB的平仓做多亏损收益 self.money_loss_long_close_MongoList.append( self.mongoList["money_loss_long_close"]) #获取MongoDB的平仓做空盈利收益 self.money_profit_short_close_MongoList.append( self.mongoList["money_profit_short_close"]) #获取MongoDB的平仓做空亏损收益 self.money_loss_short_close_MongoList.append( self.mongoList["money_loss_short_close"]) #获取MongoDB的平仓点数 self.point_close_MongoList.append( self.mongoList["point_close"]) #获取MongoDB的平仓做多盈利点数 self.point_profit_long_close_MongoList.append( self.mongoList["point_profit_long_close"]) #获取MongoDB的平仓做多亏损点数 self.point_loss_long_close_MongoList.append( self.mongoList["point_loss_long_close"]) #获取MongoDB的平仓做空盈利点数 self.point_profit_short_close_MongoList.append( self.mongoList["point_profit_short_close"]) #获取MongoDB的平仓做空亏损点数 self.point_loss_short_close_MongoList.append( self.mongoList["point_loss_short_close"]) #获取MongoDB的平仓所有做多手数 self.standardlots_long_close_MongoList.append( self.mongoList["standardlots_long_close"]) #获取MongoDB的平仓所有做空手数 self.standardlots_short_close_MongoList.append( self.mongoList["standardlots_short_close"]) table_1 = PrettyTable([ "预期/实际", "UserID", "AccountIndex", "MT4Account", "周", "平仓收益", "平仓做多盈利收益", "平仓做多亏损收益", "平仓做空盈利收益", "平仓做空亏损收益", "做多手数" ]) table_2 = PrettyTable([ "预期/实际", "UserID", "AccountIndex", "MT4Account", "周", "平仓点数", "平仓做多盈利点数", "平仓做多亏损点数", "平仓做空盈利点数", "平仓做空亏损点数", "做空手数" ]) try: table_1.add_row([ "预期结果", self.userID, self.AccountIndex, self.mt4Account, self.item["Week"], self.mongoList["money_close"], self.mongoList["money_profit_long_close"], self.mongoList["money_loss_long_close"], self.mongoList["money_profit_short_close"], self.mongoList["money_loss_short_close"], self.mongoList["standardlots_long_close"] ]) table_1.add_row([ "实际结果", self.userID, self.AccountIndex, self.mt4Account, self.item["Week"], self.item["Money"], self.item["MoneyProfitLong"], self.item["MoneyLossLong"], self.item["MoneyProfitShort"], self.item["MoneyLossShort"], self.item["StandardLotsLong"] ]) table_1.add_row(["", "", "", "", "", "", "", "", "", "", ""]) table_2.add_row([ "预期结果", self.userID, self.AccountIndex, self.mt4Account, self.item["Week"], self.mongoList["point_close"], self.mongoList["point_profit_long_close"], self.mongoList["point_loss_long_close"], self.mongoList["point_profit_short_close"], self.mongoList["point_loss_short_close"], self.mongoList["standardlots_short_close"] ]) table_2.add_row([ "实际结果", self.userID, self.AccountIndex, self.mt4Account, self.item["Week"], self.item["Pips"], self.item["PipsProfitLong"], self.item["PipsLossLong"], self.item["PipsProfitShort"], self.item["PipsLossShort"], self.item["StandardLotsShort"] ]) table_2.add_row(["", "", "", "", "", "", "", "", "", "", ""]) finally: table_1.reversesort = True table_2.reversesort = True print(table_1) print(table_2)
def Analyzer(): # Creating tables allFuncs = 0 tables = PrettyTable() peStatistics = PrettyTable() dllTable = PrettyTable() resTable = PrettyTable() statistics = PrettyTable() # categorizing extracted strings for win_api in allStrings: for key in regdict: if win_api[0] in regdict[key]: if win_api[0] != "": dictCateg[key].append(win_api) allFuncs += 1 # printing categorized strings import_indicator = 0 for key in dictCateg: if dictCateg[key] != []: # More important categories if key == "Keyboard/Keylogging" or key == "Evasion/Bypassing" or key == "System/Persistence" or key == "Cryptography" or key == "Information Gathering": print( f"\n{yellow}[{red}!{yellow}]__WARNING__[{red}!{yellow}]{white}" ) # Printing zone tables.field_names = [ f"Functions or Strings about {green}{key}{white}", "Address" ] for func in dictCateg[key]: if func[0] == "": pass else: tables.add_row( [f"{red}{func[0]}{white}", f"{red}{func[1]}{white}"]) import_indicator += 1 # Logging for summary table if key == "Registry": scoreDict[key] += 1 elif key == "File": scoreDict[key] += 1 elif key == "Networking/Web": scoreDict[key] += 1 elif key == "Keyboard/Keylogging": scoreDict[key] += 1 elif key == "Process": scoreDict[key] += 1 elif key == "Memory Management": scoreDict[key] += 1 elif key == "Dll/Resource Handling": scoreDict[key] += 1 elif key == "Evasion/Bypassing": scoreDict[key] += 1 elif key == "System/Persistence": scoreDict[key] += 1 elif key == "COMObject": scoreDict[key] += 1 elif key == "Cryptography": scoreDict[key] += 1 elif key == "Information Gathering": scoreDict[key] += 1 elif key == "Other/Unknown": scoreDict[key] += 1 else: pass print(tables) tables.clear_rows() # If there is no function imported in target executable if import_indicator == 0: print(f"{errorS} There is no function/API imports found.") print( f"{magenta}>>{white} Try '{green}--packer{white}' or '{green}--lang{white}' to see additional info about target file.\n" ) # gathering extracted dll files try: dllTable.field_names = [f"Linked {green}DLL{white} Files"] for items in binaryfile.DIRECTORY_ENTRY_IMPORT: dlStr = str(items.dll.decode()) dllTable.add_row([f"{red}{dlStr}{white}"]) print(dllTable) except: pass # Yara rule match print(f"\n{infoS} Performing YARA rule matching...") WindowsYara(target_file=fileName) # Resource scanner zone print(f"\n{infoS} Performing magic number analysis...") resCounter = 0 resTable.field_names = [ f"File Extensions", "Names", "Byte Matches", "Confidence" ] resourceList = list(pr.magic_file(fileName)) for res in range(0, len(resourceList)): extrExt = str(resourceList[res].extension) extrNam = str(resourceList[res].name) extrByt = str(resourceList[res].byte_match) if resourceList[res].confidence >= 0.4: resCounter += 1 if extrExt == '': resTable.add_row([ f"{red}No Extension{white}", f"{red}{extrNam}{white}", f"{red}{extrByt}{white}", f"{red}{resourceList[res].confidence}{white}" ]) else: resTable.add_row([ f"{red}{extrExt}{white}", f"{red}{extrNam}{white}", f"{red}{extrByt}{white}", f"{red}{resourceList[res].confidence}{white}" ]) if len(resourceList) != 0: print(resTable) # Assembly and pe structure analysis zone print( f"\n{infoS} Performing PE file structure and assembly code analysis...\n" ) # Gathering information about sections peStatistics.field_names = [ "Section Name", "Virtual Size", "Virtual Address", "Size Of Raw Data", "Pointer to Raw Data", "Entropy" ] pe = pf.PE(fileName) # Parsing timedatestamp data mydict = pe.dump_dict() tempstr = mydict["FILE_HEADER"]["TimeDateStamp"]["Value"][11:].replace( "[", "") datestamp = tempstr.replace("]", "") # Parsing sections for sect in pe.sections: if sect.get_entropy() >= 7: peStatistics.add_row([ sect.Name.decode().rstrip('\x00'), hex(sect.Misc_VirtualSize), hex(sect.VirtualAddress), hex(sect.SizeOfRawData), hex(sect.PointerToRawData), f"{red}{sect.get_entropy()}{white} (Possible obfuscation!!)" ]) else: peStatistics.add_row([ sect.Name.decode().rstrip('\x00'), hex(sect.Misc_VirtualSize), hex(sect.VirtualAddress), hex(sect.SizeOfRawData), hex(sect.PointerToRawData), sect.get_entropy() ]) print(f"{magenta}>>{white} Time Date Stamp: {green}{datestamp}{white}") print(peStatistics) # Statistics zone print(f"\n{green}->{white} Statistics for: {green}{fileName}{white}") # printing all function statistics statistics.field_names = ["Categories", "Number of Functions or Strings"] statistics.add_row( [f"{green}All Functions{white}", f"{green}{allFuncs}{white}"]) for key in scoreDict: if scoreDict[key] == 0: pass else: if key == "Keyboard/Keylogging" or key == "Evasion/Bypassing" or key == "System/Persistence" or key == "Cryptography" or key == "Information Gathering": statistics.add_row( [f"{yellow}{key}{white}", f"{red}{scoreDict[key]}{white}"]) else: statistics.add_row( [f"{white}{key}", f"{scoreDict[key]}{white}"]) print(statistics) # Warning about obfuscated file if allFuncs < 20: print( f"\n{errorS} This file might be obfuscated or encrypted. Try {green}--packer{white} to scan this file for packers." ) print( f"{errorS} You can also use {green}--hashscan{white} to scan this file.\n" ) sys.exit(0)
def process_integration(_args): # Parse YAML file with input data with open(_args.source, 'r') as stream: try: config = yaml.safe_load(stream) except yaml.YAMLError as e: print(e) return # Modules required by Python expressions in assignments modules = ['math'] # Store YAML data n variables fun = wrap_code(str(config.get('fun', '')), modules) antiderivative = config.get('antiderivative', None) domain = config.get('domain', {}) a = wrap_code(str(domain.get('a', 0)), modules)(0) b = wrap_code(str(domain.get('b', 0)), modules)(0) integration = config.get('integration', {}) method = integration.get('method', 'midpoint') step = wrap_code(str(integration.get('step', '0')), modules)(0) estimation = integration.get('estimation', {}) auto_estimation = estimation.get('auto', False) precision = wrap_code(str(estimation.get('precision', '0')), modules)(0) # Bind method names to corresponding functions methods = { 'midpoint': integrate_by_midpoints, 'trapezoid': integrate_by_trapezoids, 'simpson': integrate_by_parabolas } # Bind method names to precision order precision_order = {'midpoint': 2, 'trapezoid': 2, 'simpson': 4} points = np.arange(a, b + step, step) # Compile antiderivative to bytecode if it isn't None and compute a correct integral antiderivative_fun = compute_or_null(antiderivative, lambda x: wrap_code(x, modules)) correct_integral = compute_or_null(antiderivative_fun, lambda x: x(b) - x(a)) if auto_estimation: # Computations with automatic step table = PrettyTable([ 'method', 'eps', 'uniform steps count', 'steps count', 'correct', 'approximate', 'delta' ]) def append_row(_method_name, _method_fun): # Bind f(x) to quadrature method_integral = partial(_method_fun, fun) # Compute optimal grid for given integral with given precision grid = calculate_grid(method_integral, points, a, b, precision, precision_order[_method_name]) # Compute integral numerically approximate_integral = _method_fun(fun, grid) # Add row to the table table.add_row([ _method_name, # Method of integration precision, # Precision of table len(points) - 1, # Count of segments in original grid len(grid) - 1, # Count of segments in optimal grid correct_integral, # Correct value of integral approximate_integral, # Approximate value of integral compute_or_null(correct_integral, lambda x: abs( x - approximate_integral)) # | correct - approx | ]) if method == 'all': # Calculate report for all methods for m in methods: append_row(m, methods[m]) else: # Calculate report for one method append_row(method, methods[method]) print(table) else: # Computation with constant step table = PrettyTable( ['method', 'step', 'correct', 'approximate', 'delta']) def append_row(_method_name, _method_fun): # Compute integral numerically approximate_integral = _method_fun(fun, points) table.add_row([ _method_name, # Method of integration step, # Grid step correct_integral, # Correct value of integral approximate_integral, # Approximate value of integral compute_or_null(correct_integral, lambda x: abs( x - approximate_integral)) # |correct - approx | ]) if method == 'all': # Calculate reports for all methods for m in methods: append_row(m, methods[m]) else: # Calculate report for one method append_row(method, methods[method]) print(table)
import math from prettytable import PrettyTable table = PrettyTable() a = [[4, -1, 0, 3], [1, 15.5, 3, 8], [0, -1.3, -4, 1.1], [14, 5, -2, 30]] n = len(a) iters = [] major = [] initialValues = [0, 0, 0, 0] totalResult = [[] for y in range(len(initialValues))] relaxed = 1 def calculateNewJacobi(x0): x = [] for i in range(0, n): sum = 0 for j in range(0, n): if (j != i): sum = sum + a[i][j] * x0[j] value = (relaxed * ((a[i][n - 1] - sum) / a[i][i])) + (1 - relaxed) * x0[i] x.append(value) totalResult[i].append(value) return x def norm(x): return max([math.fabs(x) for x in x])
right_table=soup.find('span', class_='next swap') tommorrow = str(right_table.encode("utf-8")) tommorrow = tommorrow[50:-11] tommorrow = tommorrow.replace("\\xc2\\xa0", " ") tommorrow = tommorrow.replace(".\\n", " ") right_table=soup.find('div', class_='summary') week = str(right_table.encode("utf-8")) week = week[35:-11] week = week.replace("\\xc2\\xb0", "\xb0") week = week.replace(".\\n", " ") from prettytable import PrettyTable t = PrettyTable(['today', weather]) t.add_row(['UVindex', UVindex]) t.add_row(['humidity', humidity]) t.add_row(['dewpoint', dewpoint]) t.add_row(['pressure', pressure]) t.add_row(['feels like', feels]) t.add_row(['high', high]) t.add_row(['low', low]) print(t) from tkinter import * def printSomething(): # if you want the button to disappear: # button.destroy() or button.pack_forget()