hexsha
stringlengths
40
40
size
int64
5
2.06M
ext
stringclasses
10 values
lang
stringclasses
1 value
max_stars_repo_path
stringlengths
3
248
max_stars_repo_name
stringlengths
5
125
max_stars_repo_head_hexsha
stringlengths
40
78
max_stars_repo_licenses
listlengths
1
10
max_stars_count
int64
1
191k
max_stars_repo_stars_event_min_datetime
stringlengths
24
24
max_stars_repo_stars_event_max_datetime
stringlengths
24
24
max_issues_repo_path
stringlengths
3
248
max_issues_repo_name
stringlengths
5
125
max_issues_repo_head_hexsha
stringlengths
40
78
max_issues_repo_licenses
listlengths
1
10
max_issues_count
int64
1
67k
max_issues_repo_issues_event_min_datetime
stringlengths
24
24
max_issues_repo_issues_event_max_datetime
stringlengths
24
24
max_forks_repo_path
stringlengths
3
248
max_forks_repo_name
stringlengths
5
125
max_forks_repo_head_hexsha
stringlengths
40
78
max_forks_repo_licenses
listlengths
1
10
max_forks_count
int64
1
105k
max_forks_repo_forks_event_min_datetime
stringlengths
24
24
max_forks_repo_forks_event_max_datetime
stringlengths
24
24
content
stringlengths
5
2.06M
avg_line_length
float64
1
1.02M
max_line_length
int64
3
1.03M
alphanum_fraction
float64
0
1
count_classes
int64
0
1.6M
score_classes
float64
0
1
count_generators
int64
0
651k
score_generators
float64
0
1
count_decorators
int64
0
990k
score_decorators
float64
0
1
count_async_functions
int64
0
235k
score_async_functions
float64
0
1
count_documentation
int64
0
1.04M
score_documentation
float64
0
1
dfb68a5201db3b2abf55a2e729e1d1531d27950c
77
py
Python
src/buildercore/external.py
elifesciences/builder
161829686f777f7ac7f97bd970395886ba5089c1
[ "MIT" ]
11
2017-03-01T18:00:30.000Z
2021-12-10T05:11:02.000Z
src/buildercore/external.py
elifesciences/builder
161829686f777f7ac7f97bd970395886ba5089c1
[ "MIT" ]
397
2016-07-08T14:39:46.000Z
2022-03-30T12:45:09.000Z
src/buildercore/external.py
elifesciences/builder
161829686f777f7ac7f97bd970395886ba5089c1
[ "MIT" ]
14
2016-07-13T08:33:28.000Z
2020-04-22T21:42:21.000Z
import subprocess def execute(cmd): return subprocess.check_output(cmd)
15.4
39
0.779221
0
0
0
0
0
0
0
0
0
0
dfb696c1a314cee61ccd51a38771b72300f8407a
648
py
Python
Round 2/data_packing.py
kamyu104/GoogleCodeJam-2014
ff29a677f502168eb0b92d6928ad6983d2622017
[ "MIT" ]
10
2016-04-10T22:50:54.000Z
2021-04-17T18:17:02.000Z
Round 2/data_packing.py
kamyu104/GoogleCodeJam-2014
ff29a677f502168eb0b92d6928ad6983d2622017
[ "MIT" ]
null
null
null
Round 2/data_packing.py
kamyu104/GoogleCodeJam-2014
ff29a677f502168eb0b92d6928ad6983d2622017
[ "MIT" ]
10
2016-07-19T08:43:38.000Z
2021-07-22T22:38:44.000Z
# Copyright (c) 2021 kamyu. All rights reserved. # # Google Code Jam 2014 Round 2 - Problem A. Data Packing # https://codingcompetitions.withgoogle.com/codejam/round/0000000000432fed/0000000000432b8d # # Time: O(NlogN) # Space: O(1) # def data_packing(): N, X = map(int, raw_input().strip().split()) S = map(int, raw_input().strip().split()) S.sort() result = 0 left, right = 0, len(S)-1 while left <= right: if left < right and S[left]+S[right] <= X: left += 1 right -= 1 result += 1 return result for case in xrange(input()): print 'Case #%d: %s' % (case+1, data_packing())
24.923077
91
0.598765
0
0
0
0
0
0
0
0
242
0.373457
dfb71ae9c49c8ec75050dd6031ca98dd54f66f9f
18,950
py
Python
BiModNeuroCNN/training/bimodal_classification.py
cfcooney/BiModNeuroCNN
f79da6150b4186bcbc15d876394f4af8a47076d0
[ "MIT" ]
4
2020-10-31T21:20:12.000Z
2022-01-05T16:13:07.000Z
BiModNeuroCNN/training/bimodal_classification.py
cfcooney/BiModNeuroCNN
f79da6150b4186bcbc15d876394f4af8a47076d0
[ "MIT" ]
null
null
null
BiModNeuroCNN/training/bimodal_classification.py
cfcooney/BiModNeuroCNN
f79da6150b4186bcbc15d876394f4af8a47076d0
[ "MIT" ]
null
null
null
""" Description: Class for training CNNs using a nested cross-validation method. Train on the inner_fold to obtain optimized hyperparameters. Train outer_fold to obtain classification performance. """ from braindecode.datautil.iterators import BalancedBatchSizeIterator from braindecode.experiments.stopcriteria import MaxEpochs, NoDecrease, Or from braindecode.torch_ext.util import set_random_seeds, np_to_var, var_to_np from braindecode.datautil.signal_target import SignalAndTarget from braindecode.torch_ext.functions import square, safe_log import torch as th from sklearn.model_selection import train_test_split from BiModNeuroCNN.training.training_utils import current_acc, current_loss from BiModNeuroCNN.data_loader.data_utils import smote_augmentation, multi_SignalAndTarget from BiModNeuroCNN.results.results import Results as res from torch.nn.functional import nll_loss, cross_entropy from BiModNeuroCNN.training.bimodal_training import Experiment import numpy as np import itertools as it import torch from torch import optim import logging from ast import literal_eval from BiModNeuroCNN.results.metrics import cross_entropy import warnings warnings.filterwarnings("ignore", category=UserWarning) log = logging.getLogger(__name__) torch.backends.cudnn.deterministic = True class Classification: def __init__(self, model, subnet1_params, subnet2_params, hyp_params, parameters, data_params, model_save_path, tag): self.model = model self.subnet1_params = subnet1_params self.subnet2_params = subnet2_params self.model_save_path = model_save_path self.tag = tag self.best_loss = parameters["best_loss"] self.batch_size = parameters["batch_size"] self.monitors = parameters["monitors"] self.cuda = parameters["cuda"] self.model_constraint = parameters["model_constraint"] self.max_increase_epochs = parameters['max_increase_epochs'] self.lr_scheduler = parameters['learning_rate_scheduler'] self.lr_step = parameters['lr_step'] self.lr_gamma = parameters['lr_gamma'] self.n_classes = data_params["n_classes"] self.n_chans_d1 = data_params["n_chans_d1"] self.input_time_length_d1= data_params["input_time_length_d1"] self.n_chans_d2 = data_params["n_chans_d2"] self.input_time_length_d2 = data_params["input_time_length_d2"] self.hyp_params = hyp_params self.activation = "elu" self.learning_rate = 0.001 self.dropout = 0.1 self.epochs = parameters['epochs'] self.window = None self.structure = 'deep' self.n_filts = 10 #n_filts in n-1 filters self.first_pool = False self.loss = nll_loss for key in hyp_params: setattr(self, key, hyp_params[key]) self.iterator = BalancedBatchSizeIterator(batch_size=self.batch_size) self.best_params = None self.model_number = 1 self.y_pred = np.array([]) self.y_true = np.array([]) self.probabilities = np.array([]) def call_model(self): self.subnet1_params['structure'] = self.structure self.subnet2_params['structure'] = self.structure if self.model.__name__ == 'BiModalNet': model = self.model(n_classes=self.n_classes, in_chans_1=self.n_chans_d1, input_time_1=self.input_time_length_d1, SubNet_1_params=self.subnet1_params, in_chans_2=self.n_chans_d2, input_time_2=self.input_time_length_d2, SubNet_2_params=self.subnet2_params, linear_dims=100, drop_prob=.2, nonlin=torch.nn.functional.leaky_relu, fc1_out_features=500, fc2_out_features=500, gru_hidden_size=250, gru_n_layers=1) th.nn.init.kaiming_uniform_(model.fused_linear.weight) th.nn.init.constant_(model.fused_linear.bias, 0) elif self.model.__name__ == 'BiModalNet_w_Pool': model = self.model(n_classes=self.n_classes, in_chans_1=self.n_chans_d1, input_time_1=self.input_time_length_d1, SubNet_1_params=self.subnet1_params, in_chans_2=self.n_chans_d2, input_time_2=self.input_time_length_d2, SubNet_2_params=self.subnet2_params, linear_dims=100, drop_prob=.2, nonlin=torch.nn.functional.leaky_relu, fc1_out_features=500, fc2_out_features=500, gru_hidden_size=250, gru_n_layers=1) th.nn.init.kaiming_uniform_(model.fused_linear.weight) th.nn.init.constant_(model.fused_linear.bias, 0) return model def train_model(self, train_set_1, val_set_1, test_set_1, train_set_2, val_set_2, test_set_2, save_model): """ :param train_set_1: (np.array) n_trials*n_channels*n_samples :param val_set_1: (np.array) n_trials*n_channels*n_samples :param test_set_1: (np.array) n_trials*n_channels*n_samples - can be None when training on inner-fold :param train_set_2: (np.array) n_trials*n_channels*n_samples :param val_set_2: (np.array) n_trials*n_channels*n_samples :param test_set_2: (np.array) n_trials*n_channels*n_samples - can be None when training on inner-fold :param save_model: (Bool) True if trained model is to be saved :return: Accuracy and loss scores for the model trained with a given set of hyper-parameters """ model = self.call_model() predictions = None set_random_seeds(seed=20190629, cuda=self.cuda) if self.cuda: model.cuda() torch.backends.cudnn.deterministic = True model = torch.nn.DataParallel(model) log.info(f"Cuda in use") log.info("%s model: ".format(str(model))) optimizer = optim.Adam(model.parameters(), lr=self.learning_rate, weight_decay=0.01, eps=1e-8, amsgrad=False) stop_criterion = Or([MaxEpochs(self.epochs), NoDecrease('valid_loss', self.max_increase_epochs)]) model_loss_function = None #####Setup to run the selected model##### model_test = Experiment(model, train_set_1, val_set_1, train_set_2, val_set_2, test_set_1=test_set_1, test_set_2=test_set_2, iterator=self.iterator, loss_function=self.loss, optimizer=optimizer, lr_scheduler=self.lr_scheduler(optimizer, step_size=self.lr_step, gamma=self.lr_gamma), model_constraint=self.model_constraint, monitors=self.monitors, stop_criterion=stop_criterion, remember_best_column='valid_misclass', run_after_early_stop=True, model_loss_function=model_loss_function, cuda=self.cuda, save_file=self.model_save_path, tag=self.tag, save_model=save_model) model_test.run() model_acc = model_test.epochs_df['valid_misclass'].astype('float') model_loss = model_test.epochs_df['valid_loss'].astype('float') current_val_acc = 1 - current_acc(model_acc) current_val_loss = current_loss(model_loss) test_accuracy = None if train_set_1 is not None and test_set_2 is not None: val_metric_index = self.get_model_index(model_test.epochs_df) test_accuracy = round((1 - model_test.epochs_df['test_misclass'].iloc[val_metric_index]) * 100, 3) predictions = model_test.model_predictions probabilities = model_test.model_probabilities return current_val_acc, current_val_loss, test_accuracy, model_test, predictions, probabilities def train_inner(self, train_set_1, val_set_1, train_set_2, val_set_2, test_set_1=None, test_set_2=None, augment=False, save_model=False): """ :param train_set_1: (np.array) n_trials*n_channels*n_samples :param val_set_1: (np.array) n_trials*n_channels*n_samples :param test_set_1: (np.array) n_trials*n_channels*n_samples - can be None when performing HP optimization :param train_set_2: (np.array) n_trials*n_channels*n_samples :param val_set_2: (np.array) n_trials*n_channels*n_samples :param test_set_2: (np.array) n_trials*n_channels*n_samples - can be None when performing HP optimization :param augment: (Bool) True if data augmentation to be applied - currently only configured for SMOTE augmentation :param save_model: (Bool) True if trained model is to be saved :return: Accuracy, loss and cross entropy scores for the model trained with a given set of hyper-parameters """ val_acc, val_loss, val_cross_entropy = [], [], [] if augment: # Only augment training data - never test or validation sets train_set_1_os, train_labels_1_os = smote_augmentation(train_set_1.X, train_set_1.y, 2) train_set_2_os, train_labels_2_os = smote_augmentation(train_set_1.X, train_set_1.y, 2) train_set_1, train_set_2 = multi_SignalAndTarget((train_set_1_os, train_labels_1_os), (train_set_2_os, train_labels_2_os)) names = list(self.hyp_params.keys()) hyp_param_combs = it.product(*(self.hyp_params[Name] for Name in names)) for hyp_combination in hyp_param_combs: assert len(hyp_combination) == len(self.hyp_params), f"HP combination must be of equal length to original set." for i in range(len(self.hyp_params)): setattr(self, list(self.hyp_params.keys())[i], hyp_combination[i]) if 'window' in self.hyp_params.keys(): # when using classification window as a hyperparameter - currently data would have to be of same number of samples train_set_1_w = SignalAndTarget(train_set_1.X[:, :, self.window[0]:self.window[1]], train_set_1.y) val_set_1_w = SignalAndTarget(val_set_1.X[:, :, self.window[0]:self.window[1]], val_set_1.y) train_set_2_w = SignalAndTarget(train_set_2.X[:, :, self.window[0]:self.window[1]], train_set_2.y) val_set_2_w = SignalAndTarget(val_set_2.X[:, :, self.window[0]:self.window[1]], val_set_2.y) current_val_acc, current_val_loss, _, _, _, probabilities = self.train_model(train_set_1_w, val_set_1_w, test_set_1, train_set_2_w, val_set_2_w, test_set_2, save_model) else: current_val_acc, current_val_loss, _, _, _, probabilities = self.train_model(train_set_1, val_set_1, test_set_1, train_set_2, val_set_2, test_set_2, save_model) val_acc.append(current_val_acc) val_loss.append(current_val_loss) probabilities = np.array(probabilities).reshape((val_set_1.y.shape[0],4)) val_cross_entropy.append(cross_entropy(val_set_1.y, probabilities)) #1 CE value per-HP, repeat for n_folds return val_acc, val_loss, val_cross_entropy def train_outer(self, trainsetlist, testsetlist, augment=False, save_model=True, epochs_save_path=None, print_details=False): """ :param trainsetlist: (list) data as split by k-folds n_folds*(n_trials*n_channels*n_samples) :param testsetlist: (list) data as split by k-folds n_folds*(n_trials*n_channels*n_samples) :param augment: (Bool) True if data augmentation to be applied - currently only configured for SMOTE augmentation :param save_model: (Bool) True if trained model is to be saved """ scores, all_preds, probabilities_list, outer_cross_entropy, fold_models = [],[],[],[],[] fold_number = 1 for train_set, test_set in zip(trainsetlist, testsetlist): train_set_1, train_set_2 = train_set[0], train_set[1] test_set_1, test_set_2 = test_set[0], test_set[1] train_set_1_X, val_set_1_X, train_set_1_y, val_set_1_y = train_test_split(train_set_1.X, train_set_1.y, test_size=0.2, shuffle=True, random_state=42, stratify= train_set_1.y) train_set_2_X, val_set_2_X, train_set_2_y, val_set_2_y = train_test_split(train_set_2.X, train_set_2.y, test_size=0.2, shuffle=True, random_state=42, stratify= train_set_2.y) train_set_1, val_set_1, train_set_2, val_set_2 = multi_SignalAndTarget((train_set_1_X, train_set_1_y), (val_set_1_X, val_set_1_y), (train_set_2_X, train_set_2_y), (val_set_2_X, val_set_2_y)) if augment: # Only augment training data - never test or validation sets train_set_1_os, train_labels_1_os = smote_augmentation(train_set_1.X, train_set_1.y, 2) train_set_2_os, train_labels_2_os = smote_augmentation(train_set_2.X, train_set_2.y, 2) train_set_1 = SignalAndTarget(train_set_1_os, train_labels_1_os) train_set_2 = SignalAndTarget(train_set_2_os, train_labels_2_os) print(train_set_1.X.shape) if 'window' in self.hyp_params.keys(): # when using classification window as a hyperparameter - currently data would have to be of same number of samples if type(self.window) == str: self.window = literal_eval(self.window) # extract tuple of indices train_set_1_w = SignalAndTarget(train_set_1.X[:,:,self.window[0]:self.window[1]], train_set_1.y) val_set_1_w = SignalAndTarget(val_set_1.X[:,:,self.window[0]:self.window[1]], val_set_1.y) test_set_1_w = SignalAndTarget(test_set_1.X[:,:,self.window[0]:self.window[1]], test_set_1.y) train_set_2_w = SignalAndTarget(train_set_2.X[:,:,self.window[0]:self.window[1]], train_set_2.y) val_set_2_w = SignalAndTarget(val_set_2.X[:,:,self.window[0]:self.window[1]], val_set_2.y) test_set_2_w = SignalAndTarget(test_set_2.X[:, :, self.window[0]:self.window[1]], test_set_2.y) _, _, test_accuracy, optimised_model, predictions, probabilities = self.train_model(train_set_1_w, val_set_1_w, test_set_1_w, train_set_2_w, val_set_2_w, test_set_2_w, save_model) if print_details: print(f"Data 1 train set: {train_set_1.y.shape} | Data 1 val_set: {val_set_1.y.shape} | Data 1 test_set: {test_set_1.y.shape}") print(f"Data 2 train set: {train_set_2.y.shape} | Data 2 val_set: {val_set_2.y.shape} | Data 2 test_set: {test_set_2.y.shape}") else: _, _, test_accuracy, optimised_model, predictions, probabilities = self.train_model(train_set_1, val_set_1, test_set_1, train_set_2, val_set_2, test_set_2, save_model) if epochs_save_path != None: try: optimised_model.epochs_df.to_excel(f"{epochs_save_path}/epochs{fold_number}.xlsx") except FileNotFoundError: optimised_model.epochs_df.to_excel(f"{epochs_save_path}/epochs{fold_number}.xlsx", engine='xlsxwriter') fold_models.append(optimised_model) probs_array = [] for lst in probabilities: for trial in lst: probs_array.append(trial) # all probabilities for this test-set probabilities_list.append(probs_array) #outer probabilities to be used for cross-entropy print(f"/"*20) scores.append(test_accuracy) self.concat_y_pred(predictions) self.concat_y_true(test_set_1.y) fold_number += 1 for y_true, y_probs in zip(testsetlist, probabilities_list): outer_cross_entropy.append(cross_entropy(y_true[0].y, y_probs)) return scores, fold_models, self.y_pred, probabilities_list, outer_cross_entropy, self.y_true def set_best_params(self): """ Set optimal hyperparameter values selected from optimization - Best parameter values can be accessed with BiModNeuroCNN.results.Results.get_best_params() and the list assigned to self.best_params. """ assert type(self.best_params) is list, "list of selected parameters required" for i in range(len(self.hyp_params)): setattr(self, list(self.hyp_params.keys())[i], self.best_params[i]) @staticmethod def get_model_index(df): """ Returns the row index of a pandas dataframe used for storing epoch-by-epoch results. :param df: pandas.DataFrame :return: int index of the selected epoch based on validation metric """ valid_metric_index = df['valid_misclass'].idxmin() best_val_acc = df.index[df['valid_misclass'] == df['valid_misclass'].iloc[valid_metric_index]] previous_best = 1.0 i = 0 for n, index in enumerate(best_val_acc): value = df['test_misclass'][index] if value < previous_best: previous_best = value i = n return best_val_acc[i] def concat_y_pred(self, y_pred_fold): """ Method for combining all outer-fold ground-truth values. :param y_pred_fold: array of single-fold true values. :return: all outer fold true values in single arrau """ self.y_pred = np.concatenate((self.y_pred, np.array(y_pred_fold))) def concat_y_true(self, y_true_fold): """ Method for combining all outer-fold ground-truth values. :param y_true_fold: array of single-fold true values. :return: all outer fold true values in single arrau """ self.y_true = np.concatenate((self.y_true, np.array(y_true_fold))) def concat_probabilities(self, probabilities_fold): """ Method for combining all outer-fold ground-truth values. :param y_pred_fold: array of single-fold true values. :return: all outer fold true values in single arrau """ self.probabilities = np.concatenate((self.probabilities, probabilities_fold))
57.95107
154
0.644063
17,628
0.930237
0
0
716
0.037784
0
0
4,701
0.248074
dfb822e8f7cafa7cb423cc71ade94b740d42328b
7,462
py
Python
simple_task_repeater/str_app.py
lavrpetrov/simple-task-repeater
cd56ed52143ac31171fc757c6e1f7740bebe1ed4
[ "MIT" ]
null
null
null
simple_task_repeater/str_app.py
lavrpetrov/simple-task-repeater
cd56ed52143ac31171fc757c6e1f7740bebe1ed4
[ "MIT" ]
null
null
null
simple_task_repeater/str_app.py
lavrpetrov/simple-task-repeater
cd56ed52143ac31171fc757c6e1f7740bebe1ed4
[ "MIT" ]
1
2021-04-20T15:38:44.000Z
2021-04-20T15:38:44.000Z
import datetime from collections import Counter from functools import wraps from dateparser import parse as parse_date from calmlib import get_current_date, get_current_datetime, to_date, trim from .base import Task from .str_database import STRDatabase from .telegram_bot import TelegramBot, command, catch_errors DEFAULT_PERIOD = 4 TASK_PER_DAY_LIMIT = 3 class STRApp(TelegramBot): # todo: rewrite all commands, add decorator that parses message and passes it to the command as kwargs. @wraps(TelegramBot.__init__) def __init__(self, db: STRDatabase, *args, **kwargs): super().__init__(*args, **kwargs) self.db = db self._actualize_tasks() self._last_actualize_date = get_current_date() @staticmethod def _tokenize_message(message): result = {} # cut off command code and get shortcut. parts = message.split(maxsplit=2) if len(parts) == 1: raise ValueError("No task shortcut provided") elif len(parts) == 2: return {'shortcut': parts[1]} _, result['shortcut'], message = parts parts = message.split(':') key = "text" for part in parts[:-1]: result[key], key = map(str.strip, part.rsplit(maxsplit=1)) result[key] = parts[-1].strip() if not result['text']: del result['text'] return result def _parse_task(self, user, task): """ """ if 'date' in task: try: task['date'] = parse_date(task['date']) except: raise ValueError(f"Failed to parse date {task['date']}") else: task['date'] = self._determine_suitable_date(user) if 'period' in task: task['period'] = int(task['period']) else: task['period'] = self._determine_suitable_period(user) return task def _determine_suitable_period(self, user): # todo: count current tasks and estimate period necessary to stay below task_per_day_limit # discard large-period tasks. return DEFAULT_PERIOD def _determine_suitable_date(self, user_name): tasks = self.db.get_users_tasks(user_name) tasks_dates = Counter([task.date.date() for task in tasks]) # find_date task_date = get_current_datetime() td = datetime.timedelta(days=1) while tasks_dates[task_date.date()] >= TASK_PER_DAY_LIMIT: task_date += td # this naturally stops because each task register only once. return task_date def parse_message(self, user, message): return self._parse_task(user, STRApp._tokenize_message(message)) @command @catch_errors def add(self, user, message): """ Add new task from message Message should have format {shortcut} {task text} period:1 {key}:{value} """ result = "" task = {'user': user} task.update(self.parse_message(user, message)) # todo: if date is not specified pick something suitable. # todo: if period is not specified - pick something suitable depending on current load task = Task(**task) self.db.add_task(task) result += f"Added task {task.shortcut}" return result @command @catch_errors def update(self, user, message): update = self.parse_message(user, message) task = self.db.get_task(user, update['shortcut']) task.__dict__.update(update) self.db.update_task(user, task) return f"Successfully updated task {task.shortcut}" @command @catch_errors def remove(self, user, message): """ Remove task. """ task = self.parse_message(user, message) self.db.remove_task(user, task['shortcut']) return f"Task {task['shortcut']} removed" @command @catch_errors def get(self, user, message): """ Remove task. """ task = self.parse_message(user, message) task = self.db.get_task(user, task['shortcut']) return repr(task) @command @catch_errors def start(self, user, message): try: self.db.add_user(user) except ValueError: return f"User {user} already active" return f"Added user {user} successfully" @command @catch_errors def stop(self, user, message): try: self.db.remove_user(user) except ValueError: return f"No user {user}" return f"Removed user {user} successfully" @command def list_all(self, user, message): """ List shortcuts of users tasks """ # todo: make a short task repr. return '\n'.join([task.shortcut for task in self.db.get_users_tasks(user)]) @command def list(self, user, message): """ Get tasks for particular date. """ message = trim(message, '/list') if message.strip(): date = parse_date(message) else: date = get_current_datetime() self.actualize_tasks() tasks = self.db.get_users_tasks(user) # need to cast into date because date is datetime with hours etc. tasks = [task for task in tasks if to_date(task.date) == to_date(date)] response = date.strftime("Tasks for %a, %d %b\n") response += "\n".join([task.text for task in tasks]) return response @command def complete(self, user, message): """ Register that you've completed a task :param user: :param message: :return: """ task = self.parse_message(user, message) if 'date' in task: date = parse_date(task['date']) else: date = get_current_datetime() task = self.db.get_task(user=user, shortcut=task['shortcut']) task.completions.append(date) task.date = date + datetime.timedelta(days=task.period) self.db.update_task(task) @command def help(self, user, message): """ Return commands and shortened docstrings. """ reply = "" # todo: add docstrings - instead of help message for each command. # todo: how to make telegram list all possible commands? reply += "Commands: \n" reply += '\n '.join([command.__name__ for command in self.commands]) reply += "Task fields: \n" reply += '\n '.join(Task.declared_fields.keys()) return reply def run(self): with self.db: super().run() def actualize_tasks(self): if self._last_actualize_date < get_current_date(): self._actualize_tasks() self._last_actualize_date = get_current_date() def _actualize_tasks(self): """ Go over all tasks and update date/reschedule """ for user in self.db.user_names: for task in self.db.get_users_tasks(user): today = get_current_datetime() while to_date(task.date) < to_date(today): if task.reschedule: # if task is past due and to be rescheduled - reschedule it on today task.date = today else: task.date += datetime.timedelta(days=task.period) self.db.update_task(task)
32.163793
107
0.590592
7,099
0.951354
0
0
4,697
0.629456
0
0
1,878
0.251675
dfb8674c6f7746d9692d1c11fcd1c8fdb24ebb98
258
py
Python
Strings/conversion-operation.py
tverma332/python3
544c4ec9c726c37293c8da5799f50575cc50852d
[ "MIT" ]
3
2022-03-28T09:10:08.000Z
2022-03-29T10:47:56.000Z
Strings/conversion-operation.py
tverma332/python3
544c4ec9c726c37293c8da5799f50575cc50852d
[ "MIT" ]
1
2022-03-27T11:52:58.000Z
2022-03-27T11:52:58.000Z
Strings/conversion-operation.py
tverma332/python3
544c4ec9c726c37293c8da5799f50575cc50852d
[ "MIT" ]
null
null
null
# lower , title , upper operations on string x = "spider" y = "MAN" v=x.upper() # all letters will become uppercase w=y.lower() # all letters will become lowercase z=y.title() # only first letter will become upper and rest of all lowercase print(v,w,z)
19.846154
75
0.705426
0
0
0
0
0
0
0
0
190
0.736434
dfb9067db6876e985a83eb3d9d6219b06ce32b30
1,197
py
Python
setup.py
adadesions/sfcpy
d395218ae9f72fed378c30ad604923373b7fbf3f
[ "MIT" ]
2
2019-08-28T19:30:32.000Z
2020-03-28T16:17:01.000Z
setup.py
adadesions/sfcpy
d395218ae9f72fed378c30ad604923373b7fbf3f
[ "MIT" ]
5
2021-03-18T22:53:57.000Z
2022-03-11T23:42:38.000Z
setup.py
adadesions/sfcpy
d395218ae9f72fed378c30ad604923373b7fbf3f
[ "MIT" ]
null
null
null
"""Setup script for sfcpy""" import os.path from setuptools import setup # The directory containing this file HERE = os.path.abspath(os.path.dirname(__file__)) # The text of the README file with open(os.path.join(HERE, "README.md"), encoding='utf-8') as fid: README = fid.read() # This call to setup() does all the work setup( name="sfcpy", version="1.2.3", description="Space-Filling Curve library for image-processing tasks", long_description=README, long_description_content_type="text/markdown", url="https://github.com/adadesions/sfcpy", author="adadesions", author_email="[email protected]", license="MIT", classifiers=[ "License :: OSI Approved :: MIT License", "Programming Language :: Python", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", ], packages=["sfcpy"], include_package_data=True, tests_require=['pytest'], install_requires=[ "numpy", "matplotlib", "Pillow" ], entry_points={"console_scripts": ["sfcpy=sfcpy.__main__:main"]}, )
29.925
73
0.652464
0
0
0
0
0
0
0
0
624
0.521303
dfb94390c72e2b9eb210dfba78b3240cd00784e2
7,921
py
Python
make_DigitalCommons_spreadsheet.py
lsulibraries/CWBR_DigitalCommons
6eb994d08d6de088075cde82f6dc2b3aed15bdda
[ "Apache-2.0" ]
null
null
null
make_DigitalCommons_spreadsheet.py
lsulibraries/CWBR_DigitalCommons
6eb994d08d6de088075cde82f6dc2b3aed15bdda
[ "Apache-2.0" ]
null
null
null
make_DigitalCommons_spreadsheet.py
lsulibraries/CWBR_DigitalCommons
6eb994d08d6de088075cde82f6dc2b3aed15bdda
[ "Apache-2.0" ]
null
null
null
#!/usr/bin/env python3 import csv import os from collections import namedtuple import string from nameparser import HumanName def csv_to_dict(filename): file_dict = dict() with open(filename, 'r', newline='', encoding='utf-8') as csvfile: csvreader = csv.reader(csvfile, delimiter='\t', quotechar='"') headers = next(csvreader) CWBR = namedtuple('CWBR', headers) for row in csvreader: item = CWBR(*row) if file_dict.get(item.ID): print('**** Two examples of {} in these spreadsheets ****'.format(item.ID)) exit() file_dict[item.ID] = item return file_dict def make_paragraphs_text(issue): return '\n\t'.join([i for i in issue.Review.replace('<br>', '<p>') .replace('</br>', '</p>') .replace('</p>', '') .split('<p>') if i]) def make_announcement_block(issue): record_type = issue.Record_type if record_type.lower() == 'classics': return 'Feature Essay' elif record_type.lower() in ('interview', 'editorial', 'review', ): return record_type def format_title_parts(string_segment): string_segment = string.capwords(string_segment, ' ') string_segment = string_segment.lstrip().replace("'S ", "'s ").replace('’', "'") string_segment = string_segment.replace('“', '"') string_segment = string_segment.replace('</p>', '').replace('<p>', '') return string_segment def make_title_block(issue): title_parts, subtitle_parts = find_title_lines(issue) title_string = ''.join([format_title_parts(title_part) for title_part in title_parts if title_part]) subtitle_string = ''.join([format_title_parts(subtitle_part) for subtitle_part in subtitle_parts if subtitle_part]) if title_string and subtitle_string: return ': '.join([title_string, subtitle_string]) else: return ''.join([title_string, subtitle_string]) def pull_title_from_Title(issue): title = strip_bolds_breaks(issue.Title).replace('EDITORIAL:', '').replace('INTERVIEW:', '') title_parts = [item for item in title.split('<p>') if item] subtitle_parts = '' return title_parts, subtitle_parts def pull_title_from_Headline(issue): title_parts = [item for item in issue.Headline.split('<p>') if item] subtitle_parts = [item for item in issue.Sub_headline.split('<p>') if item] return title_parts, subtitle_parts def find_title_lines(issue): if issue.Record_type not in ('Editorial', 'Interview'): title_parts, subtitle_parts = pull_title_from_Headline(issue) else: title_parts, subtitle_parts = pull_title_from_Title(issue) if not (title_parts or subtitle_parts): title_parts, subtitle_parts = pull_title_from_Title(issue) return title_parts, subtitle_parts def strip_bolds_breaks(text): for i in ('<br>', '</br>', '<BR>', '</BR>', '<b>', '</b>', '<B>', '</B>', ): text = text.replace(i, '') return text def pick_authors(issue): author_list = [] if issue.Record_type not in ('Review', 'Classics'): for author in (issue.Auth_1, issue.Auth_2, issue.Auth_3): if author: author = author.replace('<br>', '<p>').replace('</br>', '</p>') author_list.append(author) return author_list else: if issue.Reviewer: author_list.append(issue.Reviewer) return author_list def parse_name(name): parsed_name = HumanName(name) first = parsed_name.first middle = parsed_name.middle last = parsed_name.last suffix = parsed_name.suffix return (first, middle, last, suffix) def reformat_issue_type(issue_type): internal_external_dict = {'Editorial': 'editorial', 'Classics': 'feature_essay', 'Interview': 'author_interview', 'Review': 'review', } return internal_external_dict[issue_type] def make_publication_date(issue_date): season, year = issue_date.split(' ') seasons_month_dict = {'Spring': '03', 'Summer': '06', 'Fall': '09', 'Winter': '12'} month = seasons_month_dict[season] return '{}-{}-01'.format(year, month) def make_season(issue_date): return issue_date.split(' ')[0] def make_url(issue_id): return 'https://s3-us-west-2.amazonaws.com/cwbr-publicshare/{}.pdf'.format(issue_id) def make_csv_data(issues_dict): csv_data = [] csv_data.append(['title', 'book_id', 'fulltext_url', 'isbn', 'price', 'publication_date', 'season', 'document_type', 'publisher', 'book_pub_date', 'author1_fname', 'author1_mname', 'author1_lname', 'author1_suffix', 'author2_fname', 'author2_mname', 'author2_lname', 'author2_suffix', 'author3_fname', 'author3_mname', 'author3_lname', 'author3_suffix', 'abstract', ]) for k, issue in sorted(issues_dict.items()): authors_list = pick_authors(issue) author1_fname, author1_mname, author1_lname, author1_suffix = '', '', '', '' author2_fname, author2_mname, author2_lname, author2_suffix = '', '', '', '' author3_fname, author3_mname, author3_lname, author3_suffix = '', '', '', '' if authors_list: author1_fname, author1_mname, author1_lname, author1_suffix = parse_name(authors_list[0]) if len(authors_list) > 1: author2_fname, author2_mname, author2_lname, author2_suffix = parse_name(authors_list[1]) if len(authors_list) > 2: author3_fname, author3_mname, author3_lname, author3_suffix = parse_name(authors_list[2]) csv_data.append([make_title_block(issue), issue.ID, make_url(issue.ID), issue.ISBN, issue.Price, make_publication_date(issue.Issue_date), make_season(issue.Issue_date), reformat_issue_type(issue.Record_type), issue.Publisher, issue.Pub_date, author1_fname, author1_mname, author1_lname, author1_suffix, author2_fname, author2_mname, author2_lname, author2_suffix, author3_fname, author3_mname, author3_lname, author3_suffix, make_paragraphs_text(issue), ]) csv_writer(csv_data) def csv_writer(data): output_dir = 'uploadSpreadsheet' os.makedirs(output_dir, exist_ok=True) with open('uploadSpreadsheet/DigitalCommonsSpreadsheet.csv', "w", newline='', encoding='utf-8') as csv_file: writer = csv.writer(csv_file, delimiter='\t', quotechar='"') for line in data: writer.writerow(line) if __name__ == '__main__': issues_dict = csv_to_dict('3rdStageSourceCSVs/Interviews.csv') make_csv_data(issues_dict)
36.004545
112
0.550562
0
0
0
0
0
0
0
0
1,083
0.136656
dfb9a74f5e09588db5c20e479a0c85f0735ce76b
7,524
py
Python
pip_services3_redis/cache/RedisCache.py
pip-services-python/pip-services-redis-python
ecb2e667ab266af0274b0891a19e802cb256766a
[ "MIT" ]
null
null
null
pip_services3_redis/cache/RedisCache.py
pip-services-python/pip-services-redis-python
ecb2e667ab266af0274b0891a19e802cb256766a
[ "MIT" ]
null
null
null
pip_services3_redis/cache/RedisCache.py
pip-services-python/pip-services-redis-python
ecb2e667ab266af0274b0891a19e802cb256766a
[ "MIT" ]
null
null
null
# -*- coding: utf-8 -*- from typing import Optional, Any import redis from pip_services3_commons.config import IConfigurable, ConfigParams from pip_services3_commons.errors import ConfigException, InvalidStateException from pip_services3_commons.refer import IReferenceable, IReferences from pip_services3_commons.run import IOpenable from pip_services3_components.auth import CredentialResolver from pip_services3_components.cache import ICache from pip_services3_components.connect import ConnectionResolver class RedisCache(ICache, IConfigurable, IReferenceable, IOpenable): """ Distributed cache that stores values in Redis in-memory database. ### Configuration parameters ### - connection(s): - discovery_key: (optional) a key to retrieve the connection from :class:`IDiscovery <pip_services3_components.connect.IDiscovery.IDiscovery>` - host: host name or IP address - port: port number - uri: resource URI or connection string with all parameters in it - credential(s): - store_key: key to retrieve parameters from credential store - username: user name (currently is not used) - password: user password - options: - retries: number of retries (default: 3) - timeout: default caching timeout in milliseconds (default: 1 minute) - max_size: maximum number of values stored in this cache (default: 1000) ### References ### - `*:discovery:*:*:1.0` (optional) :class:`IDiscovery <pip_services3_components.connect.IDiscovery.IDiscovery>` services to resolve connection - `*:credential-store:*:*:1.0` (optional) Credential stores to resolve credential Example: .. code-block:: python cache = RedisCache() cache.configure(ConfigParams.from_tuples( "host", "localhost", "port", 6379 )) cache.open("123") cache.store("123", "key1", "ABC", None) value = cache.retrieve("123", "key1") # Result: "ABC" """ def __init__(self): """ Creates a new instance of this cache """ self.__connection_resolver: ConnectionResolver = ConnectionResolver() self.__credential_resolver: CredentialResolver = CredentialResolver() self.__timeout: int = 30000 self.__retries: int = 3 self.__client: redis.Redis = None def configure(self, config: ConfigParams): """ Configures component by passing configuration parameters. :param config: configuration parameters to be set. """ self.__connection_resolver.configure(config) self.__credential_resolver.configure(config) self.__timeout = config.get_as_integer_with_default('options.timeout', self.__timeout) self.__retries = config.get_as_integer_with_default('options.retries', self.__retries) def set_references(self, references: IReferences): """ Sets references to dependent components. :param references: references to locate the component dependencies. """ self.__connection_resolver.set_references(references) self.__connection_resolver.set_references(references) def is_open(self) -> bool: """ Checks if the component is opened. :return: true if the component has been opened and false otherwise. """ return self.__client is not None def open(self, correlation_id: Optional[str]): """ Opens the component. :param correlation_id: (optional) transaction id to trace execution through call chain. """ connection = self.__connection_resolver.resolve(correlation_id) if connection is None: raise ConfigException( correlation_id, 'NO_CONNECTION', 'Connection is not configured' ) credential = self.__credential_resolver.lookup(correlation_id) options = { # connect_timeout: self.__timeout, # max_attempts: self.__retries, 'retry_on_timeout': True, # 'retry_strategy': lambda options: self.__retry_strategy(options) # TODO add reconnect callback } if connection.get_uri(): options['url'] = connection.get_uri() else: options['host'] = connection.get_host() or 'localhost' options['port'] = connection.get_port() or 6379 if credential is not None: options['password'] = credential.get_password() self.__client = redis.Redis(**options) def close(self, correlation_id: Optional[str]): """ Closes component and frees used resources. :param correlation_id: (optional) transaction id to trace execution through call chain. """ if self.__client is None: return self.__client.close() self.__client = None def __check_opened(self, correlation_id: Optional[str]): if not self.is_open(): raise InvalidStateException( correlation_id, 'NOT_OPENED', 'Connection is not opened' ) def __retry_strategy(self, options: dict) -> Any: if options['error'] and options['error']['code'] == 'ECONNREFUSED': # End reconnecting on a specific error and flush all commands with # a individual error return Exception('The server refused the connection') if options['total_retry_time'] > self.__timeout: # End reconnecting after a specific timeout and flush all commands # with a individual error return Exception('Retry time exhausted') if options['attempt'] > self.__retries: # End reconnecting with built in error return None return min(int(options['attempt']) * 100, 3000) def retrieve(self, correlation_id: Optional[str], key: str) -> Any: """ Retrieves cached value from the cache using its key. If value is missing in the cache or expired it returns `None`. :param correlation_id: (optional) transaction id to trace execution through call chain. :param key: a unique value key. :return: a retrieve cached value or `None` if nothing was found. """ self.__check_opened(correlation_id) return self.__client.get(key) def store(self, correlation_id: Optional[str], key: str, value: Any, timeout: int) -> Any: """ Stores value in the cache with expiration time. :param correlation_id: (optional) transaction id to trace execution through call chain. :param key: a unique value key. :param value: a value to store. :param timeout: expiration timeout in milliseconds. :return: the stored value. """ self.__check_opened(correlation_id) return self.__client.set(name=key, value=value, px=timeout) def remove(self, correlation_id: Optional[str], key: str) -> Any: """ Removes a value from the cache by its key. :param correlation_id: (optional) transaction id to trace execution through call chain. :param key: a unique value key. :return: the removed value. """ self.__check_opened(correlation_id) return self.__client.delete(key)
37.064039
158
0.636895
7,010
0.931685
0
0
0
0
0
0
3,992
0.530569
dfbade8328cd7332030b49fd40ed470582f05c91
7,392
py
Python
main/model/property.py
lipis/gae-init-magic
6b1e0b50f8e5200cb2dacebca9ac65e796b241a9
[ "MIT" ]
1
2018-10-26T13:33:20.000Z
2018-10-26T13:33:20.000Z
main/model/property.py
lipis/gae-init-magic
6b1e0b50f8e5200cb2dacebca9ac65e796b241a9
[ "MIT" ]
652
2018-10-26T12:28:08.000Z
2021-08-02T09:13:48.000Z
main/model/property.py
lipis/gae-init-magic
6b1e0b50f8e5200cb2dacebca9ac65e796b241a9
[ "MIT" ]
null
null
null
# coding: utf-8 from __future__ import absolute_import from google.appengine.ext import ndb from api import fields import model import util class Property(model.Base): name = ndb.StringProperty(required=True) rank = ndb.IntegerProperty(default=0) verbose_name = ndb.StringProperty(default='') show_on_view = ndb.BooleanProperty(default=True, verbose_name='Show on View') show_on_update = ndb.BooleanProperty(default=True, verbose_name='Show on Update') show_on_list = ndb.BooleanProperty(default=True, verbose_name='Show on List') show_on_admin_update = ndb.BooleanProperty(default=True, verbose_name='Show on Admin Update') show_on_admin_list = ndb.BooleanProperty(default=True, verbose_name='Show on Admin List') ndb_property = ndb.StringProperty(default='', verbose_name='NDB Property') kind = ndb.StringProperty() default = ndb.StringProperty() required = ndb.BooleanProperty(default=False) repeated = ndb.BooleanProperty(default=False) tags = ndb.BooleanProperty(default=False) indexed = ndb.BooleanProperty(default=True) auto_now = ndb.BooleanProperty(default=False) auto_now_add = ndb.BooleanProperty(default=False) compressed = ndb.BooleanProperty(default=False) ndb_choices = ndb.StringProperty(verbose_name='Choices') field_property = ndb.StringProperty(default='') wtf_property = ndb.StringProperty(default='', verbose_name='WTF Property') description = ndb.StringProperty(default='') strip_filter = ndb.BooleanProperty(default=False) email_filter = ndb.BooleanProperty(default=False) sort_filter = ndb.BooleanProperty(default=False) choices = ndb.StringProperty() forms_property = ndb.StringProperty(default='') placeholder = ndb.StringProperty(default='') autofocus = ndb.BooleanProperty(default=False) readonly = ndb.BooleanProperty(default=False) def ndb_field(self, include_babel=False): args = [ 'kind=%s' % self.kind if self.kind else '', 'default=%s' % self.default if self.default else '', 'required=True' if self.required else '', 'repeated=%s' % self.repeated if self.repeated else '', 'indexed=False' if not self.indexed else '', 'compressed=True' if self.compressed else '', 'choices=[%s]' % self.ndb_choices if self.ndb_choices else '', ] if include_babel: args.append("verbose_name=_(u'%s')" % self.verbose_name_) else: args.append("verbose_name=u'%s'" % self.verbose_name if self.verbose_name else '') return '%s = %s(%s)' % ( self.name, self.ndb_property, ', '.join([arg for arg in args if arg]), ) @ndb.ComputedProperty def api_field(self): if not self.field_property: return '' if self.repeated: return "'%s': fields.List(%s)," % (self.name, self.field_property) return "'%s': %s," % (self.name, self.field_property) @ndb.ComputedProperty def wtf_field(self): validators = ['wtforms.validators.%s()' % ('required' if self.required else 'optional')] if self.ndb_property == 'ndb.StringProperty' and self.wtf_property in ['wtforms.TextAreaField', 'wtforms.StringField']: validators.append('wtforms.validators.length(max=500)') filters = [ 'util.strip_filter' if self.strip_filter else '', 'util.email_filter' if self.email_filter else '', 'util.sort_filter' if self.sort_filter else '', ] filters = [f for f in filters if f] filters = ' filters=[%s],\n' % ', '.join(filters) if filters else '' description = " description='%s',\n" % self.description if self.description else '' choices = '' if self.wtf_property in ['wtforms.RadioField', 'wtforms.SelectField', 'wtforms.SelectMultipleField']: choices = ' choices=%s,\n' % (self.choices if self.choices else '[]') date_format = '' if self.wtf_property == 'wtforms.DateTimeField': date_format = " format='%Y-%m-%dT%H:%M',\n" title = '%r' % self.verbose_name_ if self.ndb_property: title = 'model.%s.%s._verbose_name' % (self.key.parent().get().name, self.name) if self.wtf_property == 'wtforms.GeoPtField': validators += ['wtforms.validators.NumberRange(min=-90, max=90)'] validatorss = '[%s]' % ', '.join(validators) lat = ( '%s_lat = wtforms.FloatField(\n' ' %s,\n' ' %s,\n%s%s%s%s' ' )' % (self.name, title + " + ' Latitude'", validatorss, filters, choices, description, date_format)) validators.pop() validators += ['wtforms.validators.NumberRange(min=-180, max=180)'] validatorss = '[%s]' % ', '.join(validators) lon = ( '\n %s_lon = wtforms.FloatField(\n' ' %s,\n' ' %s,\n%s%s%s%s' ' )' % (self.name, title + " + ' Longtitute'", validatorss, filters, choices, description, date_format)) return '%s %s' % (lat, lon) validators = '[%s]' % ', '.join(validators) return ( '%s = %s(\n' ' %s,\n' ' %s,\n%s%s%s%s' ' )' % (self.name, self.wtf_property, title, validators, filters, choices, description, date_format)) @ndb.ComputedProperty def forms_field(self): autofocus = ', autofocus=True' if self.autofocus else '' readonly = ', readonly=True' if self.readonly else '' placeholder = ", placeholder='%s'" % self.placeholder if self.placeholder else '' if self.forms_property == 'forms.geo_pt_field': lat = "{{forms.number_field(form.%s_lat%s%s%s)}}" % (self.name, autofocus, readonly, placeholder) lon = "{{forms.number_field(form.%s_lon%s%s%s)}}" % (self.name, autofocus, readonly, placeholder) return ('<div class="row">\n' ' <div class="col-sm-6">%s</div>\n <div class="col-sm-6">%s</div>\n </div>' %(lat, lon)) return "{{%s(form.%s%s%s%s)}}" % (self.forms_property, self.name, autofocus, readonly, placeholder) @ndb.ComputedProperty def default_verbose_name(self): return util.snake_to_verbose(self.name) @ndb.ComputedProperty def verbose_name_(self): return self.verbose_name or self.default_verbose_name def get_title_name(self): if self.ndb_property != 'ndb.KeyProperty' or not self.kind: return None if self.kind == 'model.User': return 'name' model_qry = model.Model.query(ancestor=self.key.parent().parent()) model_qry = model_qry.filter(model.Model.name == self.kind.split('.')[1]) model_db = model_qry.get() if model_db and model_db.title_property_key: return model_db.title_property_key.get().name return None FIELDS = { 'auto_now': fields.Boolean, 'auto_now_add': fields.Boolean, 'autofocus': fields.Boolean, 'choices': fields.String, 'default': fields.String, 'description': fields.String, 'email_filter': fields.Boolean, 'field_property': fields.String, 'forms_property': fields.String, 'kind': fields.String, 'name': fields.String, 'ndb_property': fields.String, 'placeholder': fields.String, 'rank': fields.Integer, 'readonly': fields.Boolean, 'repeated': fields.Boolean, 'required': fields.Boolean, 'sort_filter': fields.Boolean, 'strip_filter': fields.Boolean, 'verbose_name': fields.String, 'wtf_property': fields.String, } FIELDS.update(model.Base.FIELDS)
38.701571
123
0.652056
7,246
0.980249
0
0
3,514
0.475379
0
0
1,772
0.239719
dfbc302b59b318fa83066ffc6aa91c4caa2533da
1,189
py
Python
tests/test_request.py
pauleveritt/wired_components
a9072d5fc48680d5ff895887842ffd0f06bc0081
[ "MIT" ]
1
2019-09-15T12:30:44.000Z
2019-09-15T12:30:44.000Z
tests/test_request.py
pauleveritt/wired_components
a9072d5fc48680d5ff895887842ffd0f06bc0081
[ "MIT" ]
null
null
null
tests/test_request.py
pauleveritt/wired_components
a9072d5fc48680d5ff895887842ffd0f06bc0081
[ "MIT" ]
null
null
null
import pytest from wired import ServiceContainer @pytest.fixture def request_container(registry, simple_root) -> ServiceContainer: from wired_components.request import wired_setup as request_setup from wired_components.resource import IRoot from wired_components.url import IUrl, Url # Outside system puts some things in the registry registry.register_singleton(simple_root, IRoot) request_setup(registry) # Make a container and return it container: ServiceContainer = registry.create_container( context=simple_root ) url = Url(path='somepath') container.register_singleton(url, IUrl) return container def test_request_wired_setup(registry): from wired_components.request import wired_setup assert wired_setup(registry) is None def test_request_instance(registry, request_container, simple_root): # Get the request from the container from wired_components.request import IRequest, Request request: Request = request_container.get(IRequest) # See if we're constructed correctly assert request.context.title == 'My Site' assert request.path == 'somepath' assert request.root == simple_root
31.289474
69
0.764508
0
0
0
0
610
0.513036
0
0
182
0.15307
dfbd03cf9bf0d42acbc4621a1653916d133bdb8e
958
py
Python
Charts and Graphs/LollipopCharts.py
aprakash7/Buildyourown
58f0530ea84bf9e91f258d947610ea1e93d7d456
[ "MIT" ]
null
null
null
Charts and Graphs/LollipopCharts.py
aprakash7/Buildyourown
58f0530ea84bf9e91f258d947610ea1e93d7d456
[ "MIT" ]
null
null
null
Charts and Graphs/LollipopCharts.py
aprakash7/Buildyourown
58f0530ea84bf9e91f258d947610ea1e93d7d456
[ "MIT" ]
1
2021-05-31T04:20:54.000Z
2021-05-31T04:20:54.000Z
# -*- coding: utf-8 -*- """ Created on Mon May 17 21:24:53 2021 @author: Akshay Prakash """ import pandas as pd import numpy as np import matplotlib.pyplot as plt table = pd.read_csv(r'\1617table.csv') table.head() plt.hlines(y= np.arange(1, 21), xmin = 0, xmax = table['Pts'], color = 'skyblue') plt.plot(table['Pts'], np.arange(1,21), "o") plt.yticks(np.arange(1,21), table['team']) plt.show() teamColours = ['#034694','#001C58','#5CBFEB','#D00027', '#EF0107','#DA020E','#274488','#ED1A3B', '#000000','#091453','#60223B','#0053A0', '#E03A3E','#1B458F','#000000','#53162f', '#FBEE23','#EF6610','#C92520','#BA1F1A'] plt.hlines(y= np.arange(1, 21), xmin = 0, xmax = table['Pts'], color = teamColours) plt.plot(table['Pts'], np.arange(1,21), "o") plt.yticks(np.arange(1,21), table['team']) plt.xlabel('Points') plt.ylabel('Teams') plt.title("Premier league 16/17")
30.903226
84
0.583507
0
0
0
0
0
0
0
0
377
0.393528
dfbf2ca5c949daa624f3881dc6dcb4567701067b
1,126
py
Python
python/merge-kml-files/merge-kml-files.py
bmaupin/graveyard
71d52fe6589ce13dfe7433906d1aa50df48c9f94
[ "MIT" ]
1
2019-11-23T10:44:58.000Z
2019-11-23T10:44:58.000Z
python/merge-kml-files/merge-kml-files.py
bmaupin/graveyard
71d52fe6589ce13dfe7433906d1aa50df48c9f94
[ "MIT" ]
8
2020-07-16T07:14:12.000Z
2020-10-14T17:25:33.000Z
python/merge-kml-files/merge-kml-files.py
bmaupin/graveyard
71d52fe6589ce13dfe7433906d1aa50df48c9f94
[ "MIT" ]
1
2019-11-23T10:45:00.000Z
2019-11-23T10:45:00.000Z
#!/usr/bin/env python import sys import lxml.etree def main(): if len(sys.argv) < 3: sys.stderr.write('ERROR: Must provide at least 2 KML files to merge\n') sys.exit('Usage: {} FILE1 FILE2 ...'.format(sys.argv[0])) first_kml_root = lxml.etree.parse(sys.argv[1]).getroot() first_kml_ns = first_kml_root.nsmap[None] first_kml_document = first_kml_root.find('{{{}}}Document'.format( first_kml_ns)) for filename in sys.argv[2:]: kml_root = lxml.etree.parse(filename).getroot() kml_ns = kml_root.nsmap[None] kml_document = kml_root.find('{{{}}}Document'.format(kml_ns)) # Add the Document node's child elements to the first KML file for element in kml_document.iterchildren(): first_kml_document.append(element) print(lxml.etree.tostring( first_kml_root, encoding='utf-8', xml_declaration=True, pretty_print=True, # .decode('utf-8') is required for Python 3 ).decode('utf-8')) if __name__ == '__main__': main()
31.277778
79
0.599467
0
0
0
0
0
0
0
0
262
0.232682
dfbf59c5b26596753447f4f968efc9068d24fa0b
3,829
py
Python
tccli/services/partners/v20180321/help.py
tarnover/tencentcloud-cli
5b0537913a33884a20d7663405a8aa1c2276b41a
[ "Apache-2.0" ]
null
null
null
tccli/services/partners/v20180321/help.py
tarnover/tencentcloud-cli
5b0537913a33884a20d7663405a8aa1c2276b41a
[ "Apache-2.0" ]
null
null
null
tccli/services/partners/v20180321/help.py
tarnover/tencentcloud-cli
5b0537913a33884a20d7663405a8aa1c2276b41a
[ "Apache-2.0" ]
null
null
null
# -*- coding: utf-8 -*- DESC = "partners-2018-03-21" INFO = { "AgentPayDeals": { "params": [ { "name": "OwnerUin", "desc": "订单所有者uin" }, { "name": "AgentPay", "desc": "代付标志,1:代付;0:自付" }, { "name": "DealNames", "desc": "订单号数组" } ], "desc": "代理商支付订单接口,支持自付/代付" }, "DescribeAgentBills": { "params": [ { "name": "SettleMonth", "desc": "支付月份,如2018-02" }, { "name": "ClientUin", "desc": "客户账号ID" }, { "name": "PayMode", "desc": "支付方式,prepay/postpay" }, { "name": "OrderId", "desc": "预付费订单号" }, { "name": "ClientRemark", "desc": "客户备注名称" }, { "name": "Offset", "desc": "偏移量" }, { "name": "Limit", "desc": "限制数目" } ], "desc": "代理商可查询自己及名下代客所有业务明细" }, "AgentTransferMoney": { "params": [ { "name": "ClientUin", "desc": "客户账号ID" }, { "name": "Amount", "desc": "转账金额,单位分" } ], "desc": "为合作伙伴提供转账给客户能力。仅支持合作伙伴为自己名下客户转账。" }, "DescribeRebateInfos": { "params": [ { "name": "RebateMonth", "desc": "返佣月份,如2018-02" }, { "name": "Offset", "desc": "偏移量" }, { "name": "Limit", "desc": "限制数目" } ], "desc": "代理商可查询自己名下全部返佣信息" }, "ModifyClientRemark": { "params": [ { "name": "ClientRemark", "desc": "客户备注名称" }, { "name": "ClientUin", "desc": "客户账号ID" } ], "desc": "代理商可以对名下客户添加备注、修改备注" }, "DescribeAgentClients": { "params": [ { "name": "ClientUin", "desc": "客户账号ID" }, { "name": "ClientName", "desc": "客户名称。由于涉及隐私,名称打码显示,故名称仅支持打码后的模糊搜索" }, { "name": "ClientFlag", "desc": "客户类型,a/b,类型定义参考代理商相关政策文档" }, { "name": "OrderDirection", "desc": "ASC/DESC, 不区分大小写,按申请时间排序" }, { "name": "Offset", "desc": "偏移量" }, { "name": "Limit", "desc": "限制数目" } ], "desc": "代理商可查询自己名下待审核客户列表" }, "DescribeClientBalance": { "params": [ { "name": "ClientUin", "desc": "客户(代客)账号ID" } ], "desc": "为合作伙伴提供查询客户余额能力。调用者必须是合作伙伴,只能查询自己名下客户余额" }, "DescribeAgentAuditedClients": { "params": [ { "name": "ClientUin", "desc": "客户账号ID" }, { "name": "ClientName", "desc": "客户名称。由于涉及隐私,名称打码显示,故名称仅支持打码后的模糊搜索" }, { "name": "ClientFlag", "desc": "客户类型,a/b,类型定义参考代理商相关政策文档" }, { "name": "OrderDirection", "desc": "ASC/DESC, 不区分大小写,按审核通过时间排序" }, { "name": "ClientUins", "desc": "客户账号ID列表" }, { "name": "HasOverdueBill", "desc": "是否欠费。0:不欠费;1:欠费" }, { "name": "ClientRemark", "desc": "客户备注" }, { "name": "Offset", "desc": "偏移量" }, { "name": "Limit", "desc": "限制数目" }, { "name": "ClientType", "desc": "客户类型:可以为new(新拓)/assign(指定)/old(存量)/空" }, { "name": "ProjectType", "desc": "项目类型:可以为self(自拓项目)/platform(合作项目)/repeat(复算项目 )/空" } ], "desc": "查询已审核客户列表" }, "AuditApplyClient": { "params": [ { "name": "ClientUin", "desc": "待审核客户账号ID" }, { "name": "AuditResult", "desc": "审核结果,可能的取值:accept/reject" }, { "name": "Note", "desc": "申请理由,B类客户审核通过时必须填写申请理由" } ], "desc": "代理商可以审核其名下申请中代客" } }
19.049751
68
0.404022
0
0
0
0
0
0
0
0
3,081
0.627879
dfbfef0fe41686291ae36ae72197b63006cb0f9c
83,387
py
Python
src/main/python/lib/default/__init__.py
emilybache/texttest-runner
2d5c42b8d37699a2cbcb8f19af7c271d6ad1024a
[ "MIT" ]
null
null
null
src/main/python/lib/default/__init__.py
emilybache/texttest-runner
2d5c42b8d37699a2cbcb8f19af7c271d6ad1024a
[ "MIT" ]
null
null
null
src/main/python/lib/default/__init__.py
emilybache/texttest-runner
2d5c42b8d37699a2cbcb8f19af7c271d6ad1024a
[ "MIT" ]
null
null
null
""" The default configuration, from which all others should be derived """ import os, plugins, sandbox, console, rundependent, comparetest, batch, performance, subprocess, operator, logging from copy import copy from string import Template from fnmatch import fnmatch from threading import Thread # For back-compatibility from runtest import RunTest, Running, Killed from scripts import * def getConfig(optionMap): return Config(optionMap) class Config: loggingSetup = False removePreviousThread = None def __init__(self, optionMap): self.optionMap = optionMap self.filterFileMap = {} if self.hasExplicitInterface(): self.trySetUpLogging() from reconnect import ReconnectConfig self.reconnectConfig = ReconnectConfig(optionMap) def getMachineNameForDisplay(self, machine): return machine # override for queuesystems def getCheckoutLabel(self): return "Use checkout" def getMachineLabel(self): return "Run on machine" def addToOptionGroups(self, apps, groups): recordsUseCases = len(apps) == 0 or self.anyAppHas(apps, lambda app: app.getConfigValue("use_case_record_mode") != "disabled") useCatalogues = self.anyAppHas(apps, self.isolatesDataUsingCatalogues) useCaptureMock = self.anyAppHas(apps, self.usesCaptureMock) for group in groups: if group.name.startswith("Select"): group.addOption("t", "Test names containing", description="Select tests for which the name contains the entered text. The text can be a regular expression.") group.addOption("ts", "Test paths containing", description="Select tests for which the full path to the test (e.g. suite1/subsuite/testname) contains the entered text. The text can be a regular expression. You can select tests by suite name this way.") possibleDirs = self.getFilterFileDirectories(apps, useOwnTmpDir=True) group.addOption("f", "Tests listed in file", possibleDirs=possibleDirs, selectFile=True) group.addOption("desc", "Descriptions containing", description="Select tests for which the description (comment) matches the entered text. The text can be a regular expression.") if self.anyAppHas(apps, self.hasPerformance): group.addOption("r", "Execution time", description="Specify execution time limits, either as '<min>,<max>', or as a list of comma-separated expressions, such as >=0:45,<=1:00. Digit-only numbers are interpreted as minutes, while colon-separated numbers are interpreted as hours:minutes:seconds.") group.addOption("grep", "Test-files containing", description="Select tests which have a file containing the entered text. The text can be a regular expression : e.g. enter '.*' to only look for the file without checking the contents.") group.addOption("grepfile", "Test-file to search", allocateNofValues=2, description="When the 'test-files containing' field is non-empty, apply the search in files with the given stem. Unix-style file expansion (note not regular expressions) may be used. For example '*' will look in any file.") elif group.name.startswith("Basic"): if len(apps) > 0: version = plugins.getAggregateString(apps, lambda app: app.getFullVersion()) checkout = plugins.getAggregateString(apps, lambda app: app.checkout) machine = plugins.getAggregateString(apps, lambda app: app.getRunMachine()) else: version, checkout, machine = "", "", "" group.addOption("v", "Run this version", version) group.addOption("c", self.getCheckoutLabel(), checkout) group.addOption("m", self.getMachineLabel(), self.getMachineNameForDisplay(machine)) group.addOption("cp", "Times to run", 1, minimum=1, description="Set this to some number larger than 1 to run the same test multiple times, for example to try to catch indeterminism in the system under test") if recordsUseCases: group.addOption("delay", "Replay pause (sec)", 0.0, description="How long to wait, in seconds, between replaying each GUI action in the usecase file") self.addDefaultSwitch(group, "gui", "Show GUI and record any extra actions", description="Disable virtual display usage if any. Replay whatever is in the usecase file and enabled recording when done") self.addDefaultSwitch(group, "screenshot", "Generate a screenshot after each replayed action", description="The screenshots can be viewed via the 'View Screenshots' action in the test (left panel) context menu") self.addDefaultSwitch(group, "stop", "Stop after first failure") if useCatalogues: self.addDefaultSwitch(group, "ignorecat", "Ignore catalogue file when isolating data", description="Treat test data identified by 'partial_copy_test_path' as if it were in 'copy_test_path', " + "i.e. copy everything without taking notice of the catalogue file. Useful when many things have changed with the files written by the test") if useCaptureMock: self.addCaptureMockSwitch(group) elif group.name.startswith("Advanced"): self.addDefaultOption(group, "b", "Run batch mode session") self.addDefaultOption(group, "name", "Name this run") group.addOption("vanilla", "Ignore configuration files", self.defaultVanillaValue(), possibleValues = [ "", "site", "personal", "all" ]) self.addDefaultSwitch(group, "keeptmp", "Keep temporary write-directories") group.addSwitch("ignorefilters", "Ignore all run-dependent text filtering") elif group.name.startswith("Self-diagnostics"): self.addDefaultSwitch(group, "x", "Enable self-diagnostics") defaultDiagDir = plugins.getPersonalDir("log") group.addOption("xr", "Configure self-diagnostics from", os.path.join(defaultDiagDir, "logging.debug"), possibleValues=[ os.path.join(plugins.installationDir("log"), "logging.debug") ]) group.addOption("xw", "Write self-diagnostics to", defaultDiagDir) elif group.name.startswith("Invisible"): # Options that don't make sense with the GUI should be invisible there... group.addOption("a", "Load test applications named") group.addOption("s", "Run this script") group.addOption("d", "Look for test files under") group.addSwitch("help", "Print configuration help text on stdout") group.addSwitch("g", "use dynamic GUI") group.addSwitch("gx", "use static GUI") group.addSwitch("con", "use console interface") group.addSwitch("coll", "Collect results for batch mode session") group.addSwitch("collarchive", "Collect results for batch mode session using data in the archive, back to the given date") group.addOption("tp", "Private: Tests with exact path") # use for internal communication group.addOption("finverse", "Tests not listed in file") group.addOption("fintersect", "Tests in all files") group.addOption("funion", "Tests in any of files") group.addOption("fd", "Private: Directory to search for filter files in") group.addOption("td", "Private: Directory to search for temporary settings in") group.addOption("count", "Private: How many tests we believe there will be") group.addOption("o", "Overwrite failures, optionally using version") group.addOption("reconnect", "Reconnect to previous run") group.addSwitch("reconnfull", "Recompute file filters when reconnecting", options=self.getReconnFullOptions()) group.addSwitch("n", "Create new results files (overwrite everything)") group.addSwitch("new", "Start static GUI with no applications loaded") group.addOption("bx", "Select tests exactly as for batch mode session") group.addSwitch("zen", "Make console output coloured, for use e.g. with ZenTest") if recordsUseCases: group.addSwitch("record", "Private: Record usecase rather than replay what is present") group.addSwitch("autoreplay", "Private: Used to flag that the run has been autogenerated") else: # We may have other apps that do this, don't reject these options group.addOption("delay", "Replay pause (sec)", 0) group.addSwitch("gui", "Show GUI and record any extra actions") group.addSwitch("screenshot", "Generate a screenshot after each replayed action") if not useCatalogues: group.addSwitch("ignorecat", "Ignore catalogue file when isolating data") if not useCaptureMock: self.addCaptureMockSwitch(group) def addDefaultSwitch(self, group, key, name, *args, **kw): group.addSwitch(key, name, self.optionIntValue(key), *args, **kw) def addDefaultOption(self, group, key, name, *args, **kw): group.addOption(key, name, self.optionValue(key), *args, **kw) def addCaptureMockSwitch(self, group, value=0): options = [ "Replay", "Record", "Mixed Mode", "Disabled" ] descriptions = [ "Replay all existing interactions from the information in CaptureMock's mock files. Do not record anything new.", "Ignore any existing CaptureMock files and record all the interactions afresh.", "Replay all existing interactions from the information in the CaptureMock mock files. " + \ "Record any other interactions that occur.", "Disable CaptureMock" ] group.addSwitch("rectraffic", "CaptureMock", value=value, options=options, description=descriptions) def getReconnFullOptions(self): return ["Display results exactly as they were in the original run", "Use raw data from the original run, but recompute run-dependent text, known bug information etc."] def anyAppHas(self, apps, propertyMethod): for app in apps: for partApp in [ app ] + app.extras: if propertyMethod(partApp): return True return False def defaultVanillaValue(self): if not self.optionMap.has_key("vanilla"): return "" given = self.optionValue("vanilla") return given or "all" def getRunningGroupNames(self): return [ ("Basic", None, None), ("Self-diagnostics (internal logging)", "x", 0), ("Advanced", None, None) ] def getAllRunningGroupNames(self, allApps): if len(allApps) == 0: return self.getRunningGroupNames() names = [] for app in allApps: for name in app.getRunningGroupNames(): if name not in names: names.append(name) return names def createOptionGroups(self, allApps): groupNames = [ "Selection", "Invisible" ] + [ x[0] for x in self.getAllRunningGroupNames(allApps) ] optionGroups = map(plugins.OptionGroup, groupNames) self.addToOptionGroups(allApps, optionGroups) return optionGroups def findAllValidOptions(self, allApps): groups = self.createOptionGroups(allApps) return reduce(operator.add, (g.keys() for g in groups), []) def getActionSequence(self): if self.optionMap.has_key("coll"): return [] if self.isReconnecting(): return self.getReconnectSequence() scriptObject = self.optionMap.getScriptObject() if scriptObject: if self.usesComparator(scriptObject): return [ self.getWriteDirectoryMaker(), rundependent.FilterOriginalForScript(), scriptObject, comparetest.MakeComparisons(ignoreMissing=True,enableColor=self.optionMap.has_key("zen")) ] else: return [ scriptObject ] else: return self.getTestProcessor() def usesComparator(self, scriptObject): try: return scriptObject.usesComparator() except AttributeError: return False def useGUI(self): return self.optionMap.has_key("g") or self.optionMap.has_key("gx") def useStaticGUI(self, app): return self.optionMap.has_key("gx") or \ (not self.hasExplicitInterface() and app.getConfigValue("default_interface") == "static_gui") def useConsole(self): return self.optionMap.has_key("con") def getExtraVersions(self, app): fromConfig = self.getExtraVersionsFromConfig(app) fromCmd = self.getExtraVersionsFromCmdLine(app, fromConfig) return self.createComposites(fromConfig, fromCmd) def createComposites(self, vlist1, vlist2): allVersions = copy(vlist1) for v2 in vlist2: allVersions.append(v2) for v1 in vlist1: allVersions.append(v2 + "." + v1) return allVersions def getExtraVersionsFromCmdLine(self, app, fromConfig): if self.isReconnecting(): return self.reconnectConfig.getExtraVersions(app, fromConfig) else: copyVersions = self.getCopyExtraVersions() checkoutVersions, _ = self.getCheckoutExtraVersions(app) # Generated automatically to be able to distinguish, don't save them for ver in copyVersions + checkoutVersions: app.addConfigEntry("unsaveable_version", ver) return self.createComposites(checkoutVersions, copyVersions) def getCopyExtraVersions(self): try: copyCount = int(self.optionMap.get("cp", 1)) except TypeError: copyCount = 1 return [ "copy_" + str(i) for i in range(1, copyCount) ] def makeParts(self, c): return c.replace("\\", "/").split("/") def versionNameFromCheckout(self, c, checkoutNames): checkoutParts = self.makeParts(c) for other in checkoutNames: if other != c: for otherPart in self.makeParts(other): if otherPart in checkoutParts: checkoutParts.remove(otherPart) return checkoutParts[-1].replace(".", "_") def getCheckoutExtraVersions(self, app): checkoutNames = plugins.commasplit(self.optionValue("c")) if len(checkoutNames) > 1: expandedNames = [ self.expandCheckout(c, app) for c in checkoutNames ] extraCheckouts = expandedNames[1:] return [ self.versionNameFromCheckout(c, expandedNames) for c in extraCheckouts ], extraCheckouts else: return [], [] def getBatchSession(self, app): return self.optionValue("b") def getBatchSessionForSelect(self, app): return self.getBatchSession(app) or self.optionMap.get("bx") def getExtraVersionsFromConfig(self, app): basic = app.getConfigValue("extra_version") batchSession = self.getBatchSessionForSelect(app) if batchSession is not None: for batchExtra in app.getCompositeConfigValue("batch_extra_version", batchSession): if batchExtra not in basic: basic.append(batchExtra) if self.optionMap.has_key("count"): return [] # dynamic GUI started from static GUI, rely on it telling us what to load for extra in basic: if extra in app.versions: return [] return basic def getDefaultInterface(self, allApps): if self.optionMap.has_key("s"): return "console" elif len(allApps) == 0 or self.optionMap.has_key("new"): return "static_gui" defaultIntf = None for app in allApps: appIntf = app.getConfigValue("default_interface") if defaultIntf and appIntf != defaultIntf: raise plugins.TextTestError, "Conflicting default interfaces for different applications - " + \ appIntf + " and " + defaultIntf defaultIntf = appIntf return defaultIntf def setDefaultInterface(self, allApps): mapping = { "static_gui" : "gx", "dynamic_gui": "g", "console": "con" } defaultInterface = self.getDefaultInterface(allApps) if mapping.has_key(defaultInterface): self.optionMap[mapping[defaultInterface]] = "" else: raise plugins.TextTestError, "Invalid value for default_interface '" + defaultInterface + "'" def hasExplicitInterface(self): return self.useGUI() or self.batchMode() or self.useConsole() or self.optionMap.has_key("o") def getLogfilePostfixes(self): if self.optionMap.has_key("x"): return [ "debug" ] elif self.optionMap.has_key("gx"): return [ "gui", "static_gui" ] elif self.optionMap.has_key("g"): return [ "gui", "dynamic_gui" ] elif self.batchMode(): return [ "console", "batch" ] else: return [ "console" ] def trySetUpLogging(self): if not self.loggingSetup: self.setUpLogging() Config.loggingSetup = True def setUpLogging(self): filePatterns = [ "logging." + postfix for postfix in self.getLogfilePostfixes() ] includeSite, includePersonal = self.optionMap.configPathOptions() allPaths = plugins.findDataPaths(filePatterns, includeSite, includePersonal, dataDirName="log") if len(allPaths) > 0: plugins.configureLogging(allPaths[-1]) # Won't have any effect if we've already got a log file else: plugins.configureLogging() def getResponderClasses(self, allApps): # Global side effects first :) if not self.hasExplicitInterface(): self.setDefaultInterface(allApps) self.trySetUpLogging() return self._getResponderClasses(allApps) def _getResponderClasses(self, allApps): classes = [] if not self.optionMap.has_key("gx"): if self.optionMap.has_key("new"): raise plugins.TextTestError, "'--new' option can only be provided with the static GUI" elif len(allApps) == 0: raise plugins.TextTestError, "Could not find any matching applications (files of the form config.<app>) under " + " or ".join(self.optionMap.rootDirectories) if self.useGUI(): self.addGuiResponder(classes) else: classes.append(self.getTextDisplayResponderClass()) if not self.optionMap.has_key("gx"): classes += self.getThreadActionClasses() if self.batchMode() and not self.optionMap.has_key("s"): if self.optionMap.has_key("coll"): arg = self.optionMap["coll"] if arg != "mail": classes.append(self.getWebPageResponder()) if not arg or "web" not in arg: classes.append(batch.CollectFilesResponder) else: if self.optionValue("b") is None: plugins.log.info("No batch session identifier provided, using 'default'") self.optionMap["b"] = "default" if self.anyAppHas(allApps, lambda app: self.emailEnabled(app)): classes.append(batch.EmailResponder) if self.anyAppHas(allApps, lambda app: self.getBatchConfigValue(app, "batch_junit_format") == "true"): from batch.junitreport import JUnitResponder classes.append(JUnitResponder) if os.name == "posix" and self.useVirtualDisplay(): from virtualdisplay import VirtualDisplayResponder classes.append(VirtualDisplayResponder) stateSaver = self.getStateSaver() if stateSaver is not None: classes.append(stateSaver) if not self.useGUI() and not self.batchMode(): classes.append(self.getTextResponder()) # At the end, so we've done the processing before we proceed from storytext_interface import ApplicationEventResponder classes.append(ApplicationEventResponder) return classes def emailEnabled(self, app): return self.getBatchConfigValue(app, "batch_recipients") or \ self.getBatchConfigValue(app, "batch_use_collection") == "true" def getBatchConfigValue(self, app, configName, **kw): return app.getCompositeConfigValue(configName, self.getBatchSession(app), **kw) def isActionReplay(self): for option, _ in self.getInteractiveReplayOptions(): if self.optionMap.has_key(option): return True return False def noFileAdvice(self): # What can we suggest if files aren't present? In this case, not much return "" def useVirtualDisplay(self): # Don't try to set it if we're using the static GUI or # we've requested a slow motion replay or we're trying to record a new usecase. return not self.isRecording() and not self.optionMap.has_key("gx") and \ not self.isActionReplay() and not self.optionMap.has_key("coll") and not self.optionMap.runScript() def getThreadActionClasses(self): from actionrunner import ActionRunner return [ ActionRunner ] def getTextDisplayResponderClass(self): return console.TextDisplayResponder def isolatesDataUsingCatalogues(self, app): return app.getConfigValue("create_catalogues") == "true" and \ len(app.getConfigValue("partial_copy_test_path")) > 0 def usesCaptureMock(self, app): return "traffic" in app.defFileStems() def hasWritePermission(self, path): if os.path.isdir(path): return os.access(path, os.W_OK) else: return self.hasWritePermission(os.path.dirname(path)) def getWriteDirectories(self, app): rootDir = self.optionMap.setPathFromOptionsOrEnv("TEXTTEST_TMP", app.getConfigValue("default_texttest_tmp")) # Location of temporary files from test runs if not os.path.isdir(rootDir) and not self.hasWritePermission(os.path.dirname(rootDir)): rootDir = self.optionMap.setPathFromOptionsOrEnv("", "$TEXTTEST_PERSONAL_CONFIG/tmp") writeDir = os.path.join(rootDir, self.getWriteDirectoryName(app)) localRootDir = self.optionMap.getPathFromOptionsOrEnv("TEXTTEST_LOCAL_TMP", app.getConfigValue("default_texttest_local_tmp")) # Location of temporary files on local disk from test runs. Defaults to value of TEXTTEST_TMP if localRootDir: return writeDir, os.path.join(localRootDir, self.getLocalWriteDirectoryName(app)) else: return writeDir, writeDir def getWriteDirectoryName(self, app): appDescriptor = self.getAppDescriptor() parts = self.getBasicRunDescriptors(app, appDescriptor) + self.getVersionDescriptors(appDescriptor) + \ [ self.getTimeDescriptor(), str(os.getpid()) ] return ".".join(parts) def getLocalWriteDirectoryName(self, app): return self.getWriteDirectoryName(app) def getBasicRunDescriptors(self, app, appDescriptor): appDescriptors = [ appDescriptor ] if appDescriptor else [] if self.useStaticGUI(app): return [ "static_gui" ] + appDescriptors elif appDescriptors: return appDescriptors elif self.getBatchSession(app): return [ self.getBatchSession(app) ] elif self.optionMap.has_key("g"): return [ "dynamic_gui" ] else: return [ "console" ] def getTimeDescriptor(self): return plugins.startTimeString().replace(":", "") def getAppDescriptor(self): givenAppDescriptor = self.optionValue("a") if givenAppDescriptor and "," not in givenAppDescriptor: return givenAppDescriptor def getVersionDescriptors(self, appDescriptor): givenVersion = self.optionValue("v") if givenVersion: # Commas in path names are a bit dangerous, some applications may have arguments like # -path path1,path2 and just do split on the path argument. # We try something more obscure instead... versionList = plugins.commasplit(givenVersion) if appDescriptor: parts = appDescriptor.split(".", 1) if len(parts) > 1: versionList = self.filterForApp(versionList, parts[1]) return [ "++".join(versionList) ] if versionList else [] else: return [] def filterForApp(self, versionList, appVersionDescriptor): filteredVersions = [] for version in versionList: if version != appVersionDescriptor: filteredVersions.append(version.replace(appVersionDescriptor + ".", "")) return filteredVersions def addGuiResponder(self, classes): from gtkgui.controller import GUIController classes.append(GUIController) def getReconnectSequence(self): actions = [ self.reconnectConfig.getReconnectAction() ] actions += [ self.getOriginalFilterer(), self.getTemporaryFilterer(), \ self.getTestComparator(), self.getFailureExplainer() ] return actions def getOriginalFilterer(self): if not self.optionMap.has_key("ignorefilters"): return rundependent.FilterOriginal(useFilteringStates=not self.batchMode()) def getTemporaryFilterer(self): if not self.optionMap.has_key("ignorefilters"): return rundependent.FilterTemporary(useFilteringStates=not self.batchMode()) def filterErrorText(self, app, errFile): filterAction = rundependent.FilterErrorText() return filterAction.getFilteredText(app, errFile, app) def applyFiltering(self, test, fileName, version): app = test.getAppForVersion(version) filterAction = rundependent.FilterAction() return filterAction.getFilteredText(test, fileName, app) def getTestProcessor(self): catalogueCreator = self.getCatalogueCreator() ignoreCatalogues = self.shouldIgnoreCatalogues() collator = self.getTestCollator() from traffic import SetUpCaptureMockHandlers, TerminateCaptureMockHandlers trafficSetup = SetUpCaptureMockHandlers(self.optionIntValue("rectraffic")) trafficTerminator = TerminateCaptureMockHandlers() return [ self.getExecHostFinder(), self.getWriteDirectoryMaker(), \ self.getWriteDirectoryPreparer(ignoreCatalogues), \ trafficSetup, catalogueCreator, collator, self.getOriginalFilterer(), self.getTestRunner(), \ trafficTerminator, catalogueCreator, collator, self.getTestEvaluator() ] def isRecording(self): return self.optionMap.has_key("record") def shouldIgnoreCatalogues(self): return self.optionMap.has_key("ignorecat") or self.isRecording() def hasPerformance(self, app, perfType=""): extractors = app.getConfigValue("performance_logfile_extractor") if (perfType and extractors.has_key(perfType)) or (not perfType and len(extractors) > 0): return True else: return app.hasAutomaticCputimeChecking() def hasAutomaticCputimeChecking(self, app): return len(app.getCompositeConfigValue("performance_test_machine", "cputime")) > 0 def getFilterFileDirectories(self, apps, useOwnTmpDir): # # - For each application, collect # - temporary filter dir # - all dirs in filter_file_directory # # Add these to a list. Never add the same dir twice. The first item will # be the default save/open dir, and the others will be added as shortcuts. # dirs = [] for app in apps: writeDir = app.writeDirectory if useOwnTmpDir else None dirs += self._getFilterFileDirs(app, app.getDirectory(), writeDir) return dirs def _getFilterFileDirs(self, suiteOrApp, rootDir, writeDir=None): dirs = [] appDirs = suiteOrApp.getConfigValue("filter_file_directory") tmpDir = self.getTmpFilterDir(writeDir) if tmpDir and tmpDir not in dirs: dirs.append(tmpDir) for dir in appDirs: if os.path.isabs(dir) and os.path.isdir(dir): if dir not in dirs: dirs.append(dir) else: newDir = os.path.join(rootDir, dir) if not newDir in dirs: dirs.append(newDir) return dirs def getTmpFilterDir(self, writeDir): cmdLineDir = self.optionValue("fd") if cmdLineDir: return os.path.normpath(cmdLineDir) elif writeDir: return os.path.join(writeDir, "temporary_filter_files") def getFilterClasses(self): return [ TestNameFilter, plugins.TestSelectionFilter, TestRelPathFilter, performance.TimeFilter, performance.FastestFilter, performance.SlowestFilter, plugins.ApplicationFilter, TestDescriptionFilter ] def getAbsoluteFilterFileName(self, suite, filterFileName): if os.path.isabs(filterFileName): if os.path.isfile(filterFileName): return filterFileName else: raise plugins.TextTestError, "Could not find filter file at '" + filterFileName + "'" else: dirsToSearchIn = self._getFilterFileDirs(suite, suite.app.getDirectory()) absName = suite.app.getFileName(dirsToSearchIn, filterFileName) if absName: return absName else: raise plugins.TextTestError, "No filter file named '" + filterFileName + "' found in :\n" + \ "\n".join(dirsToSearchIn) def optionListValue(self, options, key): if options.has_key(key): return plugins.commasplit(options[key]) else: return [] def findFilterFileNames(self, app, options, includeConfig): names = self.optionListValue(options, "f") + self.optionListValue(options, "fintersect") if includeConfig: names += app.getConfigValue("default_filter_file") batchSession = self.getBatchSessionForSelect(app) if batchSession: names += app.getCompositeConfigValue("batch_filter_file", batchSession) return names def findAllFilterFileNames(self, app, options, includeConfig): return self.findFilterFileNames(app, options, includeConfig) + \ self.optionListValue(options, "funion") + self.optionListValue(options, "finverse") def getFilterList(self, app, suites, options=None, **kw): if options is None: return self.filterFileMap.setdefault(app, self._getFilterList(app, self.optionMap, suites, includeConfig=True, **kw)) else: return self._getFilterList(app, options, suites, includeConfig=False, **kw) def checkFilterFileSanity(self, suite): # This will check all the files for existence from the input, and throw if it can't. # This is basically because we don't want to throw in a thread when we actually need the filters # if they aren't sensible for some reason self._checkFilterFileSanity(suite, self.optionMap, includeConfig=True) def _checkFilterFileSanity(self, suite, options, includeConfig=False): for filterFileName in self.findAllFilterFileNames(suite.app, options, includeConfig): optionFinder = self.makeOptionFinder(suite, filterFileName) self._checkFilterFileSanity(suite, optionFinder) def _getFilterList(self, app, options, suites, includeConfig, **kw): filters = self.getFiltersFromMap(options, app, suites, **kw) for filterFileName in self.findFilterFileNames(app, options, includeConfig): filters += self.getFiltersFromFile(app, filterFileName, suites) if self.isReconnecting(): filters.append(self.reconnectConfig.getFilter()) orFilterFiles = self.optionListValue(options, "funion") if len(orFilterFiles) > 0: orFilterLists = [ self.getFiltersFromFile(app, f, suites) for f in orFilterFiles ] filters.append(OrFilter(orFilterLists)) notFilterFile = options.get("finverse") if notFilterFile: filters.append(NotFilter(self.getFiltersFromFile(app, notFilterFile, suites))) return filters def makeOptionFinder(self, *args): absName = self.getAbsoluteFilterFileName(*args) fileData = ",".join(plugins.readList(absName)) return plugins.OptionFinder(fileData.split(), defaultKey="t") def getFiltersFromFile(self, app, filename, suites): for suite in suites: if suite.app is app: optionFinder = self.makeOptionFinder(suite, filename) return self._getFilterList(app, optionFinder, suites, includeConfig=False) def getFiltersFromMap(self, optionMap, app, suites, **kw): filters = [] for filterClass in self.getFilterClasses(): argument = optionMap.get(filterClass.option) if argument: filters.append(filterClass(argument, app, suites)) batchSession = self.getBatchSessionForSelect(app) if batchSession: timeLimit = app.getCompositeConfigValue("batch_timelimit", batchSession) if timeLimit: filters.append(performance.TimeFilter(timeLimit)) if optionMap.has_key("grep"): grepFile = optionMap.get("grepfile", app.getConfigValue("log_file")) filters.append(GrepFilter(optionMap["grep"], grepFile, **kw)) return filters def batchMode(self): return self.optionMap.has_key("b") def keepTemporaryDirectories(self): if "keeptmp" in self.optionMap: return self.optionMap.get("keeptmp") != "0" else: return self.batchMode() and not self.isReconnecting() def hasKeeptmpFlag(self): return "keeptmp" in self.optionMap and self.optionMap.get("keeptmp") != "0" def cleanPreviousTempDirs(self): return self.batchMode() and not self.isReconnecting() and "keeptmp" not in self.optionMap def cleanWriteDirectory(self, suite): if self.removePreviousThread and self.removePreviousThread.isAlive(): plugins.log.info("Waiting for removal of previous write directories to complete...") self.removePreviousThread.join() Config.removePreviousThread = None if not self.hasKeeptmpFlag(): self._cleanLocalWriteDirectory(suite) if not self.keepTemporaryDirectories(): self._cleanWriteDirectory(suite) machine, tmpDir = self.getRemoteTmpDirectory(suite.app) if tmpDir: self.cleanRemoteDir(suite.app, machine, tmpDir) def cleanRemoteDir(self, app, machine, tmpDir): self.runCommandOn(app, machine, [ "rm", "-rf", tmpDir ]) def _cleanWriteDirectory(self, suite): if os.path.isdir(suite.app.writeDirectory): plugins.rmtree(suite.app.writeDirectory) def _cleanLocalWriteDirectory(self, suite): if suite.app.localWriteDirectory != suite.app.writeDirectory and os.path.isdir(suite.app.localWriteDirectory): plugins.rmtree(suite.app.localWriteDirectory) def findRemotePreviousDirInfo(self, app): machine, tmpDir = self.getRemoteTmpDirectory(app) if tmpDir: # Ignore the datetime and the pid at the end searchParts = tmpDir.split(".")[:-2] + ["*"] fileArg = ".".join(searchParts) return machine, fileArg else: return None, None def cleanPreviousWriteDirs(self, previousWriteDirs): for previousWriteDir in previousWriteDirs: plugins.rmtree(previousWriteDir, attempts=3) def makeWriteDirectory(self, app, subdir=None): if not self.removePreviousThread and self.cleanPreviousTempDirs(): previousWriteDirs = self.findPreviousWriteDirs(app.writeDirectory) machine, fileArg = self.findRemotePreviousDirInfo(app) if fileArg: plugins.log.info("Removing previous remote write directories on " + machine + " matching " + fileArg) self.runCommandOn(app, machine, [ "rm", "-rf", fileArg ]) for previousWriteDir in previousWriteDirs: plugins.log.info("Removing previous write directory " + previousWriteDir + " in background") if previousWriteDirs: thread = Thread(target=self.cleanPreviousWriteDirs, args=(previousWriteDirs,)) thread.start() Config.removePreviousThread = thread dirToMake = app.writeDirectory if subdir: dirToMake = os.path.join(app.writeDirectory, subdir) plugins.ensureDirectoryExists(dirToMake) app.diag.info("Made root directory at " + dirToMake) return dirToMake def findPreviousWriteDirs(self, writeDir): previousWriteDirs = [] rootDir, basename = os.path.split(writeDir) if os.path.isdir(rootDir): # Ignore the datetime and the pid at the end searchParts = basename.split(".")[:-2] for file in os.listdir(rootDir): fileParts = file.split(".") if fileParts[:-2] == searchParts: previousWriteDir = os.path.join(rootDir, file) if os.path.isdir(previousWriteDir) and not plugins.samefile(previousWriteDir, writeDir): previousWriteDirs.append(previousWriteDir) return previousWriteDirs def isReconnecting(self): return self.optionMap.has_key("reconnect") def getWriteDirectoryMaker(self): return sandbox.MakeWriteDirectory() def getExecHostFinder(self): return sandbox.FindExecutionHosts() def getWriteDirectoryPreparer(self, ignoreCatalogues): return sandbox.PrepareWriteDirectory(ignoreCatalogues) def getTestRunner(self): return RunTest() def getTestEvaluator(self): return [ self.getFileExtractor(), self.getTemporaryFilterer(), self.getTestComparator(), self.getFailureExplainer() ] def getFileExtractor(self): return [ self.getPerformanceFileMaker(), self.getPerformanceExtractor() ] def getCatalogueCreator(self): return sandbox.CreateCatalogue() def getTestCollator(self): return sandbox.CollateFiles() def getPerformanceExtractor(self): return sandbox.ExtractPerformanceFiles(self.getMachineInfoFinder()) def getPerformanceFileMaker(self): return sandbox.MakePerformanceFile(self.getMachineInfoFinder()) def executingOnPerformanceMachine(self, test): infoFinder = self.getMachineInfoFinder() infoFinder.setUpApplication(test.app) return infoFinder.allMachinesTestPerformance(test, "cputime") def getMachineInfoFinder(self): return sandbox.MachineInfoFinder() def getFailureExplainer(self): from knownbugs import CheckForBugs, CheckForCrashes return [ CheckForCrashes(), CheckForBugs() ] def showExecHostsInFailures(self, app): return self.batchMode() or app.getRunMachine() != "localhost" def getTestComparator(self): return comparetest.MakeComparisons(enableColor=self.optionMap.has_key("zen")) def getStateSaver(self): if self.batchMode() and not self.isReconnecting(): return batch.SaveState elif self.keepTemporaryDirectories(): return SaveState def getConfigEnvironment(self, test, allVars): testEnvironmentCreator = self.getEnvironmentCreator(test) return testEnvironmentCreator.getVariables(allVars) def getEnvironmentCreator(self, test): return sandbox.TestEnvironmentCreator(test, self.optionMap) def getInteractiveReplayOptions(self): return [ ("gui", "visible GUI") ] def getTextResponder(self): return console.InteractiveResponder def getWebPageResponder(self): return batch.WebPageResponder # Utilities, which prove useful in many derived classes def optionValue(self, option): return self.optionMap.get(option, "") def optionIntValue(self, option): if self.optionMap.has_key(option): value = self.optionMap.get(option) return int(value) if value is not None else 1 else: return 0 def ignoreExecutable(self): return self.optionMap.has_key("s") or self.ignoreCheckout() or self.optionMap.has_key("coll") or self.optionMap.has_key("gx") def ignoreCheckout(self): return self.isReconnecting() # No use of checkouts has yet been thought up when reconnecting :) def setUpCheckout(self, app): return self.getGivenCheckoutPath(app) if not self.ignoreCheckout() else "" def verifyCheckoutValid(self, app): if not os.path.isabs(app.checkout): raise plugins.TextTestError, "could not create absolute checkout from relative path '" + app.checkout + "'" elif not os.path.isdir(app.checkout): self.handleNonExistent(app.checkout, "checkout", app) def checkCheckoutExists(self, app): if not app.checkout: return "" # Allow empty checkout, means no checkout is set, basically try: self.verifyCheckoutValid(app) except plugins.TextTestError, e: if self.ignoreExecutable(): plugins.printWarning(str(e), stdout=True) return "" else: raise def checkSanity(self, suite): if not self.ignoreCheckout(): self.checkCheckoutExists(suite.app) if not self.ignoreExecutable(): self.checkExecutableExists(suite) self.checkFilterFileSanity(suite) self.checkCaptureMockMigration(suite) self.checkConfigSanity(suite.app) batchSession = self.getBatchSessionForSelect(suite.app) if self.optionMap.has_key("coll") and batchSession is None: raise plugins.TextTestError, "Must provide '-b' argument to identify the batch session when running with '-coll' to collect batch run data" if batchSession is not None and not self.optionMap.has_key("coll"): batchFilter = batch.BatchVersionFilter(batchSession) batchFilter.verifyVersions(suite.app) if self.isReconnecting(): self.reconnectConfig.checkSanity(suite.app) # side effects really from here on :( if self.readsTestStateFiles(): # Reading stuff from stored pickle files, need to set up categories independently self.setUpPerformanceCategories(suite.app) def checkCaptureMockMigration(self, suite): if (suite.getCompositeConfigValue("collect_traffic", "asynchronous") or \ suite.getConfigValue("collect_traffic_python")) and \ not self.optionMap.runScript(): raise plugins.TextTestError, "collect_traffic settings have been deprecated.\n" + \ "They have been replaced by using the CaptureMock program which is now separate from TextTest.\n" + \ "Please run with '-s traffic.ConvertToCaptureMock' and consult the migration notes at\n" + \ os.path.join(plugins.installationDir("doc"), "MigrationNotes_from_3.20") + "\n" def readsTestStateFiles(self): return self.isReconnecting() or self.optionMap.has_key("coll") def setUpPerformanceCategories(self, app): # We don't create these in the normal way, so we don't know what they are. allCategories = app.getConfigValue("performance_descriptor_decrease").values() + \ app.getConfigValue("performance_descriptor_increase").values() for cat in allCategories: if cat: plugins.addCategory(*plugins.commasplit(cat)) def checkExecutableExists(self, suite): executable = suite.getConfigValue("executable") if self.executableShouldBeFile(suite.app, executable) and not os.path.isfile(executable): self.handleNonExistent(executable, "executable program", suite.app) for interpreterStr in suite.getConfigValue("interpreters").values(): interpreter = plugins.splitcmd(interpreterStr)[0] if os.path.isabs(interpreter) and not os.path.exists(interpreter): self.handleNonExistent(interpreter, "interpreter program", suite.app) def pathExistsRemotely(self, app, path, machine): exitCode = self.runCommandOn(app, machine, [ "test", "-e", path ], collectExitCode=True) return exitCode == 0 def checkConnection(self, app, machine): self.runCommandAndCheckMachine(app, machine, [ "echo", "hello" ]) def handleNonExistent(self, path, desc, app): message = "The " + desc + " '" + path + "' does not exist" remoteCopy = app.getConfigValue("remote_copy_program") if remoteCopy: runMachine = app.getRunMachine() if runMachine != "localhost": if not self.pathExistsRemotely(app, path, runMachine): self.checkConnection(app, runMachine) # throws if we can't get to it raise plugins.TextTestError, message + ", either locally or on machine '" + runMachine + "'." else: raise plugins.TextTestError, message + "." def getRemoteTmpDirectory(self, app): remoteCopy = app.getConfigValue("remote_copy_program") if remoteCopy: runMachine = app.getRunMachine() if runMachine != "localhost": return runMachine, "${HOME}/.texttest/tmp/" + os.path.basename(app.writeDirectory) return "localhost", None def getRemoteTestTmpDir(self, test): machine, appTmpDir = self.getRemoteTmpDirectory(test.app) if appTmpDir: return machine, os.path.join(appTmpDir, test.app.name + test.app.versionSuffix(), test.getRelPath()) else: return machine, appTmpDir def hasChanged(self, var, value): return os.getenv(var) != value def executableShouldBeFile(self, app, executable): if os.path.isabs(executable): return True # If it's part of the data it will be available as a relative path anyway if executable in app.getDataFileNames(): return False # For finding java classes, don't warn if they don't exist as files... if executable.endswith(".jar"): return False interpreters = app.getConfigValue("interpreters").values() return all(("java" not in i and "jython" not in i for i in interpreters)) def checkConfigSanity(self, app): for key in app.getConfigValue("collate_file"): if "." in key or "/" in key: raise plugins.TextTestError, "Cannot collate files to stem '" + key + "' - '.' and '/' characters are not allowed" definitionFileStems = app.defFileStems() definitionFileStems += [ stem + "." + app.name for stem in definitionFileStems ] for dataFileName in app.getDataFileNames(): if dataFileName in definitionFileStems: raise plugins.TextTestError, "Cannot name data files '" + dataFileName + \ "' - this name is reserved by TextTest for a particular kind of definition file.\n" + \ "Please adjust the naming in your config file." def getGivenCheckoutPath(self, app): if self.optionMap.has_key("c"): extraVersions, extraCheckouts = self.getCheckoutExtraVersions(app) for versionName, checkout in zip(extraVersions, extraCheckouts): if versionName in app.versions: return checkout checkout = self.getCheckout(app) return self.expandCheckout(checkout, app) def expandCheckout(self, checkout, app): if os.path.isabs(checkout): return os.path.normpath(checkout) checkoutLocations = app.getCompositeConfigValue("checkout_location", checkout, expandVars=False) if len(checkoutLocations) > 0: return self.makeAbsoluteCheckout(checkoutLocations, checkout, app) else: return checkout def getCheckout(self, app): if self.optionMap.has_key("c"): return plugins.commasplit(self.optionMap["c"])[0] # Under some circumstances infer checkout from batch session batchSession = self.getBatchSession(app) if batchSession and batchSession != "default" and \ app.getConfigValue("checkout_location").has_key(batchSession): return batchSession else: return app.getConfigValue("default_checkout") def makeAbsoluteCheckout(self, locations, checkout, app): isSpecific = app.getConfigValue("checkout_location").has_key(checkout) for location in locations: fullCheckout = self.absCheckout(location, checkout, isSpecific) if os.path.isdir(fullCheckout): return fullCheckout return self.absCheckout(locations[0], checkout, isSpecific) def absCheckout(self, location, checkout, isSpecific): locationWithName = Template(location).safe_substitute(TEXTTEST_CHECKOUT_NAME=checkout) fullLocation = os.path.normpath(os.path.expanduser(os.path.expandvars(locationWithName))) if isSpecific or "TEXTTEST_CHECKOUT_NAME" in location: return fullLocation else: # old-style: infer expansion in default checkout return os.path.join(fullLocation, checkout) def recomputeProgress(self, test, state, observers): if state.isComplete(): if state.hasResults(): state.recalculateStdFiles(test) fileFilter = rundependent.FilterResultRecompute() fileFilter(test) state.recalculateComparisons(test) newState = state.makeNewState(test, "recalculated") test.changeState(newState) else: collator = test.app.getTestCollator() collator.tryFetchRemoteFiles(test) fileFilter = rundependent.FilterProgressRecompute() fileFilter(test) comparator = self.getTestComparator() comparator.recomputeProgress(test, state, observers) def getRunDescription(self, test): return RunTest().getRunDescription(test) def expandExternalEnvironment(self): return True # For display in the GUI def extraReadFiles(self, testArg): return {} def printHelpScripts(self): pass def printHelpDescription(self): print "The " + self.__class__.__module__ + " configuration is a published configuration. Consult the online documentation." def printHelpOptions(self): pass def printHelpText(self): self.printHelpDescription() print "\nAdditional Command line options supported :" print "-------------------------------------------" self.printHelpOptions() print "\nPython scripts: (as given to -s <module>.<class> [args])" print "--------------------------------------------------------" self.printHelpScripts() def getDefaultMailAddress(self): user = os.getenv("USER", "$USER") return user + "@localhost" def getDefaultTestOverviewColours(self): colours = {} for wkday in plugins.weekdays: colours["run_" + wkday + "_fg"] = "black" colours["column_header_bg"] = "gray1" colours["changes_header_bg"] = "#E2E2FF" colours["row_header_bg"] = "#FFFFCC" colours["performance_fg"] = "red6" colours["memory_bg"] = "pink" colours["success_bg"] = "#CEEFBD" colours["failure_bg"] = "#FF3118" colours["knownbug_bg"] = "#FF9900" colours["incomplete_bg"] = "#8B1A1A" colours["no_results_bg"] = "gray2" colours["performance_bg"] = "#FFC6A5" colours["test_default_fg"] = "black" return colours def getDefaultPageName(self, app): pageName = app.fullName() fullVersion = app.getFullVersion() if fullVersion: pageName += " - version " + fullVersion return pageName def getDefaultCollectCompulsoryVersions(self): return { "default" : [] } def setBatchDefaults(self, app): # Batch values. Maps from session name to values app.setConfigDefault("smtp_server", "localhost", "Server to use for sending mail in batch mode") app.setConfigDefault("smtp_server_username", "", "Username for SMTP authentication when sending mail in batch mode") app.setConfigDefault("smtp_server_password", "", "Password for SMTP authentication when sending mail in batch mode") app.setConfigDefault("batch_result_repository", { "default" : "" }, "Directory to store historical batch results under") app.setConfigDefault("file_to_url", {}, "Mapping of file locations to URLS, for linking to HTML reports") app.setConfigDefault("historical_report_location", { "default" : "" }, "Directory to create reports on historical batch data under") app.setConfigDefault("historical_report_page_name", { "default" : self.getDefaultPageName(app) }, "Header for page on which this application should appear") app.setConfigDefault("historical_report_colours", self.getDefaultTestOverviewColours(), "Colours to use for historical batch HTML reports") app.setConfigDefault("historical_report_subpages", { "default" : [ "Last six runs" ]}, "Names of subselection pages to generate as part of historical report") app.setConfigDefault("historical_report_subpage_cutoff", { "default" : 100000, "Last six runs" : 6 }, "How many runs should the subpage show, starting from the most recent?") app.setConfigDefault("historical_report_subpage_weekdays", { "default" : [] }, "Which weekdays should the subpage apply to (empty implies all)?") app.setConfigDefault("historical_report_resource_pages", { "default": [ "" ] }, "Which performance/memory pages should be generated by default on running -coll") app.setConfigDefault("historical_report_resource_page_tables", { "default": []}, "Resource names to generate the tables for the relevant performance/memory pages") app.setConfigDefault("historical_report_piechart_summary", { "default": "false" }, "Generate pie chart summary page rather than default HTML tables.") app.setConfigDefault("batch_sender", { "default" : self.getDefaultMailAddress() }, "Sender address to use sending mail in batch mode") app.setConfigDefault("batch_recipients", { "default" : "" }, "Comma-separated addresses to send mail to in batch mode") app.setConfigDefault("batch_timelimit", { "default" : "" }, "Maximum length of test to include in batch mode runs") app.setConfigDefault("batch_filter_file", { "default" : [] }, "Generic filter for batch session, more flexible than timelimit") app.setConfigDefault("batch_use_collection", { "default" : "false" }, "Do we collect multiple mails into one in batch mode") app.setConfigDefault("batch_junit_format", { "default" : "false" }, "Do we write out results in junit format in batch mode") app.setConfigDefault("batch_junit_folder", { "default" : "" }, "Which folder to write test results in junit format in batch mode. Only useful together with batch_junit_format") app.setConfigDefault("batch_collect_max_age_days", { "default" : 100000 }, "When collecting multiple messages, what is the maximum age of run that we should accept?") app.setConfigDefault("batch_collect_compulsory_version", self.getDefaultCollectCompulsoryVersions(), "When collecting multiple messages, which versions should be expected and give an error if not present?") app.setConfigDefault("batch_mail_on_failure_only", { "default" : "false" }, "Send mails only if at least one test fails") app.setConfigDefault("batch_use_version_filtering", { "default" : "false" }, "Which batch sessions use the version filtering mechanism") app.setConfigDefault("batch_version", { "default" : [] }, "List of versions to allow if batch_use_version_filtering enabled") app.setConfigAlias("testoverview_colours", "historical_report_colours") def setPerformanceDefaults(self, app): # Performance values app.setConfigDefault("cputime_include_system_time", 0, "Include system time when measuring CPU time?") app.setConfigDefault("default_performance_stem", "performance", "Which performance statistic to use when selecting tests by performance, placing performance in Junit XML reports etc") app.setConfigDefault("performance_logfile", { "default" : [] }, "Which result file to collect performance data from") app.setConfigDefault("performance_logfile_extractor", {}, "What string to look for when collecting performance data") app.setConfigDefault("performance_test_machine", { "default" : [], "*mem*" : [ "any" ] }, \ "List of machines where performance can be collected") app.setConfigDefault("performance_variation_%", { "default" : 10.0 }, "How much variation in performance is allowed") app.setConfigDefault("performance_variation_serious_%", { "default" : 0.0 }, "Additional cutoff to performance_variation_% for extra highlighting") app.setConfigDefault("use_normalised_percentage_change", { "default" : "true" }, \ "Do we interpret performance percentage changes as normalised (symmetric) values?") app.setConfigDefault("performance_test_minimum", { "default" : 0.0 }, \ "Minimum time/memory to be consumed before data is collected") app.setConfigDefault("performance_descriptor_decrease", self.defaultPerfDecreaseDescriptors(), "Descriptions to be used when the numbers decrease in a performance file") app.setConfigDefault("performance_descriptor_increase", self.defaultPerfIncreaseDescriptors(), "Descriptions to be used when the numbers increase in a performance file") app.setConfigDefault("performance_unit", self.defaultPerfUnits(), "Name to be used to identify the units in a performance file") app.setConfigDefault("performance_ignore_improvements", { "default" : "false" }, "Should we ignore all improvements in performance?") app.setConfigAlias("performance_use_normalised_%", "use_normalised_percentage_change") app.setConfigAlias("batch_junit_performance", "default_performance_stem") def setUsecaseDefaults(self, app): app.setConfigDefault("use_case_record_mode", "disabled", "Mode for Use-case recording (GUI, console or disabled)") app.setConfigDefault("use_case_recorder", "", "Which Use-case recorder is being used") app.setConfigDefault("virtual_display_machine", [ "localhost" ], \ "(UNIX) List of machines to run virtual display server (Xvfb) on") app.setConfigDefault("virtual_display_count", 1, \ "(UNIX) Number of virtual display server (Xvfb) instances to run, if enabled") app.setConfigDefault("virtual_display_extra_args", "", \ "(UNIX) Extra arguments (e.g. bitdepth) to supply to virtual display server (Xvfb)") app.setConfigDefault("virtual_display_hide_windows", "true", "(Windows) Whether to emulate the virtual display handling on Windows by hiding the SUT's windows") def defaultPerfUnits(self): units = {} units["default"] = "seconds" units["*mem*"] = "MB" return units def defaultPerfDecreaseDescriptors(self): descriptors = {} descriptors["default"] = "" descriptors["memory"] = "smaller, memory-, used less memory" descriptors["cputime"] = "faster, faster, ran faster" return descriptors def defaultPerfIncreaseDescriptors(self): descriptors = {} descriptors["default"] = "" descriptors["memory"] = "larger, memory+, used more memory" descriptors["cputime"] = "slower, slower, ran slower" return descriptors def defaultSeverities(self): severities = {} severities["errors"] = 1 severities["output"] = 1 severities["stderr"] = 1 severities["stdout"] = 1 severities["usecase"] = 1 severities["performance"] = 2 severities["catalogue"] = 2 severities["default"] = 99 return severities def defaultDisplayPriorities(self): prios = {} prios["default"] = 99 return prios def getDefaultCollations(self): if os.name == "posix": return { "stacktrace" : [ "core*" ] } else: return { "" : [] } def getDefaultCollateScripts(self): if os.name == "posix": return { "default" : [], "stacktrace" : [ "interpretcore.py" ] } else: return { "default" : [] } def getStdoutName(self, namingScheme): if namingScheme == "classic": return "output" else: return "stdout" def getStderrName(self, namingScheme): if namingScheme == "classic": return "errors" else: return "stderr" def getStdinName(self, namingScheme): if namingScheme == "classic": return "input" else: return "stdin" def setComparisonDefaults(self, app, homeOS, namingScheme): app.setConfigDefault("log_file", self.getStdoutName(namingScheme), "Result file to search, by default") app.setConfigDefault("failure_severity", self.defaultSeverities(), \ "Mapping of result files to how serious diffs in them are") app.setConfigDefault("failure_display_priority", self.defaultDisplayPriorities(), \ "Mapping of result files to which order they should be shown in the text info window.") app.setConfigDefault("floating_point_tolerance", { "default" : 0.0 }, "Which tolerance to apply when comparing floating point values in output") app.setConfigDefault("relative_float_tolerance", { "default" : 0.0 }, "Which relative tolerance to apply when comparing floating point values") app.setConfigDefault("collate_file", self.getDefaultCollations(), "Mapping of result file names to paths to collect them from") app.setConfigDefault("collate_script", self.getDefaultCollateScripts(), "Mapping of result file names to scripts which turn them into suitable text") trafficText = "Deprecated. Use CaptureMock." app.setConfigDefault("collect_traffic", { "default": [], "asynchronous": [] }, trafficText) app.setConfigDefault("collect_traffic_environment", { "default" : [] }, trafficText) app.setConfigDefault("collect_traffic_python", [], trafficText) app.setConfigDefault("collect_traffic_python_ignore_callers", [], trafficText) app.setConfigDefault("collect_traffic_use_threads", "true", trafficText) app.setConfigDefault("collect_traffic_client_server", "false", trafficText) app.setConfigDefault("run_dependent_text", { "default" : [] }, "Mapping of patterns to remove from result files") app.setConfigDefault("unordered_text", { "default" : [] }, "Mapping of patterns to extract and sort from result files") app.setConfigDefault("file_split_pattern", {}, "Pattern to use for splitting result files") app.setConfigDefault("create_catalogues", "false", "Do we create a listing of files created/removed by tests") app.setConfigDefault("catalogue_process_string", "", "String for catalogue functionality to identify processes created") app.setConfigDefault("binary_file", [], "Which output files are known to be binary, and hence should not be shown/diffed?") app.setConfigDefault("discard_file", [], "List of generated result files which should not be compared") app.setConfigDefault("discard_file_text", { "default" : [] }, "List of generated result files which should not be compared if they contain the given patterns") rectrafficValue = self.optionIntValue("rectraffic") if rectrafficValue == 1: # Re-record everything. Don't use this when only recording additional new stuff # Should possibly have some way to configure this app.addConfigEntry("implied", "rectraffic", "base_version") if self.isRecording(): app.addConfigEntry("implied", "recusecase", "base_version") if homeOS != "any" and homeOS != os.name: app.addConfigEntry("implied", os.name, "base_version") app.setConfigAlias("collect_traffic_py_module", "collect_traffic_python") def defaultViewProgram(self, homeOS): if os.name == "posix": return "emacs" else: if homeOS == "posix": # Notepad cannot handle UNIX line-endings: for cross platform suites use wordpad by default... return "wordpad" else: return "notepad" def defaultFollowProgram(self): if os.name == "posix": return "xterm -bg white -T $TEXTTEST_FOLLOW_FILE_TITLE -e tail -f" else: return "baretail" def setExternalToolDefaults(self, app, homeOS): app.setConfigDefault("text_diff_program", "diff", \ "External program to use for textual comparison of files") app.setConfigDefault("lines_of_text_difference", 30, "How many lines to present in textual previews of file diffs") app.setConfigDefault("max_width_text_difference", 500, "How wide lines can be in textual previews of file diffs") app.setConfigDefault("max_file_size", { "default": "-1" }, "The maximum file size to load into external programs, in bytes. -1 means no limit.") app.setConfigDefault("text_diff_program_filters", { "default" : [], "diff" : [ "^<", "^>" ]}, "Filters that should be applied for particular diff tools to aid with grouping in dynamic GUI") app.setConfigDefault("diff_program", { "default": "tkdiff" }, "External program to use for graphical file comparison") app.setConfigDefault("view_program", { "default": self.defaultViewProgram(homeOS) }, \ "External program(s) to use for viewing and editing text files") app.setConfigDefault("view_file_on_remote_machine", { "default" : 0 }, "Do we try to start viewing programs on the test execution machine?") app.setConfigDefault("follow_program", { "default": self.defaultFollowProgram() }, "External program to use for following progress of a file") app.setConfigDefault("follow_file_by_default", 0, "When double-clicking running files, should we follow progress or just view them?") app.setConfigDefault("bug_system_location", {}, "The location of the bug system we wish to extract failure information from.") app.setConfigDefault("bug_system_username", {}, "Username to use when logging in to bug systems defined in bug_system_location") app.setConfigDefault("bug_system_password", {}, "Password to use when logging in to bug systems defined in bug_system_location") app.setConfigDefault("batch_jenkins_marked_artefacts", { "default": [] }, "Artefacts to highlight in the report when they are updated") app.setConfigDefault("batch_jenkins_archive_file_pattern", { "default": "" }, "Path to the built files in the archive, in case Jenkins fingerprints need double-checking") app.setConfigAlias("text_diff_program_max_file_size", "max_file_size") def setInterfaceDefaults(self, app): app.setConfigDefault("default_interface", "static_gui", "Which interface to start if none of -con, -g and -gx are provided") # These configure the GUI but tend to have sensible defaults per application app.setConfigDefault("gui_entry_overrides", { "default" : "<not set>" }, "Default settings for entries in the GUI") app.setConfigDefault("gui_entry_options", { "default" : [] }, "Default drop-down box options for GUI entries") app.setConfigDefault("suppress_stderr_text", [], "List of patterns which, if written on TextTest's own stderr, should not be propagated to popups and further logfiles") app.setConfigAlias("suppress_stderr_popup", "suppress_stderr_text") def getDefaultRemoteProgramOptions(self): # The aim is to ensure they never hang, but always return errors if contact not possible # Disable warnings, they get in the way of output # Disable passwords: only use public key based authentication. # Also disable hostkey checking, we assume we don't run tests on untrusted hosts. # Also don't run tests on machines which take a very long time to connect to... sshOptions = "-o StrictHostKeyChecking=no -o BatchMode=yes -o ConnectTimeout=10" rsyncExcludeFile = plugins.installationPath("etc", "rsync_exclude_patterns") return { "default": "", "ssh" : "-q " + sshOptions, "rsync" : "-e 'ssh " + sshOptions + "' -av --copy-unsafe-links --exclude-from=" + rsyncExcludeFile, "scp": "-Crp " + sshOptions } def getCommandArgsOn(self, app, machine, cmdArgs, graphical=False, agentForwarding=False): if machine == "localhost": return cmdArgs else: args = self.getRemoteProgramArgs(app, "remote_shell_program") if graphical and args[0] == "ssh": args.append("-Y") if agentForwarding and args[0] == "ssh": args.append("-A") args.append(machine) if graphical and args[0] == "rsh": args += [ "env", "DISPLAY=" + self.getFullDisplay() ] args += cmdArgs if graphical: remoteTmp = app.getRemoteTmpDirectory()[1] if remoteTmp: args[-1] = args[-1].replace(app.writeDirectory, remoteTmp) for i in range(len(args)): # Remote shells cause spaces etc to be interpreted several times args[i] = args[i].replace(" ", "\ ") return args def getFullDisplay(self): display = os.getenv("DISPLAY", "") hostaddr = plugins.gethostname() if display.startswith(":"): return hostaddr + display else: return display.replace("localhost", hostaddr) def runCommandOn(self, app, machine, cmdArgs, collectExitCode=False): allArgs = self.getCommandArgsOn(app, machine, cmdArgs) if allArgs[0] == "rsh" and collectExitCode: searchStr = "remote cmd succeeded" # Funny tricks here because rsh does not forward the exit status of the program it runs allArgs += [ "&&", "echo", searchStr ] diag = logging.getLogger("remote commands") proc = subprocess.Popen(allArgs, stdin=open(os.devnull), stdout=subprocess.PIPE, stderr=subprocess.STDOUT) output = proc.communicate()[0] diag.info("Running remote command " + repr(allArgs) + ", output was:\n" + output) return searchStr not in output # Return an "exit code" which is 0 when we succeed! else: return subprocess.call(allArgs, stdin=open(os.devnull), stdout=open(os.devnull, "w"), stderr=subprocess.STDOUT) def runCommandAndCheckMachine(self, app, machine, cmdArgs): allArgs = self.getCommandArgsOn(app, machine, cmdArgs) proc = subprocess.Popen(allArgs, stdin=open(os.devnull), stdout=subprocess.PIPE, stderr=subprocess.STDOUT) output = proc.communicate()[0] exitCode = proc.returncode if exitCode > 0: raise plugins.TextTestError, "Unable to contact machine '" + machine + \ "'.\nMake sure you have passwordless access set up correctly. The failing command was:\n" + \ " ".join(allArgs) + "\n\nThe command produced the following output:\n" + output.strip() def ensureRemoteDirExists(self, app, machine, *dirnames): quotedDirs = map(plugins.quote, dirnames) self.runCommandAndCheckMachine(app, machine, [ "mkdir", "-p" ] + quotedDirs) @staticmethod def getRemotePath(fileName, machine): if machine == "localhost": # Right now the only way we can run remote execution on a Windows system is using Cygwin # Remote copy programs like 'scp' assume that colons separate hostnames and so don't work # on classic Windows paths. # Assume for now that we can convert it to a Cygwin path. drive, tail = os.path.splitdrive(fileName) if drive: cygwinDrive = '/cygdrive/' + drive[0].lower() return cygwinDrive + tail else: return fileName else: return machine + ":" + plugins.quote(fileName) def copyFileRemotely(self, app, srcFile, srcMachine, dstFile, dstMachine): srcPath = self.getRemotePath(srcFile, srcMachine) dstPath = self.getRemotePath(dstFile, dstMachine) args = self.getRemoteProgramArgs(app, "remote_copy_program") + [ srcPath, dstPath ] return subprocess.call(args, stdin=open(os.devnull), stdout=open(os.devnull, "w"), stderr=subprocess.STDOUT) def getRemoteProgramArgs(self, app, setting): progStr = app.getConfigValue(setting) progArgs = plugins.splitcmd(progStr) argStr = app.getCompositeConfigValue("remote_program_options", progArgs[0]) return progArgs + plugins.splitcmd(argStr) def setMiscDefaults(self, app, namingScheme): app.setConfigDefault("default_texttest_tmp", "$TEXTTEST_PERSONAL_CONFIG/tmp", "Default value for $TEXTTEST_TMP, if it is not set") app.setConfigDefault("default_texttest_local_tmp", "", "Default value for $TEXTTEST_LOCAL_TMP, if it is not set") app.setConfigDefault("checkout_location", { "default" : []}, "Absolute paths to look for checkouts under") app.setConfigDefault("default_checkout", "", "Default checkout, relative to the checkout location") app.setConfigDefault("remote_shell_program", "ssh", "Program to use for running commands remotely") app.setConfigDefault("remote_program_options", self.getDefaultRemoteProgramOptions(), "Default options to use for particular remote shell programs") app.setConfigDefault("remote_copy_program", "", "(UNIX) Program to use for copying files remotely, in case of non-shared file systems") app.setConfigDefault("default_filter_file", [], "Filter file to use by default, generally only useful for versions") app.setConfigDefault("test_data_environment", {}, "Environment variables to be redirected for linked/copied test data") app.setConfigDefault("filter_file_directory", [ "filter_files" ], "Default directories for test filter files, relative to an application directory.") app.setConfigDefault("extra_version", [], "Versions to be run in addition to the one specified") app.setConfigDefault("batch_extra_version", { "default" : [] }, "Versions to be run in addition to the one specified, for particular batch sessions") app.setConfigDefault("save_filtered_file_stems", [], "Files where the filtered version should be saved rather than the SUT output") # Applies to any interface... app.setConfigDefault("auto_sort_test_suites", 0, "Automatically sort test suites in alphabetical order. 1 means sort in ascending order, -1 means sort in descending order.") app.setConfigDefault("extra_test_process_postfix", [], "Postfixes to use on ordinary files to denote an additional run of the SUT to be triggered") app.addConfigEntry("builtin", "options", "definition_file_stems") app.addConfigEntry("regenerate", "usecase", "definition_file_stems") app.addConfigEntry("builtin", self.getStdinName(namingScheme), "definition_file_stems") app.addConfigEntry("builtin", "knownbugs", "definition_file_stems") app.setConfigAlias("test_list_files_directory", "filter_file_directory") def setApplicationDefaults(self, app): homeOS = app.getConfigValue("home_operating_system") namingScheme = app.getConfigValue("filename_convention_scheme") self.setComparisonDefaults(app, homeOS, namingScheme) self.setExternalToolDefaults(app, homeOS) self.setInterfaceDefaults(app) self.setMiscDefaults(app, namingScheme) self.setBatchDefaults(app) self.setPerformanceDefaults(app) self.setUsecaseDefaults(app) def setDependentConfigDefaults(self, app): # For setting up configuration where the config file needs to have been read first # Should return True if it does anything that could cause new config files to be found interpreters = app.getConfigValue("interpreters").values() if any(("python" in i or "storytext" in i for i in interpreters)): app.addConfigEntry("default", "testcustomize.py", "definition_file_stems") extraPostfixes = app.getConfigValue("extra_test_process_postfix") for interpreterName in app.getConfigValue("interpreters").keys(): stem = interpreterName + "_options" app.addConfigEntry("builtin", stem, "definition_file_stems") for postfix in extraPostfixes: app.addConfigEntry("builtin", stem + postfix, "definition_file_stems") namingScheme = app.getConfigValue("filename_convention_scheme") for postfix in extraPostfixes: app.addConfigEntry("builtin", "options" + postfix, "definition_file_stems") app.addConfigEntry("regenerate", "usecase" + postfix, "definition_file_stems") app.addConfigEntry("builtin", self.getStdinName(namingScheme) + postfix, "definition_file_stems") if app.getConfigValue("use_case_record_mode") == "GUI" and \ app.getConfigValue("use_case_recorder") in [ "", "storytext" ] and \ not any(("usecase" in k for k in app.getConfigValue("view_program"))): app.addConfigEntry("*usecase*", "storytext_editor", "view_program") return False class SaveState(plugins.Responder): def notifyComplete(self, test): if test.state.isComplete(): # might look weird but this notification also comes in scripts etc. test.saveState() class OrFilter(plugins.Filter): def __init__(self, filterLists): self.filterLists = filterLists def accepts(self, test): return reduce(operator.or_, (test.isAcceptedByAll(filters, checkContents=False) for filters in self.filterLists), False) def acceptsTestCase(self, test): return self.accepts(test) def acceptsTestSuite(self, suite): return self.accepts(suite) def acceptsTestSuiteContents(self, suite): return reduce(operator.or_, (self.contentsAccepted(suite, filters) for filters in self.filterLists), False) def contentsAccepted(self, suite, filters): return reduce(operator.and_, (filter.acceptsTestSuiteContents(suite) for filter in filters), True) class NotFilter(plugins.Filter): def __init__(self, filters): self.filters = filters def acceptsTestCase(self, test): return not test.isAcceptedByAll(self.filters) class TestNameFilter(plugins.TextFilter): option = "t" def acceptsTestCase(self, test): return self.stringContainsText(test.name) class TestRelPathFilter(plugins.TextFilter): option = "ts" def parseInput(self, filterText, *args): # Handle paths pasted from web page return [ text.replace(" ", "/") for text in plugins.commasplit(filterText) ] def acceptsTestCase(self, test): return self.stringContainsText(test.getRelPath()) class GrepFilter(plugins.TextFilter): def __init__(self, filterText, fileStem, useTmpFiles=False): plugins.TextFilter.__init__(self, filterText) self.fileStem = fileStem self.useTmpFiles = useTmpFiles def acceptsTestCase(self, test): if self.fileStem == "free_text": return self.stringContainsText(test.state.freeText) for logFile in self.findAllFiles(test): if self.matches(logFile): return True return False def findAllFiles(self, test): if self.useTmpFiles: files = [] try: for comparison in test.state.allResults: if comparison.tmpFile and fnmatch(comparison.stem, self.fileStem) and os.path.isfile(comparison.tmpFile): files.append(comparison.tmpFile) return files except AttributeError: return [] else: return self.findAllStdFiles(test) def findAllStdFiles(self, test): logFiles = [] for fileName in test.getFileNamesMatching(self.fileStem): if os.path.isfile(fileName): logFiles.append(fileName) else: test.refreshFiles() return self.findAllStdFiles(test) return logFiles def matches(self, logFile): for line in open(logFile).xreadlines(): if self.stringContainsText(line): return True return False class TestDescriptionFilter(plugins.TextFilter): option = "desc" def acceptsTestCase(self, test): return self.stringContainsText(test.description)
52.876982
316
0.651193
82,914
0.994328
0
0
707
0.008479
0
0
24,008
0.287911
dfc3450cc6a455bca7329de3130cbc552b8baa62
747
py
Python
2019/10 October/dp10302019.py
vishrutkmr7/DailyPracticeProblemsDIP
d1bfbc75f2024736c22c05385f753a90ddcfa0f5
[ "MIT" ]
5
2019-08-06T02:34:41.000Z
2022-01-08T03:03:16.000Z
2019/10 October/dp10302019.py
ourangzeb/DailyPracticeProblemsDIP
66c07af88754e5d59b243e3ee9f02db69f7c0a77
[ "MIT" ]
15
2021-06-01T14:04:16.000Z
2022-03-08T21:17:22.000Z
2019/10 October/dp10302019.py
ourangzeb/DailyPracticeProblemsDIP
66c07af88754e5d59b243e3ee9f02db69f7c0a77
[ "MIT" ]
4
2019-09-19T20:00:05.000Z
2021-08-16T11:31:51.000Z
# This problem was recently asked by LinkedIn: # Given a non-empty array where each element represents a digit of a non-negative integer, add one to the integer. # The most significant digit is at the front of the array and each element in the array contains only one digit. # Furthermore, the integer does not have leading zeros, except in the case of the number '0'. class Solution: def plusOne(self, digits): # Fill this in. num = "" for i in range(0, len(digits)): num = num + str(digits[i]) sol = int(num) + 1 sol = list(str(sol)) for j in range(0, len(sol)): sol[j] = int(sol[j]) return sol num = [2, 9, 9] print(Solution().plusOne(num)) # [3, 0, 0]
28.730769
114
0.619813
313
0.419009
0
0
0
0
0
0
393
0.526104
dfc40c993839966190091cb6ae4333cb9d7b2cc3
1,122
py
Python
kbr/run_utils.py
brugger/kbr-tools
95c8f8274e28b986e7fd91c8404026433488c940
[ "MIT" ]
1
2021-02-02T09:47:40.000Z
2021-02-02T09:47:40.000Z
kbr/run_utils.py
brugger/kbr-tools
95c8f8274e28b986e7fd91c8404026433488c940
[ "MIT" ]
1
2021-08-04T13:00:00.000Z
2021-08-04T13:00:00.000Z
kbr/run_utils.py
brugger/kbr-tools
95c8f8274e28b986e7fd91c8404026433488c940
[ "MIT" ]
null
null
null
import subprocess import sys import os class ExecutionInfo: def __init__(self, p_status: int, stdout: str, stderr: str): self.p_status = p_status self.stdout = stdout self.stderr = stderr def exit_fail(msg: str = "") -> None: print(msg) sys.exit(-1) def exit_ok(msg: str = "") -> None: print(msg) sys.exit(0) def launch_cmd(cmd: str, cwd: str = "", use_shell_env:bool=False) -> ExecutionInfo: effective_command = cmd d = None if use_shell_env: d = dict(os.environ) if cwd == '': p = subprocess.Popen(effective_command, stdout=subprocess.PIPE, shell=True, stderr=subprocess.PIPE, env=d) else: p = subprocess.Popen(effective_command, stdout=subprocess.PIPE, shell=True, stderr=subprocess.PIPE, cwd=cwd, env=d) stdout, stderr = p.communicate() p_status = p.wait() return ExecutionInfo(p_status, stdout, stderr) def print_outputs(e:ExecutionInfo) -> None: if e.stdout != b'': print(e.stdout.decode('utf-8').rstrip("\n")) if e.stderr != b'': print(e.stderr.decode('utf-8').rstrip("\n"))
23.375
123
0.632799
176
0.156863
0
0
0
0
0
0
36
0.032086
dfc40d4989f8ef494b36888ba91588827d76ffc5
2,614
py
Python
tests/client/test_files.py
philopon/datapane
d7d69865d4def0cbe6eb334acd9edeb829dd67e6
[ "Apache-2.0" ]
481
2020-04-25T05:40:21.000Z
2022-03-30T22:04:35.000Z
tests/client/test_files.py
tig/datapane
defae6776e73b07191c0a5804a50b284ec3c9a63
[ "Apache-2.0" ]
74
2020-04-28T10:47:35.000Z
2022-03-14T15:50:55.000Z
tests/client/test_files.py
admariner/datapane
c440eaf07bd1c1f2de3ff952e0fd8c78d636aa8f
[ "Apache-2.0" ]
41
2020-07-21T16:30:21.000Z
2022-02-21T22:50:27.000Z
from pathlib import Path import altair as alt import folium import matplotlib.pyplot as plt import numpy as np import pandas as pd import plotly.graph_objects as p_go import pytest from bokeh.layouts import column from bokeh.models import ColumnDataSource from bokeh.plotting import figure from pandas.io.formats.style import Styler from datapane.client.api.files import save data = pd.DataFrame({"x": np.random.randn(20), "y": np.random.randn(20)}) def test_save_base(tmp_path: Path, monkeypatch): # absolute filename tests # test with no filename save(data) save(data) # relative filename tests monkeypatch.chdir(tmp_path) save(data) def test_save_matplotlib(tmp_path: Path): pd.set_option("plotting.backend", "matplotlib") fig, ax = plt.subplots() data.plot.scatter("x", "y", ax=ax) # test svg default save(fig) # test save axes only save(ax) # test save ndarray save(data.hist()) def test_save_bokeh(tmp_path: Path): source = ColumnDataSource(data) p = figure() p.circle(x="x", y="y", source=source) f = save(p) assert f.mime == "application/vnd.bokeh.show+json" def test_save_bokeh_layout(tmp_path: Path): source = ColumnDataSource(data) p = figure() p.circle(x="x", y="y", source=source) f = save(column(p, p)) assert f.mime == "application/vnd.bokeh.show+json" def test_save_altair(tmp_path: Path): plot = alt.Chart(data).mark_bar().encode(y="y", x="x") save(plot) def test_save_folium(tmp_path: Path): map = folium.Map(location=[45.372, -121.6972], zoom_start=12, tiles="Stamen Terrain") save(map) def test_save_plotly(tmp_path: Path): fig = p_go.Figure() fig.add_trace(p_go.Scatter(x=[0, 1, 2, 3, 4, 5], y=[1.5, 1, 1.3, 0.7, 0.8, 0.9])) save(fig) # NOTE - test disabled until pip release of altair_pandas - however should work if altair test passes @pytest.mark.skip(reason="altair_pandas not yet supported") def test_save_altair_pandas(tmp_path: Path): pd.set_option("plotting.backend", "altair") # Installing altair_pandas registers this. plot = data.plot.scatter("x", "y") save(plot) # NOTE - test disabled updated pip release of pdvega that tracks git upstream - however should work if altair test passes @pytest.mark.skip(reason="pdvega not yet supported") def test_save_pdvega(tmp_path: Path): import pdvega # noqa: F401 plot = data.vgplot.scatter("x", "y") save(plot) def test_save_table(tmp_path: Path): # tests saving a DF directly to a html file save(data) # save styled table save(Styler(data))
26.948454
121
0.694721
0
0
0
0
429
0.164116
0
0
708
0.270849
dfc53823fb3adccd40e9762c665f5bb3deecbf27
95
py
Python
instance/config.py
antomuli/News_Highlight
9feb33c0a32fa78cd93f5ab2c74942a8ca281701
[ "Unlicense" ]
2
2020-03-23T23:16:51.000Z
2020-04-26T21:15:11.000Z
instance/config.py
antomuli/News_Highlight
9feb33c0a32fa78cd93f5ab2c74942a8ca281701
[ "Unlicense" ]
null
null
null
instance/config.py
antomuli/News_Highlight
9feb33c0a32fa78cd93f5ab2c74942a8ca281701
[ "Unlicense" ]
null
null
null
NEWS_API_KEY= '138b22df68394ecbaa9c9af0d0377adb' SECRET_KEY= 'f9bf78b9a18ce6d46a0cd2b0b86df9da'
47.5
48
0.905263
0
0
0
0
0
0
0
0
68
0.715789
dfc5ea1ec35f681b24bc22174c17b45b8de95235
1,417
py
Python
twirp/logging.py
batchar2/twirpy
e5940a2a038926844098def09748953287071747
[ "Unlicense" ]
51
2020-05-23T22:31:53.000Z
2022-03-08T19:14:04.000Z
twirp/logging.py
batchar2/twirpy
e5940a2a038926844098def09748953287071747
[ "Unlicense" ]
20
2020-05-15T10:20:38.000Z
2022-02-06T23:21:56.000Z
twirp/logging.py
batchar2/twirpy
e5940a2a038926844098def09748953287071747
[ "Unlicense" ]
10
2020-05-29T09:55:49.000Z
2021-10-16T00:14:04.000Z
import os import logging import sys import structlog from structlog.stdlib import LoggerFactory, add_log_level _configured = False def configure(force = False): """ Configures logging & structlog modules Keyword Arguments: force: Force to reconfigure logging. """ global _configured if _configured and not force: return # Check whether debug flag is set debug = os.environ.get('DEBUG_MODE', False) # Set appropriate log level if debug: log_level = logging.DEBUG else: log_level = logging.INFO # Set logging config logging.basicConfig( level = log_level, format = "%(message)s", ) # Configure structlog structlog.configure( logger_factory = LoggerFactory(), processors = [ add_log_level, # Add timestamp structlog.processors.TimeStamper('iso'), # Add stack information structlog.processors.StackInfoRenderer(), # Set exception field using exec info structlog.processors.format_exc_info, # Render event_dict as JSON structlog.processors.JSONRenderer() ] ) _configured = True def get_logger(**kwargs): """ Get the structlog logger """ # Configure logging modules configure() # Return structlog return structlog.get_logger(**kwargs)
22.140625
57
0.628088
0
0
0
0
0
0
0
0
437
0.308398
dfc68640fe94c25498745f6373d4a8f15e6f9a5f
878
py
Python
setup.py
Arkq/pyexec
ec90b0aaff80996155d033bd722ff59c9259460e
[ "MIT" ]
null
null
null
setup.py
Arkq/pyexec
ec90b0aaff80996155d033bd722ff59c9259460e
[ "MIT" ]
null
null
null
setup.py
Arkq/pyexec
ec90b0aaff80996155d033bd722ff59c9259460e
[ "MIT" ]
null
null
null
# setup.py # Copyright (c) 2015-2017 Arkadiusz Bokowy # # This file is a part of pyexec. # # This project is licensed under the terms of the MIT license. from setuptools import setup import pyexec with open("README.rst") as f: long_description = f.read() setup( name="pyexec", version=pyexec.__version__, author="Arkadiusz Bokowy", author_email="[email protected]", url="https://github.com/Arkq/pyexec", description="Signal-triggered process reloader", long_description=long_description, license="MIT", py_modules=["pyexec"], classifiers=[ "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Programming Language :: Python :: 2", "Programming Language :: Python :: 3", "Topic :: Software Development :: Libraries", "Topic :: Utilities", ], )
25.085714
62
0.654897
0
0
0
0
0
0
0
0
505
0.575171
dfc68f46a49d56c4e9d2e4ea5761354ae3746b5b
323
py
Python
tests/func_eqconstr.py
andyjost/Sprite
7ecd6fc7d48d7f62da644e48c12c7b882e1a2929
[ "MIT" ]
1
2022-03-16T16:37:11.000Z
2022-03-16T16:37:11.000Z
tests/func_eqconstr.py
andyjost/Sprite
7ecd6fc7d48d7f62da644e48c12c7b882e1a2929
[ "MIT" ]
null
null
null
tests/func_eqconstr.py
andyjost/Sprite
7ecd6fc7d48d7f62da644e48c12c7b882e1a2929
[ "MIT" ]
null
null
null
'''Functional tests for the equational constraint.''' import cytest # from ./lib; must be first class TestEqConstr(cytest.FunctionalTestCase): SOURCE_DIR = 'data/curry/eqconstr/' PRINT_SKIPPED_GOALS = True # RUN_ONLY = ['a0_.[02468][048]', 'a0b0c0_.[037][048]', 'prog0.'] # A subset for quick checks. # SKIP = []
32.3
96
0.693498
224
0.693498
0
0
0
0
0
0
207
0.640867
dfc7144f2268699316911b76b5597b6509452a54
4,898
py
Python
data-sources/kbr/authority-persons-marc-to-csv.py
kbrbe/beltrans-data-integration
951ae3941b22a6fe0a8d30079bdf6f4f0a55f092
[ "MIT" ]
null
null
null
data-sources/kbr/authority-persons-marc-to-csv.py
kbrbe/beltrans-data-integration
951ae3941b22a6fe0a8d30079bdf6f4f0a55f092
[ "MIT" ]
21
2022-02-14T10:58:52.000Z
2022-03-28T14:04:40.000Z
data-sources/kbr/authority-persons-marc-to-csv.py
kbrbe/beltrans-data-integration
951ae3941b22a6fe0a8d30079bdf6f4f0a55f092
[ "MIT" ]
null
null
null
# # (c) 2022 Sven Lieber # KBR Brussels # #import xml.etree.ElementTree as ET import lxml.etree as ET import os import json import itertools import enchant import hashlib import csv from optparse import OptionParser import utils import stdnum NS_MARCSLIM = 'http://www.loc.gov/MARC21/slim' ALL_NS = {'marc': NS_MARCSLIM} # ----------------------------------------------------------------------------- def addAuthorityFieldsToCSV(elem, writer, natWriter, stats): """This function extracts authority relevant data from the given XML element 'elem' and writes it to the given CSV file writer.""" # # extract relevant data from the current record # authorityID = utils.getElementValue(elem.find('./marc:controlfield[@tag="001"]', ALL_NS)) namePerson = utils.getElementValue(elem.find('./marc:datafield[@tag="100"]/marc:subfield[@code="a"]', ALL_NS)) nameOrg = utils.getElementValue(elem.find('./marc:datafield[@tag="110"]/marc:subfield[@code="a"]', ALL_NS)) nationalities = utils.getElementValue(elem.findall('./marc:datafield[@tag="370"]/marc:subfield[@code="c"]', ALL_NS)) gender = utils.getElementValue(elem.find('./marc:datafield[@tag="375"]/marc:subfield[@code="a"]', ALL_NS)) birthDateRaw = utils.getElementValue(elem.find('./marc:datafield[@tag="046"]/marc:subfield[@code="f"]', ALL_NS)) deathDateRaw = utils.getElementValue(elem.find('./marc:datafield[@tag="046"]/marc:subfield[@code="g"]', ALL_NS)) isniRaw = utils.getElementValue(elem.xpath('./marc:datafield[@tag="024"]/marc:subfield[@code="2" and (text()="isni" or text()="ISNI")]/../marc:subfield[@code="a"]', namespaces=ALL_NS)) viafRaw = utils.getElementValue(elem.xpath('./marc:datafield[@tag="024"]/marc:subfield[@code="2" and text()="viaf"]/../marc:subfield[@code="a"]', namespaces=ALL_NS)) countryCode = utils.getElementValue(elem.find('./marc:datafield[@tag="043"]/marc:subfield[@code="c"]', ALL_NS)) (familyName, givenName) = utils.extractNameComponents(namePerson) birthDate = '' deathDate = '' datePatterns = ['%Y', '(%Y)', '[%Y]', '%Y-%m-%d', '%d/%m/%Y', '%Y%m%d'] if birthDateRaw: birthDate = utils.parseDate(birthDateRaw, datePatterns) if deathDateRaw: deathDate = utils.parseDate(deathDateRaw, datePatterns) name = f'{namePerson} {nameOrg}'.strip() if nationalities: nationalityURIString = utils.createURIString(nationalities, ';', 'http://id.loc.gov/vocabulary/countries/') for n in nationalityURIString.split(';'): natWriter.writerow({'authorityID': authorityID, 'nationality': n}) newRecord = { 'authorityID': authorityID, 'name': name, 'family_name': familyName, 'given_name': givenName, 'gender': gender, 'birth_date': birthDate, 'death_date': deathDate, 'isni_id': utils.extractIdentifier(authorityID, f'ISNI {isniRaw}', pattern='ISNI'), 'viaf_id': utils.extractIdentifier(authorityID, f'VIAF {viafRaw}', pattern='VIAF'), 'country_code': countryCode } writer.writerow(newRecord) # ----------------------------------------------------------------------------- def main(): """This script reads an XML file in MARC slim format and extracts several fields to create a CSV file.""" parser = OptionParser(usage="usage: %prog [options]") parser.add_option('-i', '--input-file', action='store', help='The input file containing MARC SLIM XML records') parser.add_option('-o', '--output-file', action='store', help='The output CSV file containing selected MARC fields') parser.add_option('-n', '--nationality-csv', action='store', help='The output CSV file containing the IDs of authorities and their nationality') (options, args) = parser.parse_args() # # Check if we got all required arguments # if( (not options.input_file) or (not options.output_file) or (not options.nationality_csv) ): parser.print_help() exit(1) # # Instead of loading everything to main memory, stream over the XML using iterparse # with open(options.output_file, 'w') as outFile, \ open(options.nationality_csv, 'w') as natFile: stats = {} outputFields = ['authorityID', 'name', 'family_name', 'given_name', 'gender', 'birth_date', 'death_date', 'isni_id', 'viaf_id', 'country_code'] outputWriter = csv.DictWriter(outFile, fieldnames=outputFields, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) outputWriter.writeheader() nationalityWriter = csv.DictWriter(natFile, fieldnames=['authorityID', 'nationality'], delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) nationalityWriter.writeheader() for event, elem in ET.iterparse(options.input_file, events=('start', 'end')): # The parser finished reading one authority record, get information and then discard the record if event == 'end' and elem.tag == ET.QName(NS_MARCSLIM, 'record'): addAuthorityFieldsToCSV(elem, outputWriter, nationalityWriter, stats) main()
43.732143
186
0.682115
0
0
0
0
0
0
0
0
2,175
0.444059
dfc7e5a8bbc57e53f20590d631fe2b87c31a1671
3,886
py
Python
promoterz/evaluationPool.py
emillj/gekkoJaponicus
d77c8c7a303b97a3643eb3f3c8b995b8b393f3f7
[ "MIT" ]
null
null
null
promoterz/evaluationPool.py
emillj/gekkoJaponicus
d77c8c7a303b97a3643eb3f3c8b995b8b393f3f7
[ "MIT" ]
null
null
null
promoterz/evaluationPool.py
emillj/gekkoJaponicus
d77c8c7a303b97a3643eb3f3c8b995b8b393f3f7
[ "MIT" ]
1
2021-11-29T20:18:25.000Z
2021-11-29T20:18:25.000Z
#!/bin/python import time import random from multiprocessing import Pool, Process, Pipe, TimeoutError from multiprocessing.pool import ThreadPool class EvaluationPool(): def __init__(self, EvaluationTool, Urls, poolsize): self.EvaluationTool = EvaluationTool self.Urls = Urls self.lasttimes = [0 for x in Urls] self.lasttimesperind = [0 for x in Urls] self.poolsizes = [5 for x in Urls] def ejectURL(self, Index): self.Urls.pop(Index) self.lasttimes.pop(Index) self.lasttimesperind.pop(Index) self.poolsizes.pop(Index) def evaluateBackend(self, DateRange, I, inds): stime = time.time() Q = [ (DateRange, ind, self.Urls[I]) for ind in inds ] P = Pool(self.poolsizes[I]) fitnesses = P.starmap(self.EvaluationTool, Q ) P.close() P.join() delta_time=time.time()-stime return fitnesses, delta_time def evaluatePopulation(self, locale): individues_to_simulate = [ind for ind in locale.population\ if not ind.fitness.valid] props=self.distributeIndividuals(individues_to_simulate) args = [ [locale.DateRange, I, props[I]]\ for I in range(len(self.Urls))] pool = ThreadPool(len(self.Urls)) results=[] for A in args: results.append(pool.apply_async(self.evaluateBackend, A)) pool.close() TimedOut=[] for A in range(len(results)): try: perindTime = 3 * self.lasttimesperind[A] if self.lasttimesperind[A] else 12 timeout = perindTime*len(props[A]) if A else None # no timeout for local machine; results[A] = results[A].get(timeout=timeout) except TimeoutError: # Timeout: remote machine is dead, et al print("Machine timeouts!") args[A][1] = 0 # Set to evaluate @ local machine results[A] = self.evaluateBackend(*args[A]) TimedOut.append(A) pool.join() for PoolIndex in range(len(results)): for i, fit in zip(range(len(results[PoolIndex][0])), results[PoolIndex][0]): props[PoolIndex][i].fitness.values = fit self.lasttimes[PoolIndex] = results[PoolIndex][1] L = len(props[PoolIndex]) self.lasttimesperind[PoolIndex] = self.lasttimes[PoolIndex] / L if L else 5 F = [x.fitness.valid for x in individues_to_simulate] assert(all(F)) for T in TimedOut: self.ejectURL(T) return len(individues_to_simulate) def distributeIndividuals(self, tosimulation): nb_simulate = len(tosimulation) sumtimes = sum(self.lasttimes) #stdtime = sum(self.lasttimes)/len(self.lasttimes) std = nb_simulate/len(self.Urls) #stdTPI = sum(self.lasttimesperind)/len(self.lasttimesperind) #print(stdTPI) if sumtimes: vels = [ 1/x for x in self.lasttimes ] constant = nb_simulate/sum(vels) proportions = [ max(1, x*constant) for x in vels ] else: proportions = [std for x in self.Urls] proportions = [int(round(x)) for x in proportions] pC = lambda x:random.randrange(0,len(x)) pB = lambda x: x.index(min(x)) pM = lambda x: x.index(max(x)) while sum(proportions) < nb_simulate: proportions[pB(proportions)] +=1 print('+') while sum(proportions) > nb_simulate: proportions[pM(proportions)] -=1 print('-') print(proportions) assert(sum(proportions) == nb_simulate) distribution = [] L=0 for P in proportions: distribution.append(tosimulation[L:L+P]) L=L+P return distribution
33.213675
97
0.587494
3,737
0.961657
0
0
0
0
0
0
267
0.068708
dfc9bea7af7becf02c3cd0e4f00d6640fee9f247
3,001
py
Python
website/drawquest/apps/following/models.py
bopopescu/drawquest-web
8d8f9149b6efeb65202809a5f8916386f58a1b3b
[ "BSD-3-Clause" ]
19
2015-11-10T17:36:20.000Z
2021-04-12T07:36:00.000Z
website/drawquest/apps/following/models.py
bopopescu/drawquest-web
8d8f9149b6efeb65202809a5f8916386f58a1b3b
[ "BSD-3-Clause" ]
1
2021-06-09T03:45:34.000Z
2021-06-09T03:45:34.000Z
website/drawquest/apps/following/models.py
bopopescu/drawquest-web
8d8f9149b6efeb65202809a5f8916386f58a1b3b
[ "BSD-3-Clause" ]
6
2015-11-11T00:38:38.000Z
2020-07-25T20:10:08.000Z
from canvas.cache_patterns import CachedCall from drawquest import knobs from drawquest.apps.drawquest_auth.models import User from drawquest.apps.drawquest_auth.details_models import UserDetails from drawquest.pagination import FakePaginator def _sorted(users): return sorted(users, key=lambda user: user.username.lower()) def _for_viewer(users, viewer=None): if viewer is None or not viewer.is_authenticated(): return users following = [int(id_) for id_ in viewer.redis.new_following.zrange(0, -1)] for user in users: user.viewer_is_following = user.id in following return users def _paginate(redis_obj, offset, request=None): ''' items should already start at the proper offset. ''' if offset == 'top': items = redis_obj.zrevrange(0, knobs.FOLLOWERS_PER_PAGE, withscores=True) else: items = redis_obj.zrevrangebyscore('({}'.format(offset), '-inf', start=0, num=knobs.FOLLOWERS_PER_PAGE, withscores=True) try: next_offset = items[-1][1] next_offset = next_offset.__repr__() except IndexError: next_offset = None items = [item for item, ts in items] pagination = FakePaginator(items, offset=offset, next_offset=next_offset) return items, pagination def followers(user, viewer=None, offset='top', direction='next', request=None): """ The users who are following `user`. """ if direction != 'next': raise ValueError("Follwers only supports 'next' - scrolling in one direction.") if request is None or (request.idiom == 'iPad' and request.app_version_tuple <= (3, 1)): user_ids = user.redis.new_followers.zrevrange(0, -1) pagination = None else: user_ids, pagination = _paginate(user.redis.new_followers, offset, request=request) users = UserDetails.from_ids(user_ids) if request is None or request.app_version_tuple < (3, 0): users = _sorted(users) return _for_viewer(users, viewer=viewer), pagination def following(user, viewer=None, offset='top', direction='next', request=None): """ The users that `user` is following. """ if direction != 'next': raise ValueError("Following only supports 'next' - scrolling in one direction.") if request is None or (request.idiom == 'iPad' and request.app_version_tuple <= (3, 1)): user_ids = user.redis.new_following.zrange(0, -1) pagination = None else: user_ids, pagination = _paginate(user.redis.new_following, offset, request=request) users = UserDetails.from_ids(user_ids) if request is None or request.app_version_tuple < (3, 0): users = _sorted(users) return _for_viewer(users, viewer=viewer), pagination def counts(user): return { 'followers': user.redis.new_followers.zcard(), 'following': user.redis.new_following.zcard(), }
34.102273
92
0.65978
0
0
0
0
0
0
0
0
357
0.11896
dfcaf8188821bfe0448579c92b86161cf07a8cb5
3,674
py
Python
Python 3/PyGame/Matrix_based_3D/entities.py
DarkShadow4/python
4cd94e0cf53ee06c9c31e9272572ca9656697c30
[ "MIT" ]
null
null
null
Python 3/PyGame/Matrix_based_3D/entities.py
DarkShadow4/python
4cd94e0cf53ee06c9c31e9272572ca9656697c30
[ "MIT" ]
null
null
null
Python 3/PyGame/Matrix_based_3D/entities.py
DarkShadow4/python
4cd94e0cf53ee06c9c31e9272572ca9656697c30
[ "MIT" ]
1
2020-08-19T17:25:22.000Z
2020-08-19T17:25:22.000Z
import numpy as np def translationMatrix(dx=0, dy=0, dz=0): return np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [dx, dy, dz, 1]]) def scalingMatrix(sx=1, sy=1, sz=1): return np.array([[sx, 0, 0, 0], [0, sy, 0, 0], [0, 0, sz, 0], [0, 0, 0, 1]]) def rotateXmatrix(radians): c = np.cos(radians) s = np.sin(radians) return np.array([[1, 0, 0, 0], [0, c, -s, 0], [0, s, c, 0], [0, 0, 0, 1]]) def rotateYmatrix(radians): c = np.cos(radians) s = np.sin(radians) return np.array([[ c, 0, s, 0], [ 0, 1, 0, 0], [-s, 0, c, 0], [ 0, 0, 0, 1]]) def rotateZmatrix(radians): c = np.cos(radians) s = np.sin(radians) return np.array([[c, -s, 0 ,0], [s, c, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]) class Entity(object): """docstring for Entity.""" def __init__(self, name="", type="", node_color=(0, 0, 0), edge_color=(255, 255, 255), node_radius=4): super(Entity, self).__init__() self.name = name self.type = type self.nodes = np.zeros((0, 4)) self.node_color = node_color self.edge_color = edge_color self.node_radius = node_radius self.edges = [] #### self.initial_nodes = np.zeros((0, 4)) self.totalTransformations = { "T":[ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1] ], "RX":[ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1] ], "RY":[ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1] ], "RZ":[ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1] ], "S":[ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1] ] } #### def addNodes(self, nodes): ones = np.ones((len(nodes), 1)) nodes = np.hstack((nodes, ones)) #### self.initial_nodes = np.vstack((self.initial_nodes, nodes)) self.nodes = np.dot(self.initial_nodes, self.totalTransformations["RY"]) self.nodes = np.dot(self.nodes, self.totalTransformations["RX"]) self.nodes = np.dot(self.nodes, self.totalTransformations["RZ"]) self.nodes = np.dot(self.nodes, self.totalTransformations["T"]) self.nodes = np.dot(self.nodes, self.totalTransformations["S"]) # centerX = sum(node[0] for node in self.nodes)/len(self.nodes) # centerY = sum(node[1] for node in self.nodes)/len(self.nodes) # centerZ = sum(node[2] for node in self.nodes)/len(self.nodes) # self.center = (centerX, centerY, centerZ) #### # self.nodes = np.vstack((self.nodes, nodes)) def addEdges(self, edges): self.edges += edges def transform(self, matrix, type): self.totalTransformations[type] = np.dot(self.totalTransformations[type], matrix) self.nodes = np.dot(self.initial_nodes, self.totalTransformations["RY"]) self.nodes = np.dot(self.nodes, self.totalTransformations["RX"]) self.nodes = np.dot(self.nodes, self.totalTransformations["RZ"]) self.nodes = np.dot(self.nodes, self.totalTransformations["T"]) self.nodes = np.dot(self.nodes, self.totalTransformations["S"])
33.099099
106
0.459717
2,604
0.708764
0
0
0
0
0
0
378
0.102885
dfcb6f77810c69d9413f60d8f54a4f595fd87395
65
py
Python
pytreearray/multiply.py
PhilipVinc/netket_dynamics
6e8009098c279271cb0f289ba9e85c039bb284e4
[ "Apache-2.0" ]
2
2021-10-02T20:29:44.000Z
2021-10-02T20:38:28.000Z
pytreearray/multiply.py
PhilipVinc/netket_dynamics
6e8009098c279271cb0f289ba9e85c039bb284e4
[ "Apache-2.0" ]
11
2021-10-01T09:15:06.000Z
2022-03-21T09:19:23.000Z
pytreearray/multiply.py
PhilipVinc/netket_dynamics
6e8009098c279271cb0f289ba9e85c039bb284e4
[ "Apache-2.0" ]
null
null
null
from ._src.multiply import multiply_outer as outer # noqa: F401
32.5
64
0.784615
0
0
0
0
0
0
0
0
12
0.184615
dfcda9e0f1ad0a543490dfbdc63f6f36b102ec00
1,258
py
Python
setup.py
utix/django-json-api
938f78f664a4ecbabb9e678595926d1a580f9d0c
[ "MIT" ]
7
2021-02-26T14:35:17.000Z
2021-02-26T21:21:58.000Z
setup.py
utix/django-json-api
938f78f664a4ecbabb9e678595926d1a580f9d0c
[ "MIT" ]
7
2021-02-26T14:44:30.000Z
2021-06-02T14:27:17.000Z
setup.py
utix/django-json-api
938f78f664a4ecbabb9e678595926d1a580f9d0c
[ "MIT" ]
1
2021-02-26T20:10:42.000Z
2021-02-26T20:10:42.000Z
#!/usr/bin/env python from os.path import join from setuptools import find_packages, setup # DEPENDENCIES def requirements_from_pip(filename): with open(filename, "r") as pip: return [line.strip() for line in pip if not line.startswith("#") and line.strip()] core_deps = requirements_from_pip("requirements.txt") dev_deps = requirements_from_pip("requirements_dev.txt") # DESCRIPTION with open("README.md", "r", encoding="utf-8") as fh: long_description = fh.read() setup( author="Sharework", author_email="[email protected]", description="JSON API specification for Django services", extras_require={"all": dev_deps, "dev": dev_deps}, install_requires=core_deps, long_description=long_description, long_description_content_type="text/markdown", name="django-json-api", package_data={"django_json_api": ["resources/VERSION"]}, packages=find_packages(), python_requires=">=3.8", url="https://github.com/share-work/django-json-api", version=open(join("django_json_api", "resources", "VERSION")).read().strip(), classifiers=[ "Programming Language :: Python :: 3.8", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", ], )
29.952381
90
0.692369
0
0
0
0
0
0
0
0
473
0.375994
dfcf9bc6b50b9274d2e45ff7e0b6d1af9920cab0
1,632
py
Python
youtube_dl/extractor/businessinsider.py
MOODesign/Youtube-videos-Download
730c0d12a06f349907481570f1f2890251f7a181
[ "Unlicense" ]
16
2020-12-01T15:26:58.000Z
2022-02-24T23:12:14.000Z
youtube_dl/extractor/businessinsider.py
MOODesign/Youtube-videos-Download
730c0d12a06f349907481570f1f2890251f7a181
[ "Unlicense" ]
5
2021-02-20T10:30:00.000Z
2021-06-01T21:12:31.000Z
youtube_dl/extractor/businessinsider.py
MOODesign/Youtube-videos-Download
730c0d12a06f349907481570f1f2890251f7a181
[ "Unlicense" ]
7
2020-12-01T15:27:04.000Z
2022-01-09T23:21:53.000Z
# coding: utf-8 from __future__ import unicode_literals from .common import InfoExtractor from .jwplatform import JWPlatformIE class BusinessInsiderIE(InfoExtractor): _VALID_URL = r'https?://(?:[^/]+\.)?businessinsider\.(?:com|nl)/(?:[^/]+/)*(?P<id>[^/?#&]+)' _TESTS = [{ 'url': 'http://uk.businessinsider.com/how-much-radiation-youre-exposed-to-in-everyday-life-2016-6', 'md5': 'ca237a53a8eb20b6dc5bd60564d4ab3e', 'info_dict': { 'id': 'hZRllCfw', 'ext': 'mp4', 'title': "Here's how much radiation you're exposed to in everyday life", 'description': 'md5:9a0d6e2c279948aadaa5e84d6d9b99bd', 'upload_date': '20170709', 'timestamp': 1499606400, }, 'params': { 'skip_download': True, }, }, { 'url': 'https://www.businessinsider.nl/5-scientifically-proven-things-make-you-less-attractive-2017-7/', 'only_matching': True, }, { 'url': 'http://www.businessinsider.com/excel-index-match-vlookup-video-how-to-2015-2?IR=T', 'only_matching': True, }] def _real_extract(self, url): video_id = self._match_id(url) webpage = self._download_webpage(url, video_id) jwplatform_id = self._search_regex( (r'data-media-id=["\']([a-zA-Z0-9]{8})', r'id=["\']jwplayer_([a-zA-Z0-9]{8})', r'id["\']?\s*:\s*["\']?([a-zA-Z0-9]{8})'), webpage, 'jwplatform id') return self.url_result( 'jwplatform:%s' % jwplatform_id, ie=JWPlatformIE.ie_key(), video_id=video_id)
37.953488
112
0.571078
1,501
0.91973
0
0
0
0
0
0
804
0.492647
dfcfb445e47c75ccbf0dd0f1527b09b9571a8702
578
py
Python
map_house.py
renankalfa/python-0-ao-Data_Scientist
2f61e1cbb1c5565da53cc1cd9aa5c3f5d1cacc88
[ "MIT" ]
1
2022-03-27T23:55:37.000Z
2022-03-27T23:55:37.000Z
map_house.py
renankalfa/python-0-ao-Data_Scientist
2f61e1cbb1c5565da53cc1cd9aa5c3f5d1cacc88
[ "MIT" ]
null
null
null
map_house.py
renankalfa/python-0-ao-Data_Scientist
2f61e1cbb1c5565da53cc1cd9aa5c3f5d1cacc88
[ "MIT" ]
null
null
null
import plotly.express as px import pandas as pd data = pd.read_csv('kc_house_data.csv') data_mapa = data[['id', 'lat', 'long', 'price']] grafico1 = px.scatter_mapbox(data_mapa, lat='lat', lon='long', hover_name='id', hover_data=['price'], color_discrete_sequence=['fuchsia'], zoom=3, height=300) grafico1.update_layout(mapbox_style='open-street-map') grafico1.update_layout(height=600, margin={'r': 0, 't': 0, 'l': 0, 'b': 0}) grafico1.show() grafico1.write_html('map_house_rocket.html')
36.125
75
0.610727
0
0
0
0
0
0
0
0
124
0.214533
dfcfba95af54686ffe34f16d2ea3725de4ec6aa5
1,561
py
Python
scripts/api-timeboard.py
ryhennessy/hiring-engineers
f151fb593a016b38b92767ce48d217c3d57c492a
[ "Apache-2.0" ]
null
null
null
scripts/api-timeboard.py
ryhennessy/hiring-engineers
f151fb593a016b38b92767ce48d217c3d57c492a
[ "Apache-2.0" ]
null
null
null
scripts/api-timeboard.py
ryhennessy/hiring-engineers
f151fb593a016b38b92767ce48d217c3d57c492a
[ "Apache-2.0" ]
1
2019-02-06T00:09:36.000Z
2019-02-06T00:09:36.000Z
#!/usr/bin/python from datadog import initialize, api options = { 'api_key': '17370fa45ebc4a8184d3dde9f8189c38', 'app_key': 'b0d652bbd1d861656723c1a93bc1a2f22d493d57' } initialize(**options) title = "Ryan Great Timeboard" description = "My Timeboard that is super awesome" graphs = [ { "title": "My Metric over my host", "definition": { "requests": [ { "q": "avg:my_metric{host:secondaryhost.hennvms.net}", "type": "line", "style": { "palette": "dog_classic", "type": "solid", "width": "normal" }, "conditional_formats": [], "aggregator": "avg" } ], "autoscale": "true", "viz": "timeseries" } }, { "title": "MySQL Anomaly Function Applied", "definition": { "viz": "timeseries", "requests": [ { "q": "anomalies(avg:mysql.performance.user_time{*}, 'basic', 2)", "type": "line", "style": { "palette": "dog_classic", "type": "solid", "width": "normal" }, "conditional_formats": [], "aggregator": "avg" } ], "autoscale": "true" } }, { "title": "My Metric Rollup Function", "definition": { "viz": "query_value", "requests": [ { "q": "avg:my_metric{*}.rollup(sum, 60)", "type": "line", "style": { "palette": "dog_classic", "type": "solid", "width": "normal" }, "conditional_formats": [], "aggregator": "avg" } ], "autoscale": "true" } }] api.Timeboard.create(title=title, description=description, graphs=graphs)
20.539474
73
0.547726
0
0
0
0
0
0
0
0
912
0.584241
dfd10fcf278a06e3edb0f59aed0bddac1ebc200d
732
py
Python
Playground/Spin.py
fountainment/cherry-soda
3dd0eb7d0b5503ba572ff2104990856ef7a87495
[ "MIT" ]
27
2020-01-16T08:20:54.000Z
2022-03-29T20:40:15.000Z
Playground/Spin.py
fountainment/cherry-soda
3dd0eb7d0b5503ba572ff2104990856ef7a87495
[ "MIT" ]
10
2022-01-07T14:07:27.000Z
2022-03-19T18:13:44.000Z
Playground/Spin.py
fountainment/cherry-soda
3dd0eb7d0b5503ba572ff2104990856ef7a87495
[ "MIT" ]
6
2019-12-27T10:04:07.000Z
2021-12-15T17:29:24.000Z
import numpy as np import math import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D def get_spin(radius_scale, height_scale, rounds): xs, ys, zs = [], [], [] theta = 0.0 delta = 0.1 twopi = math.pi * 2.0 for i in range(int(rounds * twopi / delta)): theta += delta radius = theta / twopi * radius_scale x = np.cos(theta) * radius y = np.sin(theta) * radius xs.append(x) ys.append(y) zs.append(theta / twopi * height_scale) return xs, ys, zs def main(): fig = plt.figure() ax = Axes3D(fig) ax.plot(*get_spin(1.0, 3.0, 5.0)) ax.plot(*get_spin(1.05, 3.15, 5.0)) plt.show() if __name__ == '__main__': main()
23.612903
49
0.579235
0
0
0
0
0
0
0
0
10
0.013661
dfd2a91be88a84783b35bd946e501cc258160953
1,911
py
Python
bin/get_latest_rotation.py
rhots/automation
cfa97656885f4ff91e1c79af5eb8fa38a85c35a8
[ "0BSD" ]
1
2017-06-06T03:07:01.000Z
2017-06-06T03:07:01.000Z
bin/get_latest_rotation.py
rhots/automation
cfa97656885f4ff91e1c79af5eb8fa38a85c35a8
[ "0BSD" ]
3
2016-12-19T21:09:53.000Z
2017-02-14T03:32:18.000Z
bin/get_latest_rotation.py
rhots/automation
cfa97656885f4ff91e1c79af5eb8fa38a85c35a8
[ "0BSD" ]
null
null
null
import os.path from bs4 import BeautifulSoup import requests # Location of file to store latest known page number LAST_KNOWN_PAGE_FILE = "/tmp/rotation_checker_latest" # URL of forum thread where latest rotations are posted ROTATION_FORUM_THREAD = "https://us.battle.net/forums/en/heroes/topic/17936383460" def write_last_known_page(page_num): with open(LAST_KNOWN_PAGE_FILE, "w") as f: f.write(str(page_num)) def read_last_known_page(): try: with open(LAST_KNOWN_PAGE_FILE, "r") as f: return int(f.read()) except OSError: return 0 def is_404(html): return "Page Not Found" in html def load_page(page_num): return requests.get( ROTATION_FORUM_THREAD, params={"page": page_num} ) def load_latest_page(last_known_page=0): if is_404(load_page(last_known_page+1).text): return load_page(last_known_page) else: return load_latest_page(last_known_page+1) def remove_slot_text(s): if "Slot unlocked at" in s: return s return s.split(" (Slot unlocked at")[0] def rotation_info_from_source(html): soup = BeautifulSoup(html, 'html.parser') latest_post_content = soup.select(".TopicPost-bodyContent")[-1] header = latest_post_content.span.text date = header.split("Rotation: ")[-1] heroes = [remove_slot_text(li.text) for li in latest_post_content.find_all("li")] return date, heroes if __name__ == "__main__": # read last known page number if we have it last_known = read_last_known_page() # load latest page, starting from last known page number resp = load_latest_page(last_known) # extract date and hero rotation date, heroes = rotation_info_from_source(resp.text) # write latest page number for future page_num = int(resp.url.split("=")[-1]) write_last_known_page(page_num) print(date) print(heroes)
27.695652
85
0.697541
0
0
0
0
0
0
0
0
495
0.259027
dfd2e5bbf8ec59072195c98d519d767f6b535cb9
2,485
py
Python
fidelis/credentials.py
semperstew/fidelis
8766b1bfa5bac342faf61bf4302a0e822d0a0ec9
[ "Apache-2.0" ]
null
null
null
fidelis/credentials.py
semperstew/fidelis
8766b1bfa5bac342faf61bf4302a0e822d0a0ec9
[ "Apache-2.0" ]
null
null
null
fidelis/credentials.py
semperstew/fidelis
8766b1bfa5bac342faf61bf4302a0e822d0a0ec9
[ "Apache-2.0" ]
null
null
null
# fidelis/credentials.py import datetime import requests import threading from dateutil.tz import tzlocal from collections import namedtuple def _local_now(): return datetime.datetime.now(tzlocal()) class FidelisCredentials(object): """Object to hold authentication credentials""" _default_token_timeout = 10 * 60 def __init__(self, username, password, baseURL, token=None, ignoressl=False): self.baseURL = baseURL self._username = username self._password = password self._token = token self._ignoressl = ignoressl self._time_fetcher = _local_now self._expiration = self._time_fetcher() self._refresh_lock = threading.Lock() self.refresh() @property def token(self): return self._token @token.setter def token(self, value): self._token = value @baseURL def baseURL(self): return self.baseURL @baseURL.setter def baseURL(self, value): self.baseURL = value self._update_expiration() def _refresh_needed(self, refresh_in=None): """Check if a token refresh is needed.""" if self._expiration is None: return False if refresh_in is None: refresh_in = self._default_token_timeout if self._seconds_remaining() >= refresh_in: return False return True def _is_expired(self): """Check if token is expired""" return self._refresh_needed(refresh_in=0) def refresh(self, new_token=None): if new_token is not None: self._token = new_token self._update_expiration() if not self._is_expired(): return else: with self._refresh_lock: self._protected_refresh() def _protected_refresh(self): """Refresh bearer token""" url= self.baseURL + 'authenticate' body={'username': self._username, 'password': self._password} headers={'Content-Type':'application/json'} verify=self._ignoressl r = requests.post(url=url, headers=headers, json=body, verify=verify) self._token = r.data['token'] self._update_expiration() def _seconds_remaining(self): """Calculate remaining seconds until token expiration""" delta = self._expiration - self._time_fetcher() return delta.total_seconds() def _update_expiration(self): delta = datetime.timedelta(seconds=self._default_token_timeout) self._expiration = self._time_fetcher() + delta def __call__(self, r): self.refresh() r.headers['Authorization'] = "bearer " + self._token return r
25.10101
79
0.695775
2,277
0.916298
0
0
269
0.108249
0
0
322
0.129577
dfd45fc42c8fe07d08d4459f4ff51b022c580213
6,254
py
Python
pos_wechat/tests/test_wechat_order.py
nahualventure/pos-addons
3c911c28c259967fb74e311ddcc8e6ca032c005d
[ "MIT" ]
null
null
null
pos_wechat/tests/test_wechat_order.py
nahualventure/pos-addons
3c911c28c259967fb74e311ddcc8e6ca032c005d
[ "MIT" ]
null
null
null
pos_wechat/tests/test_wechat_order.py
nahualventure/pos-addons
3c911c28c259967fb74e311ddcc8e6ca032c005d
[ "MIT" ]
3
2021-06-15T05:45:42.000Z
2021-07-27T12:28:53.000Z
# Copyright 2018 Ivan Yelizariev <https://it-projects.info/team/yelizariev> # License MIT (https://opensource.org/licenses/MIT). import logging from odoo.addons.point_of_sale.tests.common import TestPointOfSaleCommon try: from unittest.mock import patch except ImportError: from mock import patch _logger = logging.getLogger(__name__) DUMMY_AUTH_CODE = "134579302432164181" DUMMY_POS_ID = 1 class TestWeChatOrder(TestPointOfSaleCommon): at_install = True post_install = True def setUp(self): super(TestWeChatOrder, self).setUp() # create wechat journals self.pos_config.init_pos_wechat_journals() self.Order = self.env["wechat.order"] self.Refund = self.env["wechat.refund"] self.product1 = self.env["product.product"].create({"name": "Product1"}) self.product2 = self.env["product.product"].create({"name": "Product2"}) def _patch_post(self, post_result): def post(url, data): self.assertIn(url, post_result) _logger.debug("Request data for %s: %s", url, data) return post_result[url] # patch wechat patcher = patch("wechatpy.pay.base.BaseWeChatPayAPI._post", wraps=post) patcher.start() self.addCleanup(patcher.stop) def _create_pos_order(self): def compute_tax(product, price, qty=1, taxes=None): if taxes is None: taxes = product.taxes_id.filtered( lambda t: t.company_id.id == self.env.user.id ) currency = self.pos_config.pricelist_id.currency_id res = taxes.compute_all(price, currency, qty, product=product) untax = res["total_excluded"] return untax, sum(tax.get("amount", 0.0) for tax in res["taxes"]) # I click on create a new session button self.pos_config.open_session_cb() # I create a PoS order with 2 units of PCSC234 at 450 EUR # and 3 units of PCSC349 at 300 EUR. untax1, atax1 = compute_tax(self.product3, 450, 2) untax2, atax2 = compute_tax(self.product4, 300, 3) order = self.PosOrder.create( { "company_id": self.company_id, "pricelist_id": self.partner1.property_product_pricelist.id, "partner_id": self.partner1.id, "lines": [ ( 0, 0, { "name": "OL/0001", "product_id": self.product3.id, "price_unit": 450, "discount": 0.0, "qty": 2.0, "tax_ids": [(6, 0, self.product3.taxes_id.ids)], "price_subtotal": untax1, "price_subtotal_incl": untax1 + atax1, }, ), ( 0, 0, { "name": "OL/0002", "product_id": self.product4.id, "price_unit": 300, "discount": 0.0, "qty": 3.0, "tax_ids": [(6, 0, self.product4.taxes_id.ids)], "price_subtotal": untax2, "price_subtotal_incl": untax2 + atax2, }, ), ], "amount_tax": atax1 + atax2, "amount_total": untax1 + untax2 + atax1 + atax2, "amount_paid": 0, "amount_return": 0, } ) return order def _create_wechat_order(self): post_result = { "pay/unifiedorder": { "code_url": "weixin://wxpay/s/An4baqw", "trade_type": "NATIVE", "result_code": "SUCCESS", } } self.lines = [ { "product_id": self.product1.id, "name": "Product 1 Name", "quantity": 2, "price": 450, "category": "123456", "description": "翻译服务器错误", }, { "product_id": self.product2.id, "name": "Product 2 Name", "quantity": 3, "price": 300, "category": "123456", "description": "網路白目哈哈", }, ] self._patch_post(post_result) order, code_url = self.Order._create_qr(self.lines, total_fee=300) self.assertEqual(order.state, "draft", "Just created order has wrong state") return order def test_refund(self): # Order are not really equal because I'm lazy # Just imagine that they are correspond each other order = self._create_pos_order() wechat_order = self._create_wechat_order() order.wechat_order_id = wechat_order.id # patch refund api request post_result = { "secapi/pay/refund": {"trade_type": "NATIVE", "result_code": "SUCCESS"} } self._patch_post(post_result) # I create a refund refund_action = order.refund() refund = self.PosOrder.browse(refund_action["res_id"]) wechat_journal = self.env["account.journal"].search([("wechat", "=", "native")]) payment_context = {"active_ids": refund.ids, "active_id": refund.id} refund_payment = self.PosMakePayment.with_context(**payment_context).create( { "amount": refund.amount_total, "journal_id": wechat_journal.id, "wechat_order_id": wechat_order.id, } ) # I click on the validate button to register the payment. refund_payment.with_context(**payment_context).check() self.assertEqual(refund.state, "paid", "The refund is not marked as paid") self.assertEqual( wechat_order.state, "refunded", "Wechat Order state is not changed after making refund payment", )
35.942529
88
0.512312
5,874
0.93535
0
0
0
0
0
0
1,631
0.259713
dfd6670490ad28a09d2ea2ea84c8564b4b85c4b8
582
py
Python
docker/settings.py
uw-it-aca/course-roster-lti
599dad70e06bc85d3d862116c00e8ecf0e2e9c8c
[ "Apache-2.0" ]
null
null
null
docker/settings.py
uw-it-aca/course-roster-lti
599dad70e06bc85d3d862116c00e8ecf0e2e9c8c
[ "Apache-2.0" ]
53
2017-01-28T00:03:57.000Z
2022-03-23T21:57:13.000Z
docker/settings.py
uw-it-aca/course-roster-lti
599dad70e06bc85d3d862116c00e8ecf0e2e9c8c
[ "Apache-2.0" ]
null
null
null
from .base_settings import * INSTALLED_APPS += [ 'course_roster.apps.CourseRosterConfig', 'compressor', ] COMPRESS_ROOT = '/static/' COMPRESS_PRECOMPILERS = (('text/less', 'lessc {infile} {outfile}'),) COMPRESS_OFFLINE = True STATICFILES_FINDERS += ('compressor.finders.CompressorFinder',) if os.getenv('ENV', 'localdev') == 'localdev': DEBUG = True RESTCLIENTS_DAO_CACHE_CLASS = None else: RESTCLIENTS_DAO_CACHE_CLASS = 'course_roster.cache.IDCardPhotoCache' COURSE_ROSTER_PER_PAGE = 50 IDCARD_PHOTO_EXPIRES = 60 * 60 * 2 IDCARD_TOKEN_EXPIRES = 60 * 60 * 2
26.454545
72
0.735395
0
0
0
0
0
0
0
0
198
0.340206
dfd9ba7258d16727355e98f49f13d4ad3a7818cc
606
py
Python
pylons/decorators/util.py
KinSai1975/Menira.py
ca275ce244ee4804444e1827ba60010a55acc07c
[ "BSD-3-Clause" ]
118
2015-01-04T06:55:14.000Z
2022-01-14T08:32:41.000Z
pylons/decorators/util.py
KinSai1975/Menira.py
ca275ce244ee4804444e1827ba60010a55acc07c
[ "BSD-3-Clause" ]
21
2015-01-03T02:16:28.000Z
2021-03-24T06:10:57.000Z
pylons/decorators/util.py
KinSai1975/Menira.py
ca275ce244ee4804444e1827ba60010a55acc07c
[ "BSD-3-Clause" ]
53
2015-01-04T03:21:08.000Z
2021-08-04T20:52:01.000Z
"""Decorator internal utilities""" import pylons from pylons.controllers import WSGIController def get_pylons(decorator_args): """Return the `pylons` object: either the :mod`~pylons` module or the :attr:`~WSGIController._py_object` equivalent, searching a decorator's *args for the latter :attr:`~WSGIController._py_object` is more efficient as it provides direct access to the Pylons global variables. """ if decorator_args: controller = decorator_args[0] if isinstance(controller, WSGIController): return controller._py_object return pylons
31.894737
71
0.722772
0
0
0
0
0
0
0
0
334
0.551155
dfdcfb5c19d0b0d911ba4d7178ec8d4e8e195552
1,191
py
Python
blt_net/pcmad/config_pcmad.py
AlexD123123/BLT-net
97a06795137e0d9fc9332bbb342ad3248db7dc37
[ "Apache-2.0" ]
1
2022-01-13T07:23:52.000Z
2022-01-13T07:23:52.000Z
blt_net/pcmad/config_pcmad.py
AlexD123123/BLT-net
97a06795137e0d9fc9332bbb342ad3248db7dc37
[ "Apache-2.0" ]
null
null
null
blt_net/pcmad/config_pcmad.py
AlexD123123/BLT-net
97a06795137e0d9fc9332bbb342ad3248db7dc37
[ "Apache-2.0" ]
null
null
null
from yacs.config import CfgNode as CN def get_cfg_defaults(): """Get a yacs CfgNode object with default values for my_project.""" # Return a clone so that the defaults will not be altered # This is for the "local variable" use pattern return _C.clone() _C = CN() _C.SYSTEM = CN() _C.config_name = 'roi_config_default' _C.img_shape = [1024, 2048] _C.merge_grid_resolution = [20, 20] _C.allowed_size_arr = [[[256, 128], [256, 256], [256, 384], [256, 512]], [[384, 192], [384, 384], [384, 576], [384, 768]], [[512, 256], [512, 512], [512, 768], [512, 1024]], [[640, 320], [640, 640], [640, 960], [640, 1280]], [[768, 384], [768, 768], [768, 1152], [768, 1536]]] _C.scale_factor_arr = [1, 1.5, 2, 2.5, 3] #01.01.2020 # _C.inital_padding_arr = [[20, 40], [20, 40], [40, 40], [50, 50], [60, 60]] # _C.min_required_crop_padding_arr = [[30, 30], [30, 30], [40, 40], [50, 50], [60, 60]] #28.03.2020 _C.inital_padding_arr = [[20, 40], [20, 40], [60, 60], [60, 60], [80, 80]] _C.min_required_crop_padding_arr = [[30, 30], [30, 30], [60, 60], [60, 60], [80, 80]] _C.proposals_min_conf = 0.01
29.775
87
0.565071
0
0
0
0
0
0
0
0
375
0.314861
dfdddf5fadff57862aa0a7599f33c1b1aa1825cf
1,188
py
Python
src/pylendingclub/wrapper/order.py
bbarney213/PyLendingClub-Wrapper
7f2ef823a56bc87b7f88abf86498805c2c9ce3d3
[ "BSD-3-Clause" ]
2
2018-06-06T20:04:04.000Z
2018-06-13T12:17:37.000Z
src/pylendingclub/wrapper/order.py
bbarney213/PyLendingClub
7f2ef823a56bc87b7f88abf86498805c2c9ce3d3
[ "BSD-3-Clause" ]
4
2018-10-18T13:59:14.000Z
2018-10-23T16:08:51.000Z
src/pylendingclub/wrapper/order.py
bbarney213/PyLendingClub
7f2ef823a56bc87b7f88abf86498805c2c9ce3d3
[ "BSD-3-Clause" ]
null
null
null
class Order(object): def order(self): return { 'loanId': self._loan_id, 'requestedAmount': self._amount, 'portfolioId': self._portfolio } def __init__(self, loan_id, amount, portfolio): self._loan_id = int(loan_id) self._amount = amount self._portfolio = portfolio @classmethod def from_dict(cls, input_dict): return cls(input_dict.get('loanId'), input_dict.get('requestedAmount'), input_dict.get('portfolioId')) class ConfirmedOrder(): # TODO : Surface properties of the notes being purchased @property def fulfilled(self): return self._fulfilled def data(self): source = dict(self._source) source['fulfilled'] = self.fulfilled return source def __init__(self, json): self._source = json self._loan_id = json.get('loanId') self._requested_amount = json.get('requestedAmount') self._invested_amount = json.get('investedAmount') self._execution_status = json.get('executionStatus') self._fulfilled = 'ORDER_FULFILLED' in self._execution_status
29.7
69
0.619529
1,184
0.996633
0
0
262
0.220539
0
0
218
0.183502
dfdf748f02b9b943852a62e3f8521187d01d62ea
2,175
py
Python
app/__init__.py
muthash/Weconnect-api
d3434c99b96a911258dfb8e3ff68696a2021a64b
[ "MIT" ]
1
2018-03-15T17:08:11.000Z
2018-03-15T17:08:11.000Z
app/__init__.py
muthash/Weconnect-api
d3434c99b96a911258dfb8e3ff68696a2021a64b
[ "MIT" ]
1
2018-02-28T21:26:04.000Z
2018-03-01T07:19:05.000Z
app/__init__.py
muthash/Weconnect-api
d3434c99b96a911258dfb8e3ff68696a2021a64b
[ "MIT" ]
1
2018-03-09T03:45:22.000Z
2018-03-09T03:45:22.000Z
""" The create_app function wraps the creation of a new Flask object, and returns it after it's loaded up with configuration settings using app.config """ from flask import jsonify from flask_api import FlaskAPI from flask_cors import CORS from flask_sqlalchemy import SQLAlchemy from flask_jwt_extended import JWTManager from flask_mail import Mail from instance.config import app_config db = SQLAlchemy() jwt = JWTManager() mail = Mail() def create_app(config_name): """Function wraps the creation of a new Flask object, and returns it after it's loaded up with configuration settings """ app = FlaskAPI(__name__, instance_relative_config=True) cors = CORS(app) app.config.from_object(app_config[config_name]) app.config.from_pyfile('config.py') db.init_app(app) jwt.init_app(app) mail.init_app(app) from app.auth.views import auth from app.business.views import biz from app.reviews.views import rev from app.search.views import search from app.models import BlacklistToken @app.errorhandler(400) def bad_request(error): """Error handler for a bad request""" return jsonify(dict(error='The Server did not understand' + 'the request')), 400 @app.errorhandler(404) def not_found(error): """Error handler for not found page""" return jsonify(dict(error='The Resource is not available')), 404 @app.errorhandler(405) def method_not_allowed(error): """Error handler for wrong method to an endpoint""" return jsonify(dict(error='The HTTP request Method' + ' is not allowed')), 405 @jwt.token_in_blacklist_loader def check_if_token_in_blacklist(decrypted_token): """Check if token is blacklisted""" jti = decrypted_token['jti'] blacklist = BlacklistToken.query.filter_by(token=jti).first() if blacklist is None: return False return blacklist.revoked app.register_blueprint(auth) app.register_blueprint(biz) app.register_blueprint(rev) app.register_blueprint(search) return app
31.521739
83
0.686897
0
0
0
0
948
0.435862
0
0
589
0.270805
dfdfaf2898c9221e7f4f486f5412b4e767f314f2
3,821
py
Python
tests/test_constraints.py
jayvdb/versions
951bc3fd99b6a675190f11ee0752af1d7ff5b440
[ "MIT" ]
3
2015-02-20T04:02:25.000Z
2021-04-06T14:42:21.000Z
tests/test_constraints.py
jayvdb/versions
951bc3fd99b6a675190f11ee0752af1d7ff5b440
[ "MIT" ]
1
2019-07-07T06:37:01.000Z
2019-07-07T06:37:01.000Z
tests/test_constraints.py
jayvdb/versions
951bc3fd99b6a675190f11ee0752af1d7ff5b440
[ "MIT" ]
2
2019-07-07T05:40:29.000Z
2021-04-06T14:42:23.000Z
from unittest import TestCase from versions.constraints import Constraints, merge, ExclusiveConstraints from versions.constraint import Constraint class TestConstraints(TestCase): def test_match(self): self.assertTrue(Constraints.parse('>1,<2').match('1.5')) def test_match_in(self): self.assertTrue('1.5' in Constraints.parse('>1,<2')) def test_parse(self): constraints = Constraints.parse('>1,<2') def test_add(self): self.assertEqual(Constraints() + '>1', Constraints.parse('>1')) self.assertEqual(Constraints() + Constraints.parse('>1'), Constraints.parse('>1')) self.assertEqual(Constraints() + Constraint.parse('>1'), Constraints.parse('>1')) self.assertRaises(TypeError, Constraints().__add__, 42) def test_iadd(self): constraints = Constraints() constraints += '>1' self.assertEqual(constraints, Constraints.parse('>1')) def test_str(self): self.assertEqual(str(Constraints([Constraint.parse('>1'), Constraint.parse('<2')])), '>1.0.0,<2.0.0') def test_repr(self): self.assertEqual(repr(Constraints()), "Constraints()") self.assertEqual(repr(Constraints.parse('==1')), "Constraints.parse('==1.0.0')") def test_eq_invalid_constraints_str(self): self.assertFalse(Constraints() == '#@$!') class TestMerge(TestCase): def assertMerge(self, input, output): self.assertEqual(merge(input), output) def test_raises_ExclusiveConstraints(self): self.assertRaises(ExclusiveConstraints, merge, [Constraint.parse('==1'), Constraint.parse('==2')]) self.assertRaises(ExclusiveConstraints, merge, [Constraint.parse('>2'), Constraint.parse('<1')]) self.assertRaises(ExclusiveConstraints, merge, [Constraint.parse('>2'), Constraint.parse('<2')]) self.assertRaises(ExclusiveConstraints, merge, [Constraint.parse('>2'), Constraint.parse('<=2')]) # the first 2 constraints will be merge into ==2, # which conflicts with !=2 self.assertRaises(ExclusiveConstraints, merge, [Constraint.parse('<=2'), Constraint.parse('>=2'), Constraint.parse('!=2')]) def test(self): constraints = [Constraint.parse('>1'), Constraint.parse('<2')] self.assertMerge(constraints, constraints) self.assertMerge([Constraint.parse('<2'), Constraint.parse('<3')], [Constraint.parse('<2.0.0')]) self.assertMerge([Constraint.parse('<2'), Constraint.parse('>=1')], [Constraint.parse('>=1.0.0'), Constraint.parse('<2.0.0')]) self.assertMerge([Constraint.parse('>=2'), Constraint.parse('>2')], [Constraint.parse('>2.0.0')]) self.assertMerge([Constraint.parse('>1'), Constraint.parse('>=2')], [Constraint.parse('>=2.0.0')]) self.assertMerge([Constraint.parse('<2'), Constraint.parse('<=1')], [Constraint.parse('<=1.0.0')]) self.assertMerge([Constraint.parse('<=2'), Constraint.parse('<1')], [Constraint.parse('<1.0.0')]) self.assertMerge([Constraint.parse('<=2'), Constraint.parse('>=2')], [Constraint.parse('==2.0.0')]) # Negative constraints should not be omitted! self.assertMerge([Constraint.parse('!=2'), Constraint.parse('!=1')], sorted([Constraint.parse('!=1.0.0'), Constraint.parse('!=2.0.0')]))
40.221053
83
0.559016
3,667
0.959696
0
0
0
0
0
0
479
0.12536
dfe01ac7f7adb258b0362ce750c15bb90b3ecb5f
520
py
Python
run.py
bayusetiawan01/poj
9c205ce298a2b3ca0d9c00b7d4a3fd05fecf326a
[ "MIT" ]
25
2016-02-26T17:35:19.000Z
2021-08-17T10:30:14.000Z
run.py
bayusetiawan01/poj
9c205ce298a2b3ca0d9c00b7d4a3fd05fecf326a
[ "MIT" ]
5
2016-04-27T16:52:46.000Z
2021-04-24T10:06:16.000Z
run.py
bayusetiawan01/poj
9c205ce298a2b3ca0d9c00b7d4a3fd05fecf326a
[ "MIT" ]
6
2016-04-27T16:50:13.000Z
2021-04-03T06:27:41.000Z
import sys import subprocess if __name__ == "__main__": try: executable = sys.argv[1] input_filename = sys.argv[2] output_filename = sys.argv[3] tl = sys.argv[4] except IndexError: sys.exit(-1) input_file = open(input_filename, "r") output_file = open(output_filename, "w") returncode = subprocess.call(["timeout", tl, "./{}".format(executable)], stdin = input_file, stdout = output_file) print(returncode) input_file.close() output_file.close()
27.368421
118
0.634615
0
0
0
0
0
0
0
0
31
0.059615
dfe12be6330b0968db19fa6ffe0881fb8fa8099d
1,224
py
Python
typefactory/constraints/numeric.py
stevemccartney/typefactory
75c9eb9eec9a7b9488db9cc0d06352f4fd1de1d9
[ "Apache-2.0" ]
null
null
null
typefactory/constraints/numeric.py
stevemccartney/typefactory
75c9eb9eec9a7b9488db9cc0d06352f4fd1de1d9
[ "Apache-2.0" ]
null
null
null
typefactory/constraints/numeric.py
stevemccartney/typefactory
75c9eb9eec9a7b9488db9cc0d06352f4fd1de1d9
[ "Apache-2.0" ]
null
null
null
from dataclasses import dataclass from numbers import Real from typing import Optional @dataclass class MultipleOf: param: Real def __call__(self, value: Real) -> Optional[str]: if value % self.param != 0: return f"Value must be a multiple of {self.param}" else: return None @dataclass class Minimum: param: Real def __call__(self, value: Real) -> Optional[str]: if value < self.param: return f"Value must be >= {self.param}" else: return None @dataclass class ExclusiveMinimum: param: Real def __call__(self, value: Real) -> Optional[str]: if value <= self.param: return f"Value must be > {self.param}" else: return None @dataclass class Maximum: param: Real def __call__(self, value: Real) -> Optional[str]: if value > self.param: return f"Value must be <= {self.param}" else: return None @dataclass class ExclusiveMaximum: param: Real def __call__(self, value: Real) -> Optional[str]: if value >= self.param: return f"Value must be < {self.param}" else: return None
20.745763
62
0.586601
1,067
0.871732
0
0
1,122
0.916667
0
0
169
0.138072
dfe159b3edd0ee9b633d2a90e3ddecd214d799b8
4,580
py
Python
Version Autonome/main.py
chiudidier/ProjetBloc5
214f401e5b35bc5894ecc3d20f338762b689f2ca
[ "CC0-1.0" ]
null
null
null
Version Autonome/main.py
chiudidier/ProjetBloc5
214f401e5b35bc5894ecc3d20f338762b689f2ca
[ "CC0-1.0" ]
null
null
null
Version Autonome/main.py
chiudidier/ProjetBloc5
214f401e5b35bc5894ecc3d20f338762b689f2ca
[ "CC0-1.0" ]
null
null
null
from taquin import * from random import * from math import * #main ''' old : ancienne façon de mélanger qui correspond à une manipulation du taquin. Plus à coder pour les élèves et pour faire des essais de profondeur montxt='012345678'# position initiale = solution montaquin=Taquin(montxt)# création du taquin # mélange en realisant 15 coups aléatoires à partir de la position initiale pour garantir que la position obtenu soit bien solutionnable. while montaquin.gagnant(): montaquin.melanger(15) ''' continuer=True while continuer: ''' #old : ancienne façon de mélanger qui correspond à une manipulation du taquin. Plus à coder pour les élèves et pour faire des essais de profondeur montxt='012345678'# position initiale = solution montaquin=Taquin(montxt)# création du taquin # mélange en realisant 15 coups aléatoires à partir de la position initiale pour garantir que la position obtenu soit bien solutionnable. while montaquin.estGagnant(): montaquin.melanger(15) ''' # création aléatoire du taquin initiale, n'utiliser qu'avec IDA montxt=random_init('012345678')# position initiale créé à partir d'une position aléatoire mais dont la solvabilité est vérifiable montaquin=Taquin(montxt)# création du taquin print(montaquin) # valeur arbitrairement choisie : une valeur plus grande donnera des taquins plus difficiles if nbcoup(montxt) > 8 : print('dsl nous ne pouvont pas résoudre se taquin en un temps raisonable') else: while not montaquin.estGagnant():# boucle principale du jeu. Sort qaund le taquin est rangé chemin=[] ''' #version BFS # attention ne pas utiliser cette version avec la génération de taquin aléatoire mais utiliser le mélange à base de coup aléatoire depuis la solution. reste=bfs(montaquin.etat)# calcul la profondeur minimum de la solution print(reste,' mouvements au moins pour terminer.')# affiche l'aide #fin version BFS ''' ''' #version DLS=BFS+DFS # attention ne pas utuiliser cette version avec la génération de taquin aléatoire mais utiliser le mélange à base de coup aléatoire depuis la solution. reste=bfs(montaquin.etat)# calcul la profondeur minimum de la solution dls(reste,montaquin.etat,0,chemin) #version DLS = DFS + BFS # attention ne pas utuiliser cette version avec la génération de taquin aléatoire mais utiliser le mélange à base de coup aléatoire depuis la solution. #fin version DLS ''' ''' #version IDS = itération d'IDS # attention ne pas utiliser cette version avec la génération de taquin aléatoire mais utiliser le mélange à base de coup aléatoire depuis la solution. #ids(montaquin.etat,chemin) #fin version IDS ''' ''' #version IDA calcule la profondeur minimum de la solution, les paramètres ne sont pas indispensables mais améliorent la lisibilité du code ''' ida(montaquin.etat,chemin) # cette partie est utilisable pour les version IDS, DFS et IDA print('solution = ', chemin)#affichage des differents etats de la solution print('nb coup à la solution',len(chemin)) nextmove=chemin.pop() nexttaquin=Taquin(nextmove) print('meilleur coup suivant :') print(comparetaquins(montaquin,nexttaquin))#affichage du prochain coup #fin de la partie solution # enregistrement du coup du joueur move=input('\n que voulez vous jouer (h,b,d,g): ')# demande le coup à jouer et applique le mouvement if move=='h': montaquin.haut() elif move=='b': montaquin.bas() elif move=='d': montaquin.droite() elif move=='g': montaquin.gauche() print(montaquin) # fin du coup du joueur print('Bravo vous avez gagné !') reponse=input('Voulez vous recommencer ? o/n : ') if reponse == 'n': continuer=False print('Au revoir')
24.491979
224
0.606332
0
0
0
0
0
0
0
0
3,372
0.726411
dfe1a99576a2d37093ebe1a9717fd7144a854d6e
1,870
py
Python
bindings/python/test/test_objects.py
open-space-collective/open-space-toolkit-mathematics
4b97f97f4aaa87bff848381a3519c6f764461378
[ "Apache-2.0" ]
5
2020-05-11T02:22:05.000Z
2022-02-02T15:26:35.000Z
bindings/python/test/test_objects.py
open-space-collective/open-space-toolkit-mathematics
4b97f97f4aaa87bff848381a3519c6f764461378
[ "Apache-2.0" ]
6
2020-01-05T20:18:18.000Z
2021-10-14T09:36:44.000Z
bindings/python/test/test_objects.py
open-space-collective/open-space-toolkit-mathematics
4b97f97f4aaa87bff848381a3519c6f764461378
[ "Apache-2.0" ]
2
2020-03-05T18:18:13.000Z
2020-04-07T17:42:24.000Z
################################################################################################################################################################ # @project Open Space Toolkit ▸ Mathematics # @file bindings/python/test/test_objects.py # @author Lucas Brémond <[email protected]> # @license Apache License 2.0 ################################################################################################################################################################ import ostk.mathematics as mathematics ################################################################################################################################################################ Angle = mathematics.geometry.Angle Point2d = mathematics.geometry.d2.objects.Point Polygon2d = mathematics.geometry.d2.objects.Polygon Transformation2d = mathematics.geometry.d2.Transformation Point3d = mathematics.geometry.d3.objects.Point PointSet3d = mathematics.geometry.d3.objects.PointSet Line3d = mathematics.geometry.d3.objects.Line Ray3d = mathematics.geometry.d3.objects.Ray Segment3d = mathematics.geometry.d3.objects.Segment Plane = mathematics.geometry.d3.objects.Plane Polygon3d = mathematics.geometry.d3.objects.Polygon Cuboid = mathematics.geometry.d3.objects.Cuboid Sphere = mathematics.geometry.d3.objects.Sphere Ellipsoid = mathematics.geometry.d3.objects.Ellipsoid Transformation3d = mathematics.geometry.d3.Transformation Quaternion = mathematics.geometry.d3.transformations.rotations.Quaternion RotationVector = mathematics.geometry.d3.transformations.rotations.RotationVector RotationMatrix = mathematics.geometry.d3.transformations.rotations.RotationMatrix ################################################################################################################################################################
53.428571
160
0.535294
0
0
0
0
0
0
0
0
838
0.447411
dfe2bc23e1d5c4fe435748a54d9f2a2f9b030af5
1,005
py
Python
twemoji/mkqrc.py
ericosur/myqt
e96f77f99442c44e51a1dbe1ee93edfa09b3db0f
[ "MIT" ]
null
null
null
twemoji/mkqrc.py
ericosur/myqt
e96f77f99442c44e51a1dbe1ee93edfa09b3db0f
[ "MIT" ]
null
null
null
twemoji/mkqrc.py
ericosur/myqt
e96f77f99442c44e51a1dbe1ee93edfa09b3db0f
[ "MIT" ]
null
null
null
#!/usr/bin/env python3 # coding: utf-8 ''' helper to generate emoji.qrc ''' from glob import glob import sys import re def output_qrc(arr, fn='emoji.qrc') -> None: ''' emoji.qrc ''' header = '''<RCC> <qresource prefix="/">''' footer = ''' </qresource> </RCC>''' with open(fn, 'wt', encoding='utf8') as fobj: print(header, file=fobj) for f in arr: print(f' <file>{f}</file>', file=fobj) print(footer, file=fobj) print('output to:', fn) def output_list(arr, fn='parse_list/list.txt') -> None: ''' output arr ''' with open(fn, 'wt', encoding='utf8') as fobj: for f in arr: r = re.sub(r'^72x72\/(.+)\.png', r'\1', f) print(r, file=fobj) print('output to:', fn) def main() -> None: ''' main ''' arr = glob('72x72/*.png') #print('len:', len(arr)) if not arr: sys.exit(1) arr.sort() output_qrc(arr) output_list(arr) if __name__ == '__main__': main()
22.333333
57
0.528358
0
0
0
0
0
0
0
0
362
0.360199
dfe2c5242a263720a913b48fff9c5a2c72756ddd
1,246
py
Python
Python3-StandardLibrary/Chapter16_Web03_cgi.py
anliven/Reading-Code-Learning-Python
a814cab207bbaad6b5c69b9feeb8bf2f459baf2b
[ "Apache-2.0" ]
null
null
null
Python3-StandardLibrary/Chapter16_Web03_cgi.py
anliven/Reading-Code-Learning-Python
a814cab207bbaad6b5c69b9feeb8bf2f459baf2b
[ "Apache-2.0" ]
null
null
null
Python3-StandardLibrary/Chapter16_Web03_cgi.py
anliven/Reading-Code-Learning-Python
a814cab207bbaad6b5c69b9feeb8bf2f459baf2b
[ "Apache-2.0" ]
null
null
null
# -*- coding: utf-8 -*- import cgi form = cgi.FieldStorage() # 创建FieldStorage实例(应只创建一个) name = form.getvalue('name', 'world') # CGI脚本通过getvalue方法获取值,这里默认值为world print("""Content-type: text/html <html> <head> <title>Greeting Page</title> </head> <body> <h1>Hello, {}!</h1> <form action='Chapter16_Web03_cgi.py'> Change Name:<input type='text' name='name'> <input type='submit' value='Submit'> </form> </body> </html> """.format(name)) # ### 脚本说明 # 实现包含HTML表单的简单CGI脚本; # 执行脚本: # 1-启动支持cgi的Web服务器:在命令行下执行“py -3 -m http.server --cgi”; # 2-将本CGI脚本放在服务器所在目录的子目录cgi-bin,并设置权限; # 3-在浏览器打开“http://127.0.0.1:8000/cgi-bin/Chapter16_Web03_cgi.py”; # 4-填写文本并提交,将显示形如“Hello world”的内容; # # ### HTML表单的相关说明 # - HTML表单是一个包含表单元素的区域,允许用户在表单中输入内容,比如文本域、下拉列表、单选框、复选框、提交按钮等; # - 使用表单标签<form>来设置,属性action设置为脚本的名称,意味着提交表单后将再次运行这个脚本; # - 输入元素标签<input>:输入类型由类型属性(type)定义; # # ### Web框架 # 对于重要或复杂的Web应用,一般不会直接为其编写繁琐的CGI脚本,而是使用Web框架,自动完成很多繁重的环节; # 更多信息:Python的Web编程指南(https://wiki.python.org/moin/WebProgramming); # # ### Web框架Flask # 简单又实用的Flask,适用于较复杂的服务端Web应用开发; # A simple framework for building complex web applications. # Home-page: https://www.palletsprojects.com/p/flask/ # Documentation:http://flask.pocoo.org/docs/
28.318182
73
0.699839
0
0
0
0
0
0
0
0
1,788
0.941053
dfe2c9adf24a8776a39019cdfbf8a0a54e0be58c
1,809
py
Python
predefined_values.py
kovvik/bert_reader
1b3b6a2bc29a026c64d2d7ba53ec5fabebf1f9e5
[ "MIT" ]
null
null
null
predefined_values.py
kovvik/bert_reader
1b3b6a2bc29a026c64d2d7ba53ec5fabebf1f9e5
[ "MIT" ]
null
null
null
predefined_values.py
kovvik/bert_reader
1b3b6a2bc29a026c64d2d7ba53ec5fabebf1f9e5
[ "MIT" ]
null
null
null
# https://uefi.org/sites/default/files/resources/UEFI%20Spec%202_6.pdf # N.2.2 Section Descriptor section_types = { "9876ccad47b44bdbb65e16f193c4f3db": { "name": "Processor Generic", "error_record_reference": {} }, "dc3ea0b0a1444797b95b53fa242b6e1d": { "name": "Processor Specific - IA32/X64", "error_record_reference": {} }, "e429faf13cb711d4bca70080c73c8881": { "name": "Processor Specific - IPF", "error_record_reference": {} }, "e19e3d16bc1111e49caac2051d5d46b0": { "name": "Processor Specific - ARM", "error_record_reference": {} }, "a5bc11146f644edeb8633e83ed7c83b1": { "name": "Platform Memory", "error_record_reference": {} }, "d995e954bbc1430fad91b44dcb3c6f35": { "name": "PCIe", "error_record_reference": {} }, "81212a9609ed499694718d729c8e69ed": { "name": "Firmware Error Record Reference", "error_record_reference": { "firmware_error_record_type": (0, 1, "byte"), "reserved": (1, 7, "hex"), "record_identifier": (8, 8, "hex") } }, "c57539633b844095bf78eddad3f9c9dd": { "name": "PCI/PCI-X Bus", "error_record_reference": {} }, "eb5e4685ca664769b6a226068b001326": { "name": "DMAr Generic", "error_record_reference": {} }, "71761d3732b245cda7d0b0fedd93e8cf": { "name": "Intel® VT for Directed I/O specific DMAr section", "error_record_reference": {} }, "036f84e17f37428ca79e575fdfaa84ec": { "name": "IOMMU specific DMAr section", "error_record_reference": {} } } error_severity = [ "Recoverable (also called non-fatal uncorrected)", "Fatal", "Corrected", "Informational" ]
29.177419
70
0.599779
0
0
0
0
0
0
0
0
1,222
0.675138
dfe30fcd6927ef89f0f16539956bef3a4837e607
1,336
py
Python
tests/filestack_helpers_test.py
SanthoshBala18/filestack-python
db55f3a27a4d073e1ba33d3d09a3def8da1a25e4
[ "Apache-2.0" ]
47
2017-01-28T12:27:18.000Z
2021-07-02T16:29:04.000Z
tests/filestack_helpers_test.py
malarozi/filestack-python
7109a9c20225532c95f0204d12649137c0de01a1
[ "Apache-2.0" ]
36
2017-01-25T23:48:33.000Z
2022-01-29T22:33:12.000Z
tests/filestack_helpers_test.py
malarozi/filestack-python
7109a9c20225532c95f0204d12649137c0de01a1
[ "Apache-2.0" ]
24
2017-01-24T23:57:32.000Z
2022-01-29T22:34:34.000Z
import pytest from filestack.helpers import verify_webhook_signature @pytest.mark.parametrize('signature, expected_result', [ ('57cbb25386c3d6ff758a7a75cf52ba02cf2b0a1a2d6d5dfb9c886553ca6011cb', True), ('incorrect-signature', False), ]) def test_webhook_verification(signature, expected_result): secret = 'webhook-secret' body = b'{"text": {"filename": "filename.jpg", "key": "kGaeljnga9wkysK6Z_filename.jpg"}}' headers = { 'FS-Signature': signature, 'FS-Timestamp': 123456789999 } result, details = verify_webhook_signature(secret, body, headers) assert result is expected_result if expected_result is False: assert 'Signature mismatch' in details['error'] @pytest.mark.parametrize('secret, body, headers, err_msg', [ ('hook-secret', b'body', 'should be a dict', 'value is not a dict'), (1, b'body', {'FS-Signature': 'abc', 'FS-Timestamp': 123}, 'value is not a string'), ('hook-secret', b'', {'FS-Timestamp': 123}, 'fs-signature header is missing'), ('hook-secret', ['incorrect'], {'FS-Signature': 'abc', 'FS-Timestamp': 123}, 'Invalid webhook body'), ]) def test_agrument_validation(secret, body, headers, err_msg): result, details = verify_webhook_signature(secret, body, headers) assert result is False assert err_msg in details['error']
40.484848
105
0.695359
0
0
0
0
1,261
0.943862
0
0
570
0.426647
dfe42600497b94099e0a72123b092ceef56b943a
4,558
py
Python
pattern/check_multiples.py
Lostefra/TranslationCoherence
b7b09c475cc78842d9724161a8cbee372d41da08
[ "MIT" ]
null
null
null
pattern/check_multiples.py
Lostefra/TranslationCoherence
b7b09c475cc78842d9724161a8cbee372d41da08
[ "MIT" ]
null
null
null
pattern/check_multiples.py
Lostefra/TranslationCoherence
b7b09c475cc78842d9724161a8cbee372d41da08
[ "MIT" ]
null
null
null
import rdflib from rdflib.term import URIRef from utilities.utility_functions import prefix from utilities import constants def has_equivalent(node, graph): equivalents = list(graph.subjects(predicate=constants.EQUIVALENCE_PREDICATE, object=node)) + \ list(graph.subjects(predicate=constants.SYNONYMY_PREDICATE, object=node)) + \ list(graph.objects(subject=node, predicate=constants.EQUIVALENCE_PREDICATE)) + \ list(graph.objects(subject=node, predicate=constants.SYNONYMY_PREDICATE)) if equivalents: return True return False # def multiple_classified(node1, node2, n, result_graph): # expressions = result_graph.subject_objects(predicate=n.differentExpression) # exprs_1, exprs_2 = [], [] # list_exprs = list(map(list, zip(*expressions))) # if list_exprs: # exprs_1, exprs_2 = list_exprs[0], list_exprs[1] # # print(f"{exprs_1}, {exprs_2}") # return any([(expr_1, n.involves_node, node1) in result_graph for expr_1 in exprs_1 + exprs_2]) or \ # any([(expr_2, n.involves_node, node2) in result_graph for expr_2 in exprs_2 + exprs_1]) # return False def check_multiples(g1, g2, n, result_graph, indexes, lemmas, frontiers, new_frontiers): # Check for pattern "several" # fred:number_1 fred:numberOf | bunchOf | seriesOf, quant:hasQuantifier quant:multiple | quant:some, hasQuality fred:Several multiples = ['number', 'bunch', 'series', 'array', 'collection', 'group', 'amount'] quantifiers = ['multiple', 'some', 'many'] quant_predicate = URIRef(constants.NAMESPACES['quant'] + 'hasQuantifier') for node1, node2 in frontiers: objs = list(g2.objects(subject=node2, predicate=quant_predicate)) if any([q in obj for q in quantifiers for obj in objs]):# and not multiple_classified(node1, node2, n, result_graph): # print(f"OBJS: {[prefix(o2, g2) for o2 in objs]}") for s1, p1 in g1.subject_predicates(object=node1): if not has_equivalent(s1, result_graph): for m in multiples: if m in prefix(p1, g1):# and any([q in prefix(o2,g2) for q in quantifiers for o2 in objs]): # Create a hierarchy relationship # "multiples_i" is a reification of a N-ary relationship expr_1 = "expression_" + next(indexes["expressions"]) expr_2 = "expression_" + next(indexes["expressions"]) result_graph.add((n[expr_1], constants.TYPE_PREDICATE, rdflib.term.URIRef(constants.NAMESPACES["translation_coherence_vocabulary"] + "Expression"))) result_graph.add((n[expr_2], constants.TYPE_PREDICATE, rdflib.term.URIRef(constants.NAMESPACES["translation_coherence_vocabulary"] + "Expression"))) result_graph.add((n[expr_1], n.involvesNoun, node1)) result_graph.add((n[expr_1], n.involvesMultiple, s1)) result_graph.add((n[expr_2], n.involvesNoun, node2)) for obj in objs: result_graph.add((n[expr_2], quant_predicate, obj)) result_graph.add((n[expr_1], n.differentExpression, n[expr_2])) # print("FOUND", prefix(node1, g1), prefix(p1, g1), prefix(node2, g2), [prefix(o2, g2) for o2 in objs]) objs = list(g1.objects(subject=node1, predicate=quant_predicate)) if any([q in obj for q in quantifiers for obj in objs]):# and not multiple_classified(node1, node2, n, result_graph): # print(f"OBJS: {[prefix(o1, g1) for o1 in objs]}") for s2,p2 in g2.subject_predicates(object=node2): if not has_equivalent(s2, result_graph): for m in multiples: if m in prefix(p2, g2):# and any([q in prefix(o1,g1) for q in quantifiers for o1 in objs]): # Create a hierarchy relationship # "multiples_i" is a reification of a N-ary relationship expr_1 = "expression_" + next(indexes["expressions"]) expr_2 = "expression_" + next(indexes["expressions"]) result_graph.add((n[expr_1], constants.TYPE_PREDICATE, rdflib.term.URIRef(constants.NAMESPACES["translation_coherence_vocabulary"] + "Expression"))) result_graph.add((n[expr_2], constants.TYPE_PREDICATE, rdflib.term.URIRef(constants.NAMESPACES["translation_coherence_vocabulary"] + "Expression"))) result_graph.add((n[expr_1], n.involvesNoun, node1)) for obj in objs: result_graph.add((n[expr_1], quant_predicate, obj)) result_graph.add((n[expr_2], n.involvesNoun, node2)) result_graph.add((n[expr_2], n.involvesMultiple, s2)) result_graph.add((n[expr_1], n.differentExpression, n[expr_2])) # print("FOUND", prefix(node2, g2), prefix(p2, g2), prefix(node1, g1), [prefix(o1, g1) for o1 in objs])
54.915663
125
0.698113
0
0
0
0
0
0
0
0
1,813
0.397762
dfe4a5779ee044b60ee7d70e0fc7668e972bffae
5,875
py
Python
app/main/views.py
Ammoh-Moringa/pitches
2551f2c8e323066ebdde3f92046368d7c7759fa6
[ "MIT" ]
null
null
null
app/main/views.py
Ammoh-Moringa/pitches
2551f2c8e323066ebdde3f92046368d7c7759fa6
[ "MIT" ]
null
null
null
app/main/views.py
Ammoh-Moringa/pitches
2551f2c8e323066ebdde3f92046368d7c7759fa6
[ "MIT" ]
null
null
null
from flask import render_template, request, redirect, url_for, abort from flask_login import login_required, current_user from . forms import PitchForm, CommentForm, CategoryForm from .import main from .. import db from ..models import User, Pitch, Comments, PitchCategory, Votes #display categories on the landing page @main.route('/') def index(): """ View root page function that returns index page """ all_category = PitchCategory.get_categories() all_pitches = Pitch.query.order_by('id').all() print(all_pitches) title = 'Home- Welcome' return render_template('index.html', title = title, categories=all_category, all_pitches=all_pitches) #Route for adding a new pitch @main.route('/pitch/newpitch',methods= ['POST','GET']) @login_required def newPitch(): pitch = PitchForm() if pitch.validate_on_submit(): title = pitch.pitch_title.data category = pitch.pitch_category.data yourPitch = pitch.pitch_comment.data #update pitch instance newPitch = Pitch(pitch_title = title,pitch_category = category,pitch_comment = yourPitch,user= current_user) #save pitch newPitch.save_pitch() return redirect(url_for('.index')) title = 'NEW PITCH' return render_template('new_pitch.html',title = title,pitchform = pitch) @main.route('/categories/<int:id>') def category(id): category = PitchCategory.query.get(id) if category is None: abort(404) pitches=Pitch.get_pitches(id) return render_template('category.html', pitches=pitches, category=category) @main.route('/add/category', methods=['GET','POST']) @login_required def new_category(): """ View new group route function that returns a page with a form to create a category """ form = CategoryForm() if form.validate_on_submit(): name = form.name.data new_category = PitchCategory(name = name) new_category.save_category() return redirect(url_for('.index')) title = 'New category' return render_template('new_category.html', category_form = form, title = title) #view single pitch alongside its comments @main.route('/comment/<int:id>',methods= ['POST','GET']) @login_required def viewPitch(id): onepitch = Pitch.getPitchId(id) comments = Comments.get_comments(id) if request.args.get("like"): onepitch.likes = onepitch.likes + 1 db.session.add(onepitch) db.session.commit() return redirect("/comment/{pitch_id}".format(pitch_id=category.id)) elif request.args.get("dislike"): onepitch.dislikes = onepitch.dislikes + 1 db.session.add(onepitch) db.session.commit() return redirect("/comment/{pitch_id}".format(pitch_id=category.id)) commentForm = CommentForm() if commentForm.validate_on_submit(): opinion = commentForm.opinion.data newComment = Comments(opinion = opinion,user = current_user,pitches_id= id) newComment.save_comment() return render_template('comments.html',commentForm = commentForm,comments = comments,pitch = onepitch) #adding a comment @main.route('/write_comment/<int:id>', methods=['GET', 'POST']) @login_required def post_comment(id): """ Function to post comments """ form = CommentForm() title = 'post comment' pitches = Pitch.query.filter_by(id=id).first() if pitches is None: abort(404) if form.validate_on_submit(): opinion = form.opinion.data new_comment = Comments(opinion = opinion, user_id = current_user.id, pitches_id = pitches.id) new_comment.save_comment() return redirect(url_for('.view_pitch', id = pitches.id)) return render_template('post_comment.html', comment_form = form, title = title) @main.route('/category/interview',methods= ['GET']) def displayInterviewCategory(): interviewPitches = Pitch.get_pitches('interview') return render_template('interviews.html',interviewPitches = interviewPitches) @main.route('/category/product',methods= ['POST','GET']) def displayProductCategory(): productPitches = Pitch.get_pitches('product') return render_template('product.html',productPitches = productPitches) @main.route('/category/promotion',methods= ['POST','GET']) def displayPromotionCategory(): promotionPitches = Pitch.get_pitches('promotion') return render_template('promotion.html',promotionPitches = promotionPitches) @main.route('/category/pickup',methods= ['POST','GET']) def displayPickupCategory(): pickupPitches = Pitch.get_pitches('pickup') return render_template('pickup.html',pickupPitches = pickupPitches) #Routes upvoting/downvoting pitches @main.route('/pitch/upvote/<int:id>&<int:vote_type>') @login_required def upvote(id,vote_type): """ View function that adds one to the vote_number column in the votes table """ # Query for user votes = Votes.query.filter_by(user_id=current_user.id).all() print(f'The new vote is {votes}') to_str=f'{vote_type}:{current_user.id}:{id}' print(f'The current vote is {to_str}') if not votes: new_vote = Votes(vote=vote_type, user_id=current_user.id, pitches_id=id) new_vote.save_vote() # print(len(count_likes)) print('YOU HAVE new VOTED') for vote in votes: if f'{vote}' == to_str: print('YOU CANNOT VOTE MORE THAN ONCE') break else: new_vote = Votes(vote=vote_type, user_id=current_user.id, pitches_id=id) new_vote.save_vote() print('YOU HAVE VOTED') break # count_likes = Votes.query.filter_by(pitches_id=id, vote=1).all() # upvotes=len(count_likes) # count_dislikes = Votes.query.filter_by(pitches_id=id, vote=2).all() return redirect(url_for('.view_pitch', id=id))
30.759162
116
0.683574
0
0
0
0
5,391
0.917617
0
0
1,513
0.257532
dfe61cbf2bb3b5a52f9141b8b81d778c054609e4
10,299
py
Python
networks/classes/centernet/models/ModelCenterNet.py
ALIENK9/Kuzushiji-recognition
a18c1fbfa72b6bbbcfe4004148cd0e90531acf6b
[ "MIT" ]
2
2019-09-15T08:52:38.000Z
2019-09-15T08:58:58.000Z
networks/classes/centernet/models/ModelCenterNet.py
MatteoRizzo96/CognitiveServices
a5efeb8f585ae2ee0465ab25e587c4db0e2b32b3
[ "MIT" ]
null
null
null
networks/classes/centernet/models/ModelCenterNet.py
MatteoRizzo96/CognitiveServices
a5efeb8f585ae2ee0465ab25e587c4db0e2b32b3
[ "MIT" ]
2
2020-11-06T07:29:56.000Z
2020-11-06T07:33:27.000Z
import glob import os import pandas as pd from tensorflow.python.keras.preprocessing.image import ImageDataGenerator from typing import Dict, List, Union, Tuple import numpy as np import tensorflow as tf from tensorflow.python.keras.callbacks import ModelCheckpoint, TensorBoard, LearningRateScheduler from networks.classes.centernet.datasets.ClassificationDataset import ClassificationDataset class ModelCenterNet: def __init__(self, logs: Dict): self.__logs = logs self.__input_width: int = None self.__input_height: int = None def build_model(self, model_generator, input_shape: Tuple[int, int, int], mode: str, n_category: int = 1) -> tf.keras.Model: """ Builds the network. :param model_generator: a generator for the network :param input_shape: the shape of the input images :param mode: the type of model that must be generated :param n_category: the number of categories (possible classes). Defaults to 1 in order to detect the presence or absence of an object only (and not its label). :return: a Keras model """ self.__input_width = input_shape[0] self.__input_height = input_shape[1] self.__logs['execution'].info('Building {} model...'.format(mode)) return model_generator.generate_model(input_shape, mode, n_category) @staticmethod def setup_callbacks(weights_log_path: str, batch_size: int, lr: float) -> List[ tf.keras.callbacks.Callback]: """ Sets up the callbacks for the training of the model. """ # Setup callback to save the best weights after each epoch checkpointer = ModelCheckpoint(filepath=os.path.join(weights_log_path, 'weights.{epoch:02d}-{val_loss:.2f}.hdf5'), verbose=0, save_best_only=True, save_weights_only=True, monitor='val_loss', mode='min') tensorboard_log_dir = os.path.join(weights_log_path, 'tensorboard') # Note that update_freq is set to batch_size * 10, # because the epoch takes too long and batch size too short tensorboard = TensorBoard(log_dir=tensorboard_log_dir, write_graph=True, histogram_freq=0, write_grads=True, write_images=False, batch_size=batch_size, update_freq=batch_size * 10) def lrs(epoch): if epoch > 10: return lr / 10 elif epoch > 6: return lr / 5 else: return lr lr_schedule = LearningRateScheduler(lrs, verbose=1) return [tensorboard, checkpointer, lr_schedule] def restore_weights(self, model: tf.keras.Model, init_epoch: int, weights_folder_path: str) -> None: """ Restores the weights from an existing weights file :param model: :param init_epoch: :param weights_folder_path: """ init_epoch_str = '0' + str(init_epoch) if init_epoch < 10 else str(init_epoch) restore_path_reg = os.path.join(weights_folder_path, 'weights.{}-*.hdf5'.format(init_epoch_str)) list_files = glob.glob(restore_path_reg) assert len(list_files) > 0, \ 'ERR: No weights file match provided name {}'.format(restore_path_reg) # Take real filename restore_filename = list_files[0].split('/')[-1] restore_path = os.path.join(weights_folder_path, restore_filename) assert os.path.isfile(restore_path), \ 'ERR: Weight file in path {} seems not to be a file'.format(restore_path) self.__logs['execution'].info("Restoring weights in file {}...".format(restore_filename)) model.load_weights(restore_path) def train(self, dataset: Union[tf.data.Dataset, ClassificationDataset], model: tf.keras.Model, init_epoch: int, epochs: int, batch_size: int, callbacks: List[tf.keras.callbacks.Callback], class_weights=None, augmentation: bool = False): """ Compiles and trains the model for the specified number of epochs. """ self.__logs['training'].info('Training the model...\n') # Display the architecture of the model self.__logs['training'].info('Architecture of the model:') model.summary() # Train the model self.__logs['training'].info('Starting the fitting procedure:') self.__logs['training'].info('* Total number of epochs: ' + str(epochs)) self.__logs['training'].info('* Initial epoch: ' + str(init_epoch) + '\n') training_set, training_set_size = dataset.get_training_set() validation_set, validation_set_size = dataset.get_validation_set() training_steps = training_set_size // batch_size + 1 validation_steps = validation_set_size // batch_size + 1 if augmentation: x_train, y_train = dataset.get_xy_training() x_val, y_val = dataset.get_xy_validation() train_image_data_generator = ImageDataGenerator(brightness_range=[0.7, 1.0], rotation_range=10, width_shift_range=0.1, height_shift_range=0.1, zoom_range=.1) val_image_data_generator = ImageDataGenerator() train_generator = train_image_data_generator.flow_from_dataframe( dataframe=pd.DataFrame({'image': x_train, 'class': y_train}), directory='', x_col='image', y_col='class', class_mode='other', target_size=(self.__input_width, self.__input_height), batch_size=batch_size) val_generator = val_image_data_generator.flow_from_dataframe( dataframe=pd.DataFrame({'image': x_val, 'class': y_val}), directory='', x_col='image', y_col='class', class_mode='other', target_size=(self.__input_width, self.__input_height), batch_size=batch_size) model.fit_generator(train_generator, epochs=epochs, steps_per_epoch=training_steps, validation_data=val_generator, validation_steps=validation_steps, callbacks=callbacks, initial_epoch=init_epoch, class_weight=class_weights) else: model.fit(training_set, epochs=epochs, steps_per_epoch=training_steps, validation_data=validation_set, validation_steps=validation_steps, callbacks=callbacks, initial_epoch=init_epoch, class_weight=class_weights) self.__logs['training'].info('Training procedure performed successfully!\n') def evaluate(self, model: tf.keras.Model, evaluation_set: Union[tf.data.Dataset, ClassificationDataset], evaluation_steps: Union[int, None] = None, batch_size: Union[int, None] = None, augmentation: bool = False) -> Union[float, List[float], None]: """ Evaluate the model on provided set. :return: the loss value if model has no other metrics, otw returns array with loss and metrics values. """ self.__logs['training'].info('Evaluating the model...') if augmentation: x_eval, y_eval = evaluation_set.get_xy_evaluation() data_generator = ImageDataGenerator() evaluation_set = data_generator.flow_from_dataframe( dataframe=pd.DataFrame({'image': x_eval, 'class': y_eval}), directory='', x_col='image', y_col='class', class_mode='other', target_size=(self.__input_width, self.__input_height), batch_size=batch_size) else: if evaluation_steps is not None and evaluation_steps == 0: self.__logs['training'].warn('Skipping evaluation since provided set is empty') return None return model.evaluate(evaluation_set, verbose=1, steps=evaluation_steps) def predict(self, model: tf.keras.Model, dataset: Union[tf.data.Dataset, List[str]], # List is for submission verbose: int = 1, steps: Union[int, None] = None, batch_size: Union[int, None] = None, augmentation: bool = False) -> Union[np.ndarray, List[np.ndarray]]: """ Performs a prediction on a given dataset """ self.__logs['test'].info("Predicting...") if augmentation: data_generator = ImageDataGenerator() generator = data_generator.flow_from_dataframe( dataframe=pd.DataFrame({'image': dataset}), directory='', x_col='image', class_mode=None, target_size=(self.__input_width, self.__input_height), batch_size=batch_size, shuffle=False) steps = 1 return model.predict_generator(generator, steps=steps, verbose=verbose) else: return model.predict(dataset, verbose=verbose, steps=steps)
40.869048
108
0.556656
9,899
0.961161
0
0
1,656
0.160792
0
0
2,031
0.197204
dfe9372c929b790c9a52b80b77bdd70cddddba45
187
py
Python
problem1.py
bakwc/PyCodeMonkey
32ea3a8947133ee9f96bea269a5dfd7a5b264ac1
[ "MIT" ]
null
null
null
problem1.py
bakwc/PyCodeMonkey
32ea3a8947133ee9f96bea269a5dfd7a5b264ac1
[ "MIT" ]
null
null
null
problem1.py
bakwc/PyCodeMonkey
32ea3a8947133ee9f96bea269a5dfd7a5b264ac1
[ "MIT" ]
null
null
null
# find fibonacci number def myFib(n): pass def tests(): assert myFib(1) == 1 assert myFib(2) == 1 assert myFib(3) == 2 assert myFib(4) == 3 assert myFib(5) == 5
15.583333
24
0.561497
0
0
0
0
0
0
0
0
23
0.122995
dfea1cd7528525e57a90decbb00e4b3b1963212b
4,114
py
Python
tests/web/test_show_image.py
AndrewLorente/catsnap
57427b8f61ef5185a41e49d55ffd7dd328777834
[ "MIT" ]
5
2015-11-23T18:40:00.000Z
2019-03-22T06:54:04.000Z
tests/web/test_show_image.py
AndrewLorente/catsnap
57427b8f61ef5185a41e49d55ffd7dd328777834
[ "MIT" ]
5
2016-04-07T15:35:53.000Z
2019-02-10T23:00:32.000Z
tests/web/test_show_image.py
AndrewLorente/catsnap
57427b8f61ef5185a41e49d55ffd7dd328777834
[ "MIT" ]
2
2015-12-02T16:44:05.000Z
2017-09-29T23:17:33.000Z
from __future__ import unicode_literals import json from tests import TestCase, with_settings from nose.tools import eq_ from catsnap import Client from catsnap.table.image import Image, ImageResize from catsnap.table.album import Album class TestShowImage(TestCase): @with_settings(aws={'bucket': 'snapcats'}) def test_view_an_image(self): session = Client().session() album = Album(name='cow shots') session.add(album) session.flush() prev_image = Image(filename='badcafe', album_id=album.album_id) session.add(prev_image) image = Image(filename='deadbeef', description='one time I saw a dead cow', title='dead beef', album_id=album.album_id) session.add(image) next_image = Image(filename='dadface', album_id=album.album_id) session.add(next_image) session.flush() response = self.app.get('/image/%d' % image.image_id) assert 'https://s3.amazonaws.com/snapcats/deadbeef' in response.data,\ response.data assert 'one time I saw a dead cow' in response.data, response.data assert 'cow shots' in response.data, response.data assert str(prev_image.image_id) in response.data, response.data assert str(next_image.image_id) in response.data, response.data @with_settings(aws={'bucket': 'snapcats'}) def test_view_an_image__defaults_to_medium(self): session = Client().session() image = Image(filename='deadbeef', description='one time I saw a dead cow', title='dead beef') session.add(image) session.flush() for (size, suffix) in [(100, 'thumbnail'), (320, 'small'), (500, 'medium'), (1600, 'large')]: session.add(ImageResize(image_id=image.image_id, width=size, height=size, suffix=suffix)) session.flush() response = self.app.get('/image/%d' % image.image_id) assert 'https://s3.amazonaws.com/snapcats/deadbeef_medium' in response.data,\ response.data # if no medium exists, assume it's because the original is smaller than a # "medium," and thus the original is an appropriate size. @with_settings(aws={'bucket': 'snapcats'}) def test_view_an_image__defaults_to_original_if_no_medium_exists(self): session = Client().session() image = Image(filename='deadbeef', description='one time I saw a dead cow', title='dead beef') session.add(image) session.flush() for (size, suffix) in [(100, 'thumbnail'), (320, 'small')]: session.add(ImageResize(image_id=image.image_id, width=size, height=size, suffix=suffix)) session.flush() response = self.app.get('/image/%d' % image.image_id) assert 'src="https://s3.amazonaws.com/snapcats/deadbeef"' in response.data,\ response.data @with_settings(aws={'bucket': 'snapcats'}) def test_get_image_info_as_json(self): session = Client().session() album = Album(name='cow shots') session.add(album) session.flush() image = Image(filename='deadbeef', description='one time I saw a dead cow', title='dead beef', album_id=album.album_id) session.add(image) image.add_tags(['cow', 'dead']) session.flush() response = self.app.get('/image/%d.json' % image.image_id) eq_(json.loads(response.data), { 'description': 'one time I saw a dead cow', 'title': 'dead beef', 'album_id': album.album_id, 'tags': [ 'cow', 'dead', ], 'source_url': 'https://s3.amazonaws.com/snapcats/deadbeef', 'camera': None, 'photographed_at': None, 'focal_length': None, 'aperture': None, 'shutter_speed': None, 'iso': None, })
39.557692
101
0.59018
3,874
0.941663
0
0
3,681
0.89475
0
0
938
0.228002
dfec725778cb5fb317db1061f7feba9a3d3f7b10
554
py
Python
tests/test_imgs2bw.py
antsfamily/improc
ceab171b0e61187fa2ced7c58540d5ffde79ebac
[ "MIT" ]
2
2019-09-29T08:43:31.000Z
2022-01-12T09:46:18.000Z
tests/test_imgs2bw.py
antsfamily/improc
ceab171b0e61187fa2ced7c58540d5ffde79ebac
[ "MIT" ]
null
null
null
tests/test_imgs2bw.py
antsfamily/improc
ceab171b0e61187fa2ced7c58540d5ffde79ebac
[ "MIT" ]
null
null
null
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Date : 2018-07-04 09:43:51 # @Author : Zhi Liu ([email protected]) # @Link : http://iridescent.ink # @Version : $1.1$ import matplotlib.cm as cm from matplotlib import pyplot as plt import improc as imp datafolder = '/mnt/d/DataSets/oi/nsi/classical/' imgspathes = [ datafolder + 'BaboonRGB.bmp', datafolder + 'LenaRGB.bmp', ] print(imgspathes) bws = imp.imgs2bw(imgspathes, 50) print(bws.dtype, bws.shape) print(bws) plt.figure() plt.imshow(bws[:, :, :, 0], cm.gray) plt.show()
19.103448
48
0.658845
0
0
0
0
0
0
0
0
235
0.424188
dfec78daa3bbf2130e5e79b3fbc047fcd7c950b3
764
py
Python
Un4/Un4.py
tonypithony/forktinypythonprojectsscripts
3dae818c822ee7de6de021e9f46d02bfe05f7355
[ "MIT" ]
null
null
null
Un4/Un4.py
tonypithony/forktinypythonprojectsscripts
3dae818c822ee7de6de021e9f46d02bfe05f7355
[ "MIT" ]
null
null
null
Un4/Un4.py
tonypithony/forktinypythonprojectsscripts
3dae818c822ee7de6de021e9f46d02bfe05f7355
[ "MIT" ]
null
null
null
#!/usr/bin/env python3 """Jump the Five""" import argparse # -------------------------------------------------- def get_args(): parser = argparse.ArgumentParser(description='Jump the Five', formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('text', metavar='str', help='Input text') return parser.parse_args() def main(): args = get_args() jumper = {'1': '9', '2': '8', '3': '7', '4': '6', '5': '0', '6': '4', '7': '3', '8': '2', '9': '1', '0': '5'} for char in args.text: print(jumper.get(char, char), end='') print() # -------------------------------------------------- if __name__ == '__main__': main() # $ ./Un4.py 867-5309 # 243-0751 # $ ./Un4.py 'Call 1-800-329-8044 today!' # Call 9-255-781-2566 today!
25.466667
64
0.522251
0
0
0
0
0
0
0
0
355
0.46466
dfed59a42f4a11efd34b43e01fd5f7beba8d46b6
169
py
Python
tests/web_platform/css_grid_1/abspos/test_grid_positioned_items_gaps.py
jonboland/colosseum
cbf974be54fd7f6fddbe7285704cfaf7a866c5c5
[ "BSD-3-Clause" ]
71
2015-04-13T09:44:14.000Z
2019-03-24T01:03:02.000Z
tests/web_platform/css_grid_1/abspos/test_grid_positioned_items_gaps.py
jonboland/colosseum
cbf974be54fd7f6fddbe7285704cfaf7a866c5c5
[ "BSD-3-Clause" ]
35
2019-05-06T15:26:09.000Z
2022-03-28T06:30:33.000Z
tests/web_platform/css_grid_1/abspos/test_grid_positioned_items_gaps.py
jonboland/colosseum
cbf974be54fd7f6fddbe7285704cfaf7a866c5c5
[ "BSD-3-Clause" ]
139
2015-05-30T18:37:43.000Z
2019-03-27T17:14:05.000Z
from tests.utils import W3CTestCase class TestGridPositionedItemsGaps(W3CTestCase): vars().update(W3CTestCase.find_tests(__file__, 'grid-positioned-items-gaps-'))
28.166667
82
0.804734
130
0.769231
0
0
0
0
0
0
29
0.171598
dff0a891ee94445188ef897fe40edf7b03e0dcdf
18
py
Python
src/__init__.py
PMantovani/pympu6050
bab4e680d700d9ad62855958cdb93feaaa16060c
[ "MIT" ]
null
null
null
src/__init__.py
PMantovani/pympu6050
bab4e680d700d9ad62855958cdb93feaaa16060c
[ "MIT" ]
null
null
null
src/__init__.py
PMantovani/pympu6050
bab4e680d700d9ad62855958cdb93feaaa16060c
[ "MIT" ]
null
null
null
name = "pympu6050"
18
18
0.722222
0
0
0
0
0
0
0
0
11
0.611111
dff25402be58788805ce4000a620f3bec7823781
4,537
py
Python
iocage/main.py
krcNAS/iocage
13d87e92f8ba186b6c8b7f64a948f26a05586430
[ "BSD-2-Clause" ]
null
null
null
iocage/main.py
krcNAS/iocage
13d87e92f8ba186b6c8b7f64a948f26a05586430
[ "BSD-2-Clause" ]
null
null
null
iocage/main.py
krcNAS/iocage
13d87e92f8ba186b6c8b7f64a948f26a05586430
[ "BSD-2-Clause" ]
null
null
null
# Copyright (c) 2014-2017, iocage # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted providing that the following conditions # are met: # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS # OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING # IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. """The main CLI for ioc.""" import locale import os import re import signal import subprocess as su import sys import click # This prevents it from getting in our way. from click import core import iocage.lib.ioc_check as ioc_check core._verify_python3_env = lambda: None user_locale = os.environ.get("LANG", "en_US.UTF-8") locale.setlocale(locale.LC_ALL, user_locale) # @formatter:off # Sometimes SIGINT won't be installed. # http://stackoverflow.com/questions/40775054/capturing-sigint-using-keyboardinterrupt-exception-works-in-terminal-not-in-scr/40785230#40785230 signal.signal(signal.SIGINT, signal.default_int_handler) # If a utility decides to cut off the pipe, we don't care (IE: head) signal.signal(signal.SIGPIPE, signal.SIG_DFL) # @formatter:on try: su.check_call(["sysctl", "vfs.zfs.version.spa"], stdout=su.PIPE, stderr=su.PIPE) except su.CalledProcessError: sys.exit("ZFS is required to use iocage.\n" "Try calling 'kldload zfs' as root.") def print_version(ctx, param, value): """Prints the version and then exits.""" if not value or ctx.resilient_parsing: return print("Version\t0.9.9.2 RC") sys.exit() cmd_folder = os.path.abspath(os.path.join(os.path.dirname(__file__), 'cli')) class IOCageCLI(click.MultiCommand): """ Iterates in the 'cli' directory and will load any module's cli definition. """ def list_commands(self, ctx): rv = [] for filename in os.listdir(cmd_folder): if filename.endswith('.py') and \ not filename.startswith('__init__'): rv.append(re.sub(".py$", "", filename)) rv.sort() return rv def get_command(self, ctx, name): try: mod = __import__(f"iocage.cli.{name}", None, None, ["cli"]) mod_name = mod.__name__.replace("iocage.cli.", "") try: if mod.__rootcmd__ and "--help" not in sys.argv[1:]: if len(sys.argv) != 1: if os.geteuid() != 0: sys.exit("You need to have root privileges to" f" run {mod_name}") except AttributeError: # It's not a root required command. pass return mod.cli except (ImportError, AttributeError): return @click.command(cls=IOCageCLI) @click.option("--version", "-v", is_flag=True, callback=print_version, help="Display iocage's version and exit.") def cli(version): """A jail manager.""" skip_check = False skip_check_cmds = ["--help", "activate", "-v", "--version"] try: if "iocage" in sys.argv[0] and len(sys.argv) == 1: skip_check = True for arg in sys.argv[1:]: if arg in skip_check_cmds: skip_check = True elif "clean" in arg: skip_check = True ioc_check.IOCCheck(silent=True) if not skip_check: ioc_check.IOCCheck() except RuntimeError as err: exit(err) if __name__ == '__main__': cli(prog_name="iocage")
33.858209
143
0.642054
1,152
0.253912
0
0
720
0.158695
0
0
2,191
0.482918
dff2b9a17cc9997e289067d562ccf28b75fc10b3
425
py
Python
bookinfo/models.py
dustfine/myPlaygroundSite
02db3321e9959437c588575f9df1079d2d8d1ed9
[ "MIT" ]
null
null
null
bookinfo/models.py
dustfine/myPlaygroundSite
02db3321e9959437c588575f9df1079d2d8d1ed9
[ "MIT" ]
null
null
null
bookinfo/models.py
dustfine/myPlaygroundSite
02db3321e9959437c588575f9df1079d2d8d1ed9
[ "MIT" ]
null
null
null
from django.db import models # Create your models here. class Publisher(models.Model): id = models.AutoField(primary_key=True) name = models.CharField(max_length=64, null=False, unique=True) class Book(models.Model): id = models.AutoField(primary_key=True) name = models.CharField(max_length=64, null=False, unique=True) publisher = models.ForeignKey(to=Publisher,on_delete=models.CASCADE,default=None)
35.416667
85
0.757647
365
0.858824
0
0
0
0
0
0
26
0.061176
dff4072d877687a20524346adc49201f57ca4cea
905
py
Python
svety/tests.py
clemsciences/svety
44a0c2ab5453e9d01b71b5a3f0e0e959740c2d90
[ "MIT" ]
null
null
null
svety/tests.py
clemsciences/svety
44a0c2ab5453e9d01b71b5a3f0e0e959740c2d90
[ "MIT" ]
null
null
null
svety/tests.py
clemsciences/svety
44a0c2ab5453e9d01b71b5a3f0e0e959740c2d90
[ "MIT" ]
null
null
null
""" """ import os import unittest from lxml import etree from svety import PACKDIR from svety import reader from svety import retriever __author__ = ["Clément Besnier <[email protected]>", ] class TestMain(unittest.TestCase): """ """ def setUp(self) -> None: self.filename = "hellqvist.xml" self.path = os.getcwd() retriever.retrieve_dictionary() def test_retrieve_text(self): result = retriever.retrieve_dictionary() self.assertTrue(result) self.assertIn(self.filename, os.listdir(self.path)) def test_root(self): root = reader.get_xml_root(self.filename, self.path) self.assertEqual(type(root), etree._Element) def test_lookup_word(self): root = reader.get_xml_root(self.filename, self.path) word = reader.read_entry(root, "enkom") self.assertEqual(word["faksimilID"], '0208')
23.205128
60
0.667403
703
0.775938
0
0
0
0
0
0
101
0.111479
dff5479d5d3e3729b12a7cdf8fd0b259fd5d0c88
5,424
py
Python
tests/internal/processes/test_generator.py
clausmichele/openeo-python-client
b20af2b24fcb12d0fce0e2acdb8afeeb881ff454
[ "Apache-2.0" ]
1
2021-04-01T13:15:35.000Z
2021-04-01T13:15:35.000Z
tests/internal/processes/test_generator.py
clausmichele/openeo-python-client
b20af2b24fcb12d0fce0e2acdb8afeeb881ff454
[ "Apache-2.0" ]
null
null
null
tests/internal/processes/test_generator.py
clausmichele/openeo-python-client
b20af2b24fcb12d0fce0e2acdb8afeeb881ff454
[ "Apache-2.0" ]
null
null
null
from textwrap import dedent from openeo.internal.processes.generator import PythonRenderer from openeo.internal.processes.parse import Process def test_render_basic(): process = Process.from_dict({ "id": "incr", "description": "Increment a value", "summary": "Increment a value", "parameters": [{"name": "x", "description": "value", "schema": {"type": "integer"}}], "returns": {"description": "incremented value", "schema": {"type": "integer"}} }) renderer = PythonRenderer() src = renderer.render_process(process) assert src == dedent('''\ def incr(x): """ Increment a value :param x: value :return: incremented value """ return process('incr', x=x)''') def test_render_no_params(): process = Process.from_dict({ "id": "pi", "description": "Pi", "summary": "Pi", "parameters": [], "returns": {"description": "value of pi", "schema": {"type": "number"}} }) renderer = PythonRenderer() src = renderer.render_process(process) assert src == dedent('''\ def pi(): """ Pi :return: value of pi """ return process('pi', )''') def test_render_with_default(): process = Process.from_dict({ "id": "incr", "description": "Increment a value", "summary": "Increment a value", "parameters": [ {"name": "x", "description": "value", "schema": {"type": "integer"}}, {"name": "i", "description": "increment", "schema": {"type": "integer"}, "default": 1}, ], "returns": {"description": "incremented value", "schema": {"type": "integer"}} }) renderer = PythonRenderer() src = renderer.render_process(process) assert src == dedent('''\ def incr(x, i=1): """ Increment a value :param x: value :param i: increment :return: incremented value """ return process('incr', x=x, i=i)''') def test_render_with_optional(): process = Process.from_dict({ "id": "foo", "description": "Foo", "summary": "Foo", "parameters": [ {"name": "x", "description": "value", "schema": {"type": "integer"}}, {"name": "y", "description": "something", "schema": {"type": "integer"}, "optional": True, "default": 1}, ], "returns": {"description": "new value", "schema": {"type": "integer"}} }) renderer = PythonRenderer(optional_default="UNSET") src = renderer.render_process(process) assert src == dedent('''\ def foo(x, y=UNSET): """ Foo :param x: value :param y: something :return: new value """ return process('foo', x=x, y=y)''') def test_render_return_type_hint(): process = Process.from_dict({ "id": "incr", "description": "Increment a value", "summary": "Increment a value", "parameters": [{"name": "x", "description": "value", "schema": {"type": "integer"}}], "returns": {"description": "incremented value", "schema": {"type": "integer"}} }) renderer = PythonRenderer(return_type_hint="FooBar") src = renderer.render_process(process) assert src == dedent('''\ def incr(x) -> FooBar: """ Increment a value :param x: value :return: incremented value """ return process('incr', x=x)''') def test_render_oo_no_params(): process = Process.from_dict({ "id": "pi", "description": "Pi", "summary": "Pi", "parameters": [], "returns": {"description": "value of pi", "schema": {"type": "number"}} }) renderer = PythonRenderer(oo_mode=True) src = "class Consts:\n" + renderer.render_process(process) assert src == dedent('''\ class Consts: def pi(self): """ Pi :return: value of pi """ return process('pi', )''') def test_render_keyword(): process = Process.from_dict({ "id": "or", "description": "Boolean and", "summary": "Boolean and", "parameters": [ {"name": "x", "description": "value", "schema": {"type": ["boolean", "null"]}}, {"name": "y", "description": "value", "schema": {"type": ["boolean", "null"]}} ], "returns": {"description": "result", "schema": {"type": ["boolean", "null"]}}, }) renderer = PythonRenderer() src = renderer.render_process(process) assert src == dedent('''\ def or_(x, y): """ Boolean and :param x: value :param y: value :return: result """ return process('or', x=x, y=y)''') oo_renderer = PythonRenderer(oo_mode=True, body_template="return {safe_name}({args})", ) src = oo_renderer.render_process(process) assert dedent(src) == dedent('''\ def or_(self, y): """ Boolean and :param self: value :param y: value :return: result """ return or_(x=self, y=y)''')
28.851064
117
0.50295
0
0
0
0
0
0
0
0
3,069
0.565819
dff6538ad1295913d7be8979ad8998c9e8d8ebc3
4,555
py
Python
python/tests/range.py
mizuki-nana/coreVM
1ff863b890329265a86ff46b0fdf7bac8e362f0e
[ "MIT" ]
2
2017-02-12T21:59:54.000Z
2017-02-13T14:57:48.000Z
python/tests/range.py
mizuki-nana/coreVM
1ff863b890329265a86ff46b0fdf7bac8e362f0e
[ "MIT" ]
null
null
null
python/tests/range.py
mizuki-nana/coreVM
1ff863b890329265a86ff46b0fdf7bac8e362f0e
[ "MIT" ]
null
null
null
# The MIT License (MIT) # Copyright (c) 2015 Yanzheng Li # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the 'Software'), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. ## ----------------------------------------------------------------------------- def test_range_with_one_argument(): print range(0) print range(1) print range(2) print range(5) print range(10) print range(100) print range(-1) print range(-2) print range(-5) print range(-10) print range(-100) print range(True) print range(False) ## ----------------------------------------------------------------------------- def test_range_with_one_invalid_argument(): def test_range_with_typeerror(x): try: range(x) except TypeError: print 'Expected TypeError on calling range() with argument' test_range_with_typeerror(None) test_range_with_typeerror(3.14) test_range_with_typeerror('1') ## ----------------------------------------------------------------------------- def test_range_with_two_arguments(): print range(0, 0) print range(0, 1) print range(1, 1) print range(1, 2) print range(1, 10) print range(2, 9) print range(0, 10) print range(1, 0) print range(0, -1) print range(100, 99) print range(10, 0) ## ----------------------------------------------------------------------------- def test_range_with_two_invalid_arguments(): def test_range_with_typeerror(x, y): try: range(x, y) except TypeError: print 'Expected TypeError on calling range() with argument' test_range_with_typeerror(0, None) test_range_with_typeerror(None, 1) test_range_with_typeerror(None, None) test_range_with_typeerror(0, 3.14) test_range_with_typeerror(3.14, 0) test_range_with_typeerror(3, '14') ## ----------------------------------------------------------------------------- def test_range_with_three_arguments(): print range(0, 0, 1) print range(0, 10, 1) print range(0, 10, 2) print range(10, 0, -1) print range(9, 1, -2) print range(-1, -2, -1) print range(0, 0, -1) print range(0, 10, -1) print range(0, 10, -2) print range(0, -10, 2) print range(9, -1, -2) print range(-1, -2, -1) print range(-1, -10, -12) print range(10, 0, 1) print range(9, 1, 2) print range(-1, -2, 1) ## ----------------------------------------------------------------------------- def test_range_with_three_invalid_arguments(): def test_range_with_typeerror(x, y, z): try: range(x, y, z) except TypeError: print 'Expected TypeError on calling range() with argument' test_range_with_typeerror(0, 0, None) test_range_with_typeerror(None, None, 1) test_range_with_typeerror(None, None, None) test_range_with_typeerror(0, 0, 3.14) test_range_with_typeerror(3.14, 0, 1) test_range_with_typeerror(3, '14', '1') def test_range_with_valueerror(x, y, z): try: range(x, y, z) except ValueError: print 'Expected ValueError on calling range() with argument' test_range_with_valueerror(0, 0, 0) ## ----------------------------------------------------------------------------- test_range_with_one_argument() test_range_with_one_invalid_argument() test_range_with_two_arguments() test_range_with_two_invalid_arguments() test_range_with_three_arguments() test_range_with_three_invalid_arguments() ## -----------------------------------------------------------------------------
31.413793
80
0.591438
0
0
0
0
0
0
0
0
1,958
0.429857
dff9aadffba2a29e37c671ac7172c7de73a82cb0
14,895
py
Python
hyperion/generators/adapt_sequence_batch_generator.py
jsalt2019-diadet/hyperion
14a11436d62f3c15cd9b1f70bcce3eafbea2f753
[ "Apache-2.0" ]
9
2019-09-22T05:19:59.000Z
2022-03-05T18:03:37.000Z
hyperion/generators/adapt_sequence_batch_generator.py
jsalt2019-diadet/hyperion
14a11436d62f3c15cd9b1f70bcce3eafbea2f753
[ "Apache-2.0" ]
null
null
null
hyperion/generators/adapt_sequence_batch_generator.py
jsalt2019-diadet/hyperion
14a11436d62f3c15cd9b1f70bcce3eafbea2f753
[ "Apache-2.0" ]
4
2019-10-10T06:34:05.000Z
2022-03-05T18:03:56.000Z
""" Copyright 2018 Jesus Villalba (Johns Hopkins University) Apache 2.0 (http://www.apache.org/licenses/LICENSE-2.0) """ from __future__ import absolute_import from __future__ import print_function from __future__ import division from six.moves import xrange import sys import os import argparse import time import copy import numpy as np from sklearn.utils.class_weight import compute_class_weight from ..hyp_defs import float_cpu from ..io import RandomAccessDataReaderFactory as RF from ..utils.scp_list import SCPList from ..utils.tensors import to3D_by_seq from ..transforms import TransformList from .sequence_batch_generator_v1 import SequenceBatchGeneratorV1 as SBG class AdaptSequenceBatchGenerator(SBG): def __init__(self, rspecifier, key_file, key_file_adapt, r_adapt=1, class_list = None, path_prefix=None, batch_size=1, iters_per_epoch='auto', gen_method='random', min_seq_length=None, max_seq_length=None, seq_overlap=0, prune_min_length=0, return_class = True, class_weight = None, seq_weight = 'balanced', shuffle_seqs=True, transform=None, init_epoch=0, sg_seed=1024, reset_rng=False, scp_sep=' ', part_idx=1, num_parts=1): self.scp_adapt = SCPList.load(key_file_adapt, sep=scp_sep) if num_parts > 1: self.scp_adapt = self.scp_adapt.split(part_idx, num_parts, group_by_key=False) assert r_adapt < batch_size self.r_adapt = r_adapt self._init_seq_lengths_adapt = None self._seq_lengths_adapt = None self.init_scp_adapt = self.scp_adapt self.cur_seq_adapt = 0 self.cur_frame_adapt = None self.cur_subseq = None self._init_num_subseqs_adapt = None self.num_subseqs_adapt = None super(AdaptSequenceBatchGenerator, self).__init__( rspecifier, key_file, class_list, path_prefix, batch_size, iters_per_epoch, gen_method, min_seq_length, max_seq_length, seq_overlap, prune_min_length, return_class, class_weight, seq_weight, shuffle_seqs, transform, init_epoch, sg_seed, reset_rng, scp_sep, part_idx,num_parts) @property def num_seqs(self): return len(self.scp) @property def num_seqs_adapt(self): return len(self.scp_adapt) @property def seq_lengths(self): if self._seq_lengths is None: self._init_seq_lengths = self.r.read_num_rows(self.scp.file_path) self._seq_lengths = self._init_seq_lengths return self._seq_lengths @property def seq_lengths_adapt(self): if self._seq_lengths_adapt is None: self._init_seq_lengths_adapt = self.r.read_num_rows(self.scp_adapt.file_path) self._seq_lengths_adapt = self._init_seq_lengths_adapt return self._seq_lengths_adapt @property def total_length(self): return np.sum(self.seq_lengths) @property def total_length_adapt(self): return np.sum(self.seq_lengths_adapt) @property def min_seq_length(self): if self._min_seq_length is None: self._min_seq_length = min(np.min(self.seq_lengths), np.min(self.seq_lengths_adapt)) return self._min_seq_length @property def max_seq_length(self): if self._max_seq_length is None: self._max_seq_length = max(np.max(self.seq_lengths), np.max(self.seq_lengths_adapt)) return self._max_seq_length @property def steps_per_epoch(self): if self._steps_per_epoch is None: if self.gen_method == 'sequential': if self.seq_weight == 'balanced': seqs_per_iter = self.num_seqs*np.max(self.num_subseqs) else: seqs_per_iter = np.sum(self.num_subseqs) else: seqs_per_iter = self.num_seqs self._steps_per_epoch = int(np.floor( self.iters_per_epoch * seqs_per_iter/(self.batch_size-self.r_adapt))) return self._steps_per_epoch @property def num_total_subseqs(self): return self.steps_per_epoch * self.batch_size def _prune_min_length(self, min_length): keep_idx = self.seq_lengths >= min_length self.scp = self.scp.filter_index(keep_idx) keep_idx = self.seq_lengths_adapt >= min_length self.scp_adapt = self.scp_adapt.filter_index(keep_idx) self._seq_lengths = None self._seq_lengths_adapt = None def _prepare_class_info(self, class_list): if class_list is None: class_dict = {k:i for i, k in enumerate(np.unique(self.scp.key))} class_dict.update({k:i for i, k in enumerate(np.unique(self.scp_adapt.key))}) else: with open(class_list) as f: class_dict={line.rstrip().split()[0]: i for i, line in enumerate(f)} self.num_classes = len(class_dict) self.key2class = {p: class_dict[k] for k, p in zip(self.scp.key, self.scp.file_path)} self.key2class.update({p: class_dict[k] for k, p in zip(self.scp_adapt.key, self.scp_adapt.file_path)}) def _balance_class_weight(self): super(AdaptSequenceBatchGenerator, self)._balance_class_weight() classes, class_ids = np.unique(self.scp_adapt.key, return_inverse=True) idx = self._balance_class_weigth_helper(class_ids) self.scp_adapt = self.scp_adapt.filter_index(idx) assert len(self.scp_adapt) == len(num_samples)*max_samples if self._init_seq_lengths_adapt is not None: self._init_seq_legths_adapt = self._init_seq_lengths_adapt[idx] self._seq_lengths_adapt = self._init_seq_legths_adapt def _prepare_full_seqs(self): pass def _prepare_random_subseqs(self): pass def _prepare_sequential_subseqs(self): super(AdaptSequenceBatchGenerator, self)._prepare_sequential_subseqs() seq_lengths = self.seq_lengths_adapt avg_length = int((self.max_seq_length + self.min_seq_length)/2) shift = avg_length - self.seq_overlap self._init_num_subseqs_adapt = np.ceil(seq_lengths/shift).astype(int) self.num_subseqs_adapt = self._init_num_subseqs_adapt self.cur_frame_adapt = np.zeros((self.num_seqs_adapt,), dtype=int) self.cur_subseq_adapt = np.zeros((self.num_seqs_adapt,), dtype=int) def reset(self): super(AdaptSequenceBatchGenerator, self).reset() self.cur_seq_adapt = 0 if self.shuffle_seqs: if self._init_seq_lengths_adapt is None: self.seq_lengths_adapt self.scp_adapt = self.init_scp_adapt.copy() index = self.scp_adapt.shuffle(rng=self.rng) self._seq_lengths_adapt = self._init_seq_lengths_adapt[index] if self._init_num_subseqs_adapt is not None: self.num_subseqs_adapt = self._init_num_subseqs_adapt[index] if self.gen_method == 'sequential': self.cur_subseq_adapt[:] = 0 self.cur_frame_adapt[:] = 0 def _read_full_seqs(self): batch_size = self.batch_size - self.r_adapt keys = list(self.scp.file_path[self.cur_seq:self.cur_seq+batch_size]) self.cur_seq += batch_size if len(keys) < batch_size: delta = batch_size - len(keys) keys += self.scp.file_path[:delta] self.cur_seq = delta assert len(keys) == batch_size batch_size = self.r_adapt keys_adapt = list(self.scp_adapt.file_path[self.cur_seq_adapt:self.cur_seq_adapt+batch_size]) self.cur_seq_adapt += batch_size if len(keys_adapt) < batch_size: delta = batch_size - len(keys) keys_adapt += self.scp_adapt.file_path[:delta] self.cur_seq_adapt = delta assert len(keys_adapt) == batch_size keys += keys_adapt return keys, self.r.read(keys) def _read_random_subseqs(self): keys = [] seq_lengths =[] first_frames = [] for i in xrange(self.batch_size-self.r_adapt): key = self.scp.file_path[self.cur_seq] full_seq_length = self.seq_lengths[self.cur_seq] max_seq_length = min(full_seq_length, self.max_seq_length) min_seq_length = min(full_seq_length, self.min_seq_length) seq_length = self.rng.randint(low=min_seq_length, high=max_seq_length+1) first_frame = self.rng.randint( low=0, high=full_seq_length-seq_length+1) keys.append(key) seq_lengths.append(seq_length) first_frames.append(first_frame) self.cur_seq = (self.cur_seq + 1) % self.num_seqs for i in xrange(self.r_adapt): key = self.scp_adapt.file_path[self.cur_seq_adapt] full_seq_length = self.seq_lengths_adapt[self.cur_seq_adapt] max_seq_length = min(full_seq_length, self.max_seq_length) min_seq_length = min(full_seq_length, self.min_seq_length) seq_length = self.rng.randint(low=min_seq_length, high=max_seq_length+1) first_frame = self.rng.randint( low=0, high=full_seq_length-seq_length+1) keys.append(key) seq_lengths.append(seq_length) first_frames.append(first_frame) self.cur_seq_adapt = (self.cur_seq_adapt + 1) % self.num_seqs_adapt return keys, self.r.read(keys, row_offset=first_frames, num_rows=seq_lengths) def _read_sequential_subseqs(self): keys = [] seq_lengths =[] first_frames = [] count = 0 while count < self.batch_size - self.r_adapt: key = self.scp.file_path[self.cur_seq] first_frame = self.cur_frame[self.cur_seq] full_seq_length = self.seq_lengths[self.cur_seq] remainder_seq_length = full_seq_length - first_frame if self.cur_subseq[self.cur_seq] == self.num_subseqs[self.cur_seq]: self.cur_seq = (self.cur_seq + 1) % self.num_seqs continue if self.cur_subseq[self.cur_seq] == self.num_subseqs[self.cur_seq]-1: seq_length = min(remainder_seq_length, self.max_seq_length) self.cur_frame[self.cur_seq] = 0 else: max_seq_length = min( max(self.min_seq_length, remainder_seq_length-self.min_seq_length), self.max_seq_length) min_seq_length = min(remainder_seq_length, self.min_seq_length) seq_length = self.rng.randint(low=min_seq_length, high=max_seq_length+1) self.cur_frame[self.cur_seq] = min( full_seq_length - self.min_seq_length, first_frame + seq_length - self.seq_overlap) keys.append(key) seq_lengths.append(seq_length) first_frames.append(first_frame) self.cur_subseq[self.cur_seq] += 1 if self.seq_weight == 'balanced': self.cur_subseq[self.cur_seq] %= self.num_subseqs[self.cur_seq] self.cur_seq = (self.cur_seq + 1) % self.num_seqs count += 1 while count < self.batch_size: key = self.scp_adapt.file_path[self.cur_seq_adapt] first_frame = self.cur_frame_adapt[self.cur_seq_adapt] full_seq_length = self.seq_lengths_adapt[self.cur_seq_adapt] remainder_seq_length = full_seq_length - first_frame if self.cur_subseq_adapt[self.cur_seq_adapt] == self.num_subseqs_adapt[self.cur_seq_adapt]: self.cur_seq_adapt = (self.cur_seq_adapt + 1) % self.num_seqs_adapt continue if self.cur_subseq_adapt[self.cur_seq_adapt] == self.num_subseqs_adapt[self.cur_seq_adapt]-1: seq_length = min(remainder_seq_length, self.max_seq_length) self.cur_frame_adapt[self.cur_seq_adapt] = 0 else: max_seq_length = min( max(self.min_seq_length, remainder_seq_length-self.min_seq_length), self.max_seq_length) min_seq_length = min(remainder_seq_length, self.min_seq_length) seq_length = self.rng.randint(low=min_seq_length, high=max_seq_length+1) self.cur_frame_adapt[self.cur_seq_adapt] = min( full_seq_length - self.min_seq_length, first_frame + seq_length - self.seq_overlap) keys.append(key) seq_lengths.append(seq_length) first_frames.append(first_frame) self.cur_subseq_adapt[self.cur_seq_adapt] += 1 if self.seq_weight == 'balanced': self.cur_subseq_adapt[self.cur_seq_adapt] %= self.num_subseqs_adapt[self.cur_seq_adapt] self.cur_seq_adapt = (self.cur_seq_adapt + 1) % self.num_seqs_adapt count += 1 assert len(keys) == self.batch_size return keys, self.r.read(keys, row_offset=first_frames, num_rows=seq_lengths) @staticmethod def filter_args(prefix=None, **kwargs): args = super(AdaptSequenceBatchGenerator, AdaptSequenceBatchGenerator).filter_args(prefix, **kwargs) if prefix is None: p = '' else: p = prefix + '_' valid_args = ('r_adapt',) new_args = dict((k, kwargs[p+k]) for k in valid_args if p+k in kwargs) args.update(new_args) return args @staticmethod def add_argparse_args(parser, prefix=None): args = super(AdaptSequenceBatchGenerator, AdaptSequenceBatchGenerator).add_argparse_args(parser, prefix) if prefix is None: p1 = '--' p2 = '' else: p1 = '--' + prefix + '-' p2 = prefix + '_' parser.add_argument(p1+'r-adapt', dest=(p2+'r_adapt'), default=64, type=int, help=('batch size of adaptation data.'))
34.320276
111
0.608728
14,209
0.953944
0
0
2,958
0.19859
0
0
284
0.019067
dffa822e50735b496917f2c8ca75cc5ca8d78488
1,113
py
Python
main.py
Lojlvenom/simple-python-blockchain
b226f81644daa066156aa5b9581c04cf4d47d0dc
[ "MIT" ]
null
null
null
main.py
Lojlvenom/simple-python-blockchain
b226f81644daa066156aa5b9581c04cf4d47d0dc
[ "MIT" ]
null
null
null
main.py
Lojlvenom/simple-python-blockchain
b226f81644daa066156aa5b9581c04cf4d47d0dc
[ "MIT" ]
null
null
null
import fastapi as _fastapi import blockchain as _blockchain app_desc = { 'title':'Simple python blockchain API', 'version':'1.0.0', } bc = _blockchain.Blockchain() app = _fastapi.FastAPI(**app_desc) def validade_blockchain(): if not bc._is_chain_valid(): return _fastapi.HTTPException( status_code= 400, detail="Blockchain nao e valida" ) @app.get("/", tags=["Endpoints"]) def hello(): return { "message":"Bem vindo ao simple python blockchain API, para saber mais acesse /docs" } # EP PARA ADICIONAR UM BLOCO @app.post("/mine_block/", tags=["Endpoints"]) def mine_block(data: str): validade_blockchain() block = bc.mine_block(data) return block @app.get("/blockchain/", tags=["Endpoints"]) def get_blockchain(): validade_blockchain chain = bc.chain return chain @app.get('/check_is_valid', tags=["Endpoints"]) def check_is_valid(): is_valid = validade_blockchain() if is_valid: return { "message": "Is valid" } else: return { "message": "Not valid" }
22.26
91
0.629829
0
0
0
0
688
0.618149
0
0
319
0.286613
dffa84ab01f78c539667e6f6871367dc2095eb09
1,747
py
Python
setup.py
SanjeevaRDodlapati/Chem-Learn
2db2e98061ee3dbb00ed20c51ea18b15956e298e
[ "MIT" ]
null
null
null
setup.py
SanjeevaRDodlapati/Chem-Learn
2db2e98061ee3dbb00ed20c51ea18b15956e298e
[ "MIT" ]
null
null
null
setup.py
SanjeevaRDodlapati/Chem-Learn
2db2e98061ee3dbb00ed20c51ea18b15956e298e
[ "MIT" ]
null
null
null
from glob import glob import os from setuptools import setup, find_packages def read(fname): return open(os.path.join(os.path.dirname(__file__), fname)).read() setup(name='chemlearn', version='0.0.0', description='Deep learning for chemistry', long_description=read('README.rst'), author='Sanjeeva Reddy Dodlapati', author_email='[email protected]', license="MIT", url='https://github.com/SanjeevaRDodlapati/Chem-Learn', packages=find_packages(), scripts=glob('./scripts/*.py'), install_requires=['h5py', 'argparse', 'pandas', 'numpy', 'pytest', 'torch', 'rdkit-pypi', ], keywords=['Deep learning', 'Deep neural networks', 'Molecular graphs', 'Drug discovery', 'Drug target interaction'], classifiers=['Development Status :: 0 - developmet', 'Environment :: Console', 'Intended Audience :: Science/Research', 'License :: OSI Approved :: MIT License', 'Natural Language :: English', 'Programming Language :: Python', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', 'Topic :: Scientific/Engineering :: Artificial Intelligence', 'Topic :: Scientific/Engineering :: Chem-Informatics', ] )
36.395833
80
0.499714
0
0
0
0
0
0
0
0
799
0.457355
dffe92bdb0898e53b6acb0b1fcb7c940caeeb1d9
49,731
py
Python
scripts/tests_with_setup.py
rombie/contrail-test
a68c71d6f282142501a7e2e889bbb232fdd82dc3
[ "Apache-2.0" ]
null
null
null
scripts/tests_with_setup.py
rombie/contrail-test
a68c71d6f282142501a7e2e889bbb232fdd82dc3
[ "Apache-2.0" ]
null
null
null
scripts/tests_with_setup.py
rombie/contrail-test
a68c71d6f282142501a7e2e889bbb232fdd82dc3
[ "Apache-2.0" ]
null
null
null
# Need to import path to test/fixtures and test/scripts/ # Ex : export PYTHONPATH='$PATH:/root/test/fixtures/:/root/test/scripts/' # # To run tests, you can do 'python -m testtools.run tests'. To run specific tests, # You can do 'python -m testtools.run -l tests' # Set the env variable PARAMS_FILE to point to your ini file. Else it will try to pick params.ini in PWD # from tests_with_setup_base import * class TestSanity(TestSanityBase): def setUp(self): super(TestSanity, self).setUp() # end setUp def cleanUp(self): super(TestSanity, self).cleanUp() # end cleanUp @preposttest_wrapper def test_diff_proj_same_vn_vm_add_delete(self): ''' Test to validate that a VN and VM with the same name and same subnet can be created in two different projects ''' vm_name = 'vm_mine' vn_name = 'vn222' vn_subnets = ['11.1.1.0/24'] projects = ['project111', 'project222'] user_list = [('gudi', 'gudi123', 'admin'), ('mal', 'mal123', 'admin')] auth_url = 'http://%s:5000/v2.0' % (self.inputs.openstack_ip) kc = ksclient.Client( username=self.inputs.stack_user, password=self.inputs.stack_password, tenant_name=self.inputs.project_name, auth_url=auth_url) user_pass = {} user_role = {} user_set = set() role_set = set() for (n, p, r) in user_list: user_pass[n] = p user_role[n] = r user_set.add(n) role_set.add(n) users = set([user.name for user in kc.users.list()]) roles = set([user.name for user in kc.roles.list()]) tenants = kc.tenants.list() admin_tenant = [x for x in tenants if x.name == 'admin'][0] create_user_set = user_set - users create_role_set = role_set - roles for new_tenant in projects: kc.tenants.create(new_tenant) role_dict = {} tenant_dict = {} for role in kc.roles.list(): role_dict[role.name] = role for tenant in kc.tenants.list(): tenant_dict[tenant.name] = tenant for name in create_user_set: user = kc.users.create( name, user_pass[name], '', tenant_id=admin_tenant.id) for new_tenant in projects: kc.roles.add_user_role( user, role_dict[user_role[name]], tenant_dict[new_tenant]) user_dict = {} for user in kc.users.list(): user_dict[user.name] = user self.new_proj_inputs1 = self.useFixture(ContrailTestInit(self.ini_file, stack_user=user_list[ 0][0], stack_password=user_list[0][1], project_fq_name=['default-domain', projects[0]])) self.new_proj_connections1 = ContrailConnections(self.new_proj_inputs1) self.new_proj_inputs2 = self.useFixture(ContrailTestInit(self.ini_file, stack_user=user_list[ 1][0], stack_password=user_list[1][1], project_fq_name=['default-domain', projects[1]])) self.new_proj_connections2 = ContrailConnections(self.new_proj_inputs2) vn1_fixture = self.useFixture( VNFixture( project_name=projects[ 0], connections=self.new_proj_connections1, vn_name=vn_name, inputs=self.new_proj_inputs1, subnets=vn_subnets)) assert vn1_fixture.verify_on_setup() vn1_obj = vn1_fixture.obj vn2_fixture = self.useFixture( VNFixture( project_name=projects[ 1], connections=self.new_proj_connections2, vn_name=vn_name, inputs=self.new_proj_inputs2, subnets=vn_subnets)) assert vn2_fixture.verify_on_setup() vn2_obj = vn2_fixture.obj vm1_fixture = self.useFixture( VMFixture(connections=self.new_proj_connections1, vn_obj=vn1_obj, vm_name=vm_name, project_name=projects[0])) vm2_fixture = self.useFixture( VMFixture(connections=self.new_proj_connections2, vn_obj=vn2_obj, vm_name=vm_name, project_name=projects[1])) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() if not vm1_fixture.agent_label == vm2_fixture.agent_label: self.logger.info("Correct label assigment") else: self.logger.error( "The same label has been assigned for both the VMs") return False testfail = 0 for new_tenant in projects: try: kc.tenants.delete(tenant_dict[new_tenant]) except Exception as e: self.logger.error( 'ClientException:This is because the project info still remains in the API server ==> Bug 744') for name in create_user_set: try: kc.users.delete(user_dict[name]) except Exception as e: self.logger.error( 'ClientException:This is because the project info still remains in the API server ==> Bug 744') assert testfail > 0, "Placeholder till the Bug 744 is fixed " return True # end test_diff_proj_same_vn_vm_add_delete # start subnet ping # verifying that ping to subnet broadcast is respended by other vms in same subnet # vm from other subnet should not respond @preposttest_wrapper def test_ping_on_broadcast_multicast(self): ''' Validate Ping on subnet broadcast,link local multucast,network broadcast . ''' result = True vn1_name = self.res.vn1_name vn1_subnets = self.res.vn1_subnets ping_count = '5' vn1_vm1_name = self.res.vn1_vm1_name vn1_vm2_name = self.res.vn1_vm2_name vn1_vm3_name = self.res.vn1_vm3_name vn1_vm4_name = self.res.vn1_vm4_name vn1_fixture = self.res.get_vn1_fixture() vm1_fixture = self.res.get_vn1_vm1_fixture() vm2_fixture = self.res.get_vn1_vm2_fixture() vm3_fixture = self.res.get_vn1_vm3_fixture() vm4_fixture = self.res.get_vn1_vm4_fixture() assert vm1_fixture.wait_till_vm_is_up() assert vm2_fixture.wait_till_vm_is_up() assert vm3_fixture.wait_till_vm_is_up() assert vm4_fixture.wait_till_vm_is_up() # Geting the VM ips vm1_ip = vm1_fixture.vm_ip vm2_ip = vm2_fixture.vm_ip vm3_ip = vm3_fixture.vm_ip vm4_ip = vm4_fixture.vm_ip ip_list = [vm1_ip, vm2_ip, vm3_ip, vm4_ip] bcast_ip = str(IPNetwork(vn1_subnets[0]).broadcast) list_of_ip_to_ping = [bcast_ip, '224.0.0.1', '255.255.255.255'] # passing command to vms so that they respond to subnet broadcast cmd = ['echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts'] vm_fixtures = [vm1_fixture, vm2_fixture, vm3_fixture, vm4_fixture] for vm in vm_fixtures: print 'Running cmd for %s' % vm.vm_name for i in range(3): try: self.logger.info("Retry %s" % (i)) ret = vm.run_cmd_on_vm(cmds=cmd, as_sudo=True) if not ret: for vn in vm.vn_fq_names: vm.ping_vm_from_host(vn) raise Exception except Exception as e: time.sleep(5) self.logger.exception("Got exception as %s" % (e)) else: break for dst_ip in list_of_ip_to_ping: self.logger.info('pinging from %s to %s' % (vm1_ip, dst_ip)) # pinging from Vm1 to subnet broadcast ping_output = vm1_fixture.ping_to_ip( dst_ip, return_output=True, count=ping_count, other_opt='-b') self.logger.info("ping output : \n %s" % (ping_output)) expected_result = ' 0% packet loss' if not expected_result in ping_output: self.logger.error('Expected 0% packet loss seen!') self.logger.error('Ping result : %s' % (ping_output)) result = result and True # getting count of ping response from each vm string_count_dict = {} string_count_dict = get_string_match_count(ip_list, ping_output) self.logger.info("output %s" % (string_count_dict)) self.logger.info( "There should be atleast 4 echo reply from each ip") for k in ip_list: # this is a workaround : ping utility exist as soon as it gets # one response # assert (string_count_dict[k] >= (int(ping_count) - 1)) if not string_count_dict[k] >= (int(ping_count) - 1): self.logger.error('Seen %s reply instead of atleast %s' % ( (int(ping_count) - 1))) result = result and False if not result: self.logger.error('There were errors. Verifying VM fixtures') assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() assert vm3_fixture.verify_on_setup() assert vm4_fixture.verify_on_setup() return True # end subnet ping @preposttest_wrapper def test_ping_within_vn_two_vms_two_different_subnets(self): ''' Validate Ping between two VMs within a VN-2 vms in 2 different subnets. Validate ping to subnet broadcast not responded back by other vm Validate ping to network broadcast (all 255) is responded back by other vm ''' vn1_name = 'vn030' vn1_subnets = ['31.1.1.0/30', '31.1.2.0/30'] # vn1_subnets=['30.1.1.0/24'] vn1_vm1_name = 'vm1' vn1_vm2_name = 'vm2' vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) assert vn1_fixture.verify_on_setup() vm1_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm1_name)) vm2_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm2_name)) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() assert vm1_fixture.ping_with_certainty(vm2_fixture.vm_ip) assert vm2_fixture.ping_with_certainty(vm1_fixture.vm_ip) # Geting the VM ips vm1_ip = vm1_fixture.vm_ip vm2_ip = vm2_fixture.vm_ip ip_list = [vm1_ip, vm2_ip] # gettig broadcast ip for vm1_ip ip_broadcast = '' ip_broadcast = get_subnet_broadcast_from_ip(vm1_ip, '30') list_of_ip_to_ping = [ip_broadcast, '224.0.0.1', '255.255.255.255'] # passing command to vms so that they respond to subnet broadcast cmd_list_to_pass_vm = [ 'echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts'] vm1_fixture.run_cmd_on_vm(cmds=cmd_list_to_pass_vm, as_sudo=True) vm2_fixture.run_cmd_on_vm(cmds=cmd_list_to_pass_vm, as_sudo=True) for dst_ip in list_of_ip_to_ping: print 'pinging from %s to %s' % (vm1_ip, dst_ip) # pinging from Vm1 to subnet broadcast ping_output = vm1_fixture.ping_to_ip( dst_ip, return_output=True, other_opt='-b') expected_result = ' 0% packet loss' assert (expected_result in ping_output) # getting count of ping response from each vm string_count_dict = {} string_count_dict = get_string_match_count(ip_list, ping_output) print string_count_dict if (dst_ip == ip_broadcast): assert (string_count_dict[vm2_ip] == 0) if (dst_ip == '224.0.0.1' or dst_ip == '255.255.255.255'): assert (string_count_dict[vm2_ip] > 0) return True # end test_ping_within_vn @preposttest_wrapper def test_policy_to_deny(self): ''' Test to validate that with policy having rule to disable icmp within the VN, ping between VMs should fail 1. Pick 2 VN from resource pool which have one VM in each 2. Create policy with icmp deny rule 3. Associate policy to both VN 4. Ping from one VM to another. Ping should fail Pass criteria: Step 2,3 and 4 should pass ''' vn1_name = self.res.vn1_name vn1_subnets = self.res.vn1_subnets policy_name = 'policy1' rules = [ { 'direction': '<>', 'simple_action': 'deny', 'protocol': 'icmp', 'source_network': vn1_name, 'dest_network': vn1_name, }, ] policy_fixture = self.useFixture( PolicyFixture( policy_name=policy_name, rules_list=rules, inputs=self.inputs, connections=self.connections)) vn1_fixture = self.res.get_vn1_fixture() vn1_fixture.bind_policies( [policy_fixture.policy_fq_name], vn1_fixture.vn_id) self.addCleanup(vn1_fixture.unbind_policies, vn1_fixture.vn_id, [policy_fixture.policy_fq_name]) assert vn1_fixture.verify_on_setup() vn1_vm1_name = self.res.vn1_vm1_name vn1_vm2_name = self.res.vn1_vm2_name vm1_fixture = self.res.get_vn1_vm1_fixture() vm2_fixture = self.res.get_vn1_vm2_fixture() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() if vm1_fixture.ping_to_ip(vm2_fixture.vm_ip): self.logger.error('Ping from %s to %s passed,expected it to fail' % ( vm1_fixture.vm_name, vm2_fixture.vm_name)) self.logger.info('Doing verifications on the fixtures now..') assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() return True # end test_policy_to_deny @preposttest_wrapper def test_process_restart_in_policy_between_vns(self): ''' Test to validate that with policy having rule to check icmp fwding between VMs on different VNs , ping between VMs should pass with process restarts 1. Pick 2 VN's from resource pool which has one VM each 2. Create policy with icmp allow rule between those VN's and bind it networks 3. Ping from one VM to another VM 4. Restart process 'vrouter' and 'control' on setup 5. Ping again between VM's after process restart Pass criteria: Step 2,3,4 and 5 should pass ''' vn1_name = self.res.vn1_name vn1_subnets = self.res.vn1_subnets vn2_name = self.res.vn2_name vn2_subnets = self.res.vn2_subnets policy1_name = 'policy1' policy2_name = 'policy2' rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'icmp', 'source_network': vn1_name, 'dest_network': vn2_name, }, ] rev_rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'icmp', 'source_network': vn2_name, 'dest_network': vn1_name, }, ] policy1_fixture = self.useFixture( PolicyFixture( policy_name=policy1_name, rules_list=rules, inputs=self.inputs, connections=self.connections)) policy2_fixture = self.useFixture( PolicyFixture( policy_name=policy2_name, rules_list=rev_rules, inputs=self.inputs, connections=self.connections)) vn1_fixture = self.res.get_vn1_fixture() assert vn1_fixture.verify_on_setup() vn1_fixture.bind_policies( [policy1_fixture.policy_fq_name], vn1_fixture.vn_id) self.addCleanup(vn1_fixture.unbind_policies, vn1_fixture.vn_id, [policy1_fixture.policy_fq_name]) vn2_fixture = self.res.get_vn2_fixture() assert vn2_fixture.verify_on_setup() vn2_fixture.bind_policies( [policy2_fixture.policy_fq_name], vn2_fixture.vn_id) self.addCleanup(vn2_fixture.unbind_policies, vn2_fixture.vn_id, [policy2_fixture.policy_fq_name]) vn1_vm1_name = self.res.vn1_vm1_name vn2_vm1_name = self.res.vn2_vm1_name vm1_fixture = self.res.get_vn1_vm1_fixture() vm2_fixture = self.res.get_vn2_vm1_fixture() assert vm1_fixture.wait_till_vm_is_up() assert vm2_fixture.wait_till_vm_is_up() assert vm1_fixture.ping_with_certainty(vm2_fixture.vm_ip) for compute_ip in self.inputs.compute_ips: self.inputs.restart_service('contrail-vrouter', [compute_ip]) for bgp_ip in self.inputs.bgp_ips: self.inputs.restart_service('contrail-control', [bgp_ip]) self.logger.info('Sleeping for 10 seconds') sleep(10) vn1_vm2_name = self.res.vn1_vm2_name vn2_vm2_name = self.res.vn2_vm2_name vm3_fixture = self.res.get_vn1_vm2_fixture() assert vm3_fixture.verify_on_setup() vm4_fixture = self.res.get_vn2_vm2_fixture() assert vm4_fixture.verify_on_setup() vm3_fixture.wait_till_vm_is_up() vm4_fixture.wait_till_vm_is_up() assert vm3_fixture.ping_with_certainty(vm4_fixture.vm_ip) return True # end test_process_restart_in_policy_between_vns @preposttest_wrapper def test_policy_between_vns(self): ''' Test to validate that with policy having rule to check icmp fwding between VMs on different VNs , ping between VMs should pass ''' vn1_name = self.res.vn1_name vn1_subnets = self.res.vn1_subnets vn2_name = self.res.vn2_name vn2_subnets = self.res.vn2_subnets policy1_name = 'policy1' policy2_name = 'policy2' rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'icmp', 'source_network': vn1_name, 'dest_network': vn2_name, }, ] rev_rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'icmp', 'source_network': vn2_name, 'dest_network': vn1_name, }, ] policy1_fixture = self.useFixture( PolicyFixture( policy_name=policy1_name, rules_list=rules, inputs=self.inputs, connections=self.connections)) policy2_fixture = self.useFixture( PolicyFixture( policy_name=policy2_name, rules_list=rev_rules, inputs=self.inputs, connections=self.connections)) vn1_fixture = self.res.get_vn1_fixture() vn1_fixture.bind_policies( [policy1_fixture.policy_fq_name], vn1_fixture.vn_id) self.addCleanup(vn1_fixture.unbind_policies, vn1_fixture.vn_id, [policy1_fixture.policy_fq_name]) assert vn1_fixture.verify_on_setup() vn2_fixture = self.res.get_vn2_fixture() vn2_fixture.bind_policies( [policy2_fixture.policy_fq_name], vn2_fixture.vn_id) self.addCleanup(vn2_fixture.unbind_policies, vn2_fixture.vn_id, [policy2_fixture.policy_fq_name]) assert vn2_fixture.verify_on_setup() vm1_fixture = self.res.get_vn1_vm1_fixture() assert vm1_fixture.verify_on_setup() vm2_fixture = self.res.get_vn2_vm1_fixture() assert vm2_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() assert vm1_fixture.ping_to_ip(vm2_fixture.vm_ip) return True # end test_policy_between_vns @preposttest_wrapper def test_tcp_transfer_from_fip_vm(self): ''' Validate data transfer through floating ip. ''' fip_pool_name = 'testpool' fvn_name = self.res.fip_vn_name fvm_name = self.res.fvn_vm1_name fvn_subnets = self.res.fip_vn_subnets vn1_name = self.res.vn1_name vm1_name = self.res.vn1_vm4_name vn1_subnets = self.res.vn1_subnets vn2_name = self.res.vn2_name vm2_name = self.res.vn2_vm1_name vn2_subnets = self.res.vn2_subnets # policy between frontend and backend policy_name = 'frontend-to-backend-policy' rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'any', 'source_network': vn1_name, 'dest_network': vn2_name, }, ] policy_fixture = self.useFixture( PolicyFixture(policy_name=policy_name, rules_list=rules, inputs=self.inputs, connections=self.connections)) # frontend VN vn1_fixture = self.res.get_vn1_fixture() vn1_fixture.bind_policies( [policy_fixture.policy_fq_name], vn1_fixture.vn_id) self.addCleanup(vn1_fixture.unbind_policies, vn1_fixture.vn_id, [policy_fixture.policy_fq_name]) vn1_fixture.verify_on_setup() # backend VN vn2_fixture = self.res.get_vn2_fixture() vn2_fixture.bind_policies( [policy_fixture.policy_fq_name], vn2_fixture.vn_id) self.addCleanup(vn2_fixture.unbind_policies, vn2_fixture.vn_id, [policy_fixture.policy_fq_name]) vn2_fixture.verify_on_setup() # public VN fvn_fixture = self.res.get_fvn_fixture() fvn_fixture.verify_on_setup() # frontend VM vm1_fixture = self.res.get_vn1_vm4_fixture() assert vm1_fixture.verify_on_setup() # backend VM vm2_fixture = self.res.get_vn2_vm1_fixture() assert vm2_fixture.verify_on_setup() # public VM fvm_fixture = self.res.get_fvn_vm1_fixture() assert fvm_fixture.verify_on_setup() fip_fixture = self.useFixture(FloatingIPFixture( project_name=self.inputs.project_name, inputs=self.inputs, connections=self.connections, pool_name=fip_pool_name, vn_id=fvn_fixture.vn_id)) assert fip_fixture.verify_on_setup() fip_id = fip_fixture.create_and_assoc_fip(fvn_fixture.vn_id, vm1_fixture.vm_id) fip = vm1_fixture.vnc_lib_h.floating_ip_read( id=fip_id).get_floating_ip_address() assert fvm_fixture.ping_to_ip(fip) result = fvm_fixture.tcp_data_transfer(vm1_fixture.local_ip, fip) fip_fixture.disassoc_and_delete_fip(fip_id) assert result return result # end test_tcp_transfer_from_fip_vm @preposttest_wrapper def test_multiple_vn_vm(self): """ Validate creation of multiple VN with multiple subnet and VMs in it. """ result = True # Multiple VN's with multiple subnets vn_s = {'vn-1': '20.1.1.0/24', 'vn-2': ['10.1.1.0/24', '10.1.2.0/24']} multi_vn_fixture = self.useFixture(MultipleVNFixture( connections=self.connections, inputs=self.inputs, subnet_count=2, vn_name_net=vn_s, project_name=self.inputs.project_name)) assert multi_vn_fixture.verify_on_setup() vn_objs = multi_vn_fixture.get_all_fixture_obj() multi_vm_fixture = self.useFixture(MultipleVMFixture( project_name=self.inputs.project_name, connections=self.connections, vm_count_per_vn=2, vn_objs=vn_objs)) assert multi_vm_fixture.verify_on_setup() return True # end test_multiple_vn_vm @preposttest_wrapper def test_process_restart_with_multiple_vn_vm(self): ''' Test to validate that multiple VM creation and deletion passes. ''' vm1_name = 'vm_mine' vn_name = 'vn222' vn_subnets = ['11.1.1.0/24'] vn_count_for_test = 32 if (len(self.inputs.compute_ips) == 1): vn_count_for_test = 10 vm_fixture = self.useFixture( create_multiple_vn_and_multiple_vm_fixture( connections=self.connections, vn_name=vn_name, vm_name=vm1_name, inputs=self.inputs, project_name=self.inputs.project_name, subnets=vn_subnets, vn_count=vn_count_for_test, vm_count=1, subnet_count=1)) compute_ip = [] for vmobj in vm_fixture.vm_obj_dict.values(): vm_host_ip = vmobj.vm_node_ip if vm_host_ip not in compute_ip: compute_ip.append(vm_host_ip) self.inputs.restart_service('contrail-vrouter', compute_ip) sleep(10) for vmobj in vm_fixture.vm_obj_dict.values(): assert vmobj.verify_on_setup() return True @preposttest_wrapper def test_control_node_switchover(self): ''' Stop the control node and check peering with agent fallback to other control node. 1. Pick one VN from respource pool which has 2 VM's in it 2. Verify ping between VM's 3. Find active control node in cluster by agent inspect 4. Stop control service on active control node 5. Verify agents are connected to new active control-node using xmpp connections 6. Bring back control service on previous active node 7. Verify ping between VM's again after bringing up control serveice Pass criteria: Step 2,5 and 7 should pass ''' if len(set(self.inputs.bgp_ips)) < 2: self.logger.info( "Skiping Test. At least 2 control node required to run the test") raise self.skipTest( "Skiping Test. At least 2 control node required to run the test") result = True vn1_name = self.res.vn1_name vn1_subnets = self.res.vn1_subnets vn1_vm1_name = self.res.vn1_vm1_name vn1_vm2_name = self.res.vn1_vm2_name vn1_fixture = self.res.get_vn1_fixture() assert vn1_fixture.verify_on_setup() vm1_fixture = self.res.get_vn1_vm1_fixture() assert vm1_fixture.verify_on_setup() vm2_fixture = self.res.get_vn1_vm2_fixture() assert vm2_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() assert vm1_fixture.ping_to_ip(vm2_fixture.vm_ip) assert vm2_fixture.ping_to_ip(vm1_fixture.vm_ip) # Figuring the active control node active_controller = None self.agent_inspect = self.connections.agent_inspect inspect_h = self.agent_inspect[vm1_fixture.vm_node_ip] agent_xmpp_status = inspect_h.get_vna_xmpp_connection_status() for entry in agent_xmpp_status: if entry['cfg_controller'] == 'Yes': active_controller = entry['controller_ip'] active_controller_host_ip = self.inputs.host_data[ active_controller]['host_ip'] self.logger.info('Active control node from the Agent %s is %s' % (vm1_fixture.vm_node_ip, active_controller_host_ip)) # Stop on Active node self.logger.info('Stoping the Control service in %s' % (active_controller_host_ip)) self.inputs.stop_service( 'contrail-control', [active_controller_host_ip]) sleep(5) # Check the control node shifted to other control node new_active_controller = None new_active_controller_state = None inspect_h = self.agent_inspect[vm1_fixture.vm_node_ip] agent_xmpp_status = inspect_h.get_vna_xmpp_connection_status() for entry in agent_xmpp_status: if entry['cfg_controller'] == 'Yes': new_active_controller = entry['controller_ip'] new_active_controller_state = entry['state'] new_active_controller_host_ip = self.inputs.host_data[ new_active_controller]['host_ip'] self.logger.info('Active control node from the Agent %s is %s' % (vm1_fixture.vm_node_ip, new_active_controller_host_ip)) if new_active_controller_host_ip == active_controller_host_ip: self.logger.error( 'Control node switchover fail. Old Active controlnode was %s and new active control node is %s' % (active_controller_host_ip, new_active_controller_host_ip)) result = False if new_active_controller_state != 'Established': self.logger.error( 'Agent does not have Established XMPP connection with Active control node') result = result and False # Start the control node service again self.logger.info('Starting the Control service in %s' % (active_controller_host_ip)) self.inputs.start_service( 'contrail-control', [active_controller_host_ip]) # Check the BGP peering status from the currently active control node sleep(5) cn_bgp_entry = self.cn_inspect[ new_active_controller_host_ip].get_cn_bgp_neigh_entry() for entry in cn_bgp_entry: if entry['state'] != 'Established': result = result and False self.logger.error( 'With Peer %s peering is not Established. Current State %s ' % (entry['peer'], entry['state'])) # Check the ping self.logger.info('Checking the ping between the VM again') assert vm1_fixture.ping_to_ip(vm2_fixture.vm_ip) assert vm2_fixture.ping_to_ip(vm1_fixture.vm_ip) if not result: self.logger.error('Switchover of control node failed') assert result return True # end test_control_node_switchover @preposttest_wrapper def test_agent_cleanup_with_control_node_stop(self): ''' Stop all the control node and verify the cleanup process in agent ''' if len(set(self.inputs.bgp_ips)) < 2: raise self.skipTest( "Skiping Test. At least 2 control node required to run the test") result = True vn1_name = self.res.vn1_name vn1_subnets = self.res.vn1_subnets vn1_vm1_name = self.res.vn1_vm1_name vn1_vm2_name = self.res.vn1_vm2_name vn1_fixture = self.res.get_vn1_fixture() assert vn1_fixture.verify_on_setup() vm1_fixture = self.res.get_vn1_vm1_fixture() assert vm1_fixture.verify_on_setup() vm2_fixture = self.res.get_vn1_vm2_fixture() assert vm2_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() assert vm2_fixture.ping_to_ip(vm1_fixture.vm_ip) # Collecting all the control node details controller_list = [] self.agent_inspect = self.connections.agent_inspect inspect_h = self.agent_inspect[vm1_fixture.vm_node_ip] agent_xmpp_status = inspect_h.get_vna_xmpp_connection_status() for entry in agent_xmpp_status: controller_list.append(entry['controller_ip']) list_of_vm = inspect_h.get_vna_vm_list() # Stop all the control node for entry in controller_list: self.logger.info('Stoping the Control service in %s' % (entry)) self.inputs.stop_service('contrail-control', [entry]) sleep(5) # It seems that cleanup happens after 2 mins sleep(120) # Verify VM entry is removed from the agent introspect vm_id_list = inspect_h.get_vna_vm_list() if vm1_fixture.vm_id in vm_id_list: result = result and False self.logger.error( 'VM %s is still present in Agent Introspect.Cleanup not working when all control node shut' % (vm1_fixture.vm_name)) if vm2_fixture.vm_id in vm_id_list: result = result and False self.logger.error( 'VM %s is still present in Agent Introspect.Cleanup not working when all control node shut' % (vm2_fixture.vm_name)) # TODO Verify the IF-Map entry # Start all the control node for entry in controller_list: self.logger.info('Starting the Control service in %s' % (entry)) self.inputs.start_service('contrail-control', [entry]) sleep(10) self.logger.info('Checking the VM came up properly or not') assert vm2_fixture.verify_on_setup() assert vm1_fixture.verify_on_setup() # Check everything came up fine vm_id_list = inspect_h.get_vna_vm_list() if vm1_fixture.vm_id not in vm_id_list or vm2_fixture.vm_id not in vm_id_list: result = result and False self.logger.error( 'After starting the service all the VM entry did not came up properly') if not result: self.logger.error( 'Test to verify cleanup of agent after control nodes stop Failed') assert result return True # end test_agent_cleanup_with_control_node_stop @preposttest_wrapper def test_bring_up_vm_with_control_node_down(self): ''' Create VM when there is not active control node. Verify VM comes up fine when all control nodes are back ''' self.agent_inspect = self.connections.agent_inspect if len(set(self.inputs.bgp_ips)) < 2: raise self.skipTest( "Skiping Test. At least 2 control node required to run the test") result = True vn1_name = self.res.vn1_name vn1_subnets = self.res.vn1_subnets # Collecting all the control node details controller_list = [] for entry in self.inputs.compute_ips: inspect_h = self.agent_inspect[entry] agent_xmpp_status = inspect_h.get_vna_xmpp_connection_status() for entry in agent_xmpp_status: controller_list.append(entry['controller_ip']) controller_list = set(controller_list) # Stop all the control node for entry in controller_list: self.logger.info('Stoping the Control service in %s' % (entry)) self.inputs.stop_service('contrail-control', [entry]) sleep(10) vn1_vm1_name = self.res.vn1_vm1_name vn1_vm2_name = self.res.vn1_vm2_name vn1_fixture = self.res.get_vn1_fixture() vm1_fixture = self.res.get_vn1_vm1_fixture() vm2_fixture = self.res.get_vn1_vm2_fixture() # Check all the VM got IP when control node is down # Verify VM in Agent. This is more required to get TAP iterface and Metadata IP. # TODO Need to check the verify_vm_in_agent chance to get passed when # Control node is down with new implmenetation vm1_fixture.verify_vm_in_agent() vm2_fixture.verify_vm_in_agent() vm_ip1 = vm1_fixture.get_vm_ip_from_vm() vm_ip2 = vm2_fixture.get_vm_ip_from_vm() if vm_ip1 is None or vm_ip2 is None: result = result and False self.logger.error( 'VM does not get an IP when all control nodes are down') else: self.logger.info( 'Both VM got required IP when control nodes are down') # Start all the control node for entry in controller_list: self.logger.info('Starting the Control service in %s' % (entry)) self.inputs.start_service('contrail-control', [entry]) sleep(10) self.logger.info('Checking the VM came up properly or not') assert vn1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() assert vm1_fixture.verify_on_setup() # Check ping between VM assert vm2_fixture.ping_to_ip(vm1_fixture.vm_ip) if not result: self.logger.error( 'Test to verify cleanup of agent after control nodes stop Failed') assert result return True # end test_bring_up_vm_with_control_node_down # @preposttest_wrapper # def test_vn_add_delete_no_subnet(self): # '''Test to validate VN creation even when no subnet is provided. Commented till 811 is fixed. # ''' # vn_obj=self.useFixture( VNFixture(project_name= self.inputs.project_name, connections= self.connections, # vn_name='vn007', inputs= self.inputs )) # assert vn_obj.verify_on_setup() # assert vn_obj # return True # end test_vn_add_delete_no_subnet # @preposttest_wrapper # def test_vn_reboot_nodes(self): # ''' Test to validate persistence of VN across compute/control/cfgm node reboots Commented till 129 is fixed. # ''' # vn_obj=self.useFixture( VNFixture(project_name= self.inputs.project_name, connections= self.connections, # vn_name='vn111', inputs= self.inputs, subnets=['100.100.100.0/24'])) # assert vn_obj.verify_on_setup() # reboot the compute node now and verify the VN persistence # for compute_ip in self.inputs.compute_ips: # self.inputs.reboot(compute_ip) # sleep(120) # assert vn_obj.verify_on_setup() # reboot the control nodes now and verify the VN persistence # for bgp_ip in self.inputs.bgp_ips: # self.inputs.reboot(bgp_ip) # sleep(120) # assert vn_obj.verify_on_setup() # reboot the cfgm node now and verify the VN persistence # self.inputs.reboot(self.inputs.cfgm_ip) # sleep(120) # assert vn_obj.verify_on_setup() # assert vn_obj # return True # end test_vn_reboot_nodes # @preposttest_wrapper # def vn_subnet_tests(self): # """ Validate various type of subnets associated to VNs.Commented till 762, 801, 802, 803 and 805 are fixed. # """ # # result = True # vn_s = {'vn-1' : '0.0.0.0/0', 'vn-2' : ['10.1.1.0/24', '10.1.1.0/24'], 'vn-3' : '169.254.1.1/24', 'vn-4' : '251.2.2.1/24', 'vn-5' : '127.0.0.1/32', 'vn-6' : '8.8.8.8/32', 'vn-7' : '9.9.9.9/31','vn-8' : ['11.11.11.0/30', '11.11.11.11/29']} # multi_vn_fixture = self.useFixture(MultipleVNFixture( # connections=self.connections, inputs=self.inputs, subnet_count=2, # vn_name_net=vn_s, project_name=self.inputs.project_name)) # # vn_objs = multi_vn_fixture.get_all_fixture_obj() # assert not multi_vn_fixture.verify_on_setup() # # return True # end test_subnets_vn @preposttest_wrapper def test_uve(self): '''Test to validate collector uve. ''' analytics_obj = AnalyticsVerification( inputs=self.inputs, connections=self.connections) assert analytics_obj.verify_collector_uve() return True # end test_uve @preposttest_wrapper def test_multiple_floating_ip_for_single_vm(self): '''Test to validate floating-ip Assignment to a VM. It creates a VM, assigns a FIP to it and pings to a IP in the FIP VN. ''' result = True fip_pool_name = 'some-other-pool1' fvn_name = self.res.fvn_name fvm_name = self.res.fvn_vm1_name fvn_subnets = self.res.fip_vn_subnets fip_pool_name1 = 'some-pool2' fvn_name1 = 'fvnn200' fvm_name1 = 'vm200' fvn_subnets1 = ['150.1.1.0/24'] vm1_name = self.res.vn1_vm1_name vn1_name = self.res.vn1_name vn1_subnets = self.res.vn1_subnets # VN Fixture fvn_fixture = self.res.get_fvn_fixture() assert fvn_fixture.verify_on_setup() fvn_fixture1 = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=fvn_name1, inputs=self.inputs, subnets=fvn_subnets1)) assert fvn_fixture1.verify_on_setup() vn1_fixture = self.res.get_vn1_fixture() assert vn1_fixture.verify_on_setup() # VM Fixture vm1_fixture = self.res.get_vn1_vm1_fixture() assert vm1_fixture.verify_on_setup() fvm_fixture = self.res.get_fvn_vm1_fixture() assert fvm_fixture.verify_on_setup() fvm_fixture1 = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=fvn_fixture1.obj, vm_name=fvm_name1)) assert fvm_fixture1.verify_on_setup() # Floating Ip Fixture fip_fixture = self.useFixture( FloatingIPFixture( project_name=self.inputs.project_name, inputs=self.inputs, connections=self.connections, pool_name=fip_pool_name, vn_id=fvn_fixture.vn_id)) assert fip_fixture.verify_on_setup() fip_fixture1 = self.useFixture( FloatingIPFixture( project_name=self.inputs.project_name, inputs=self.inputs, connections=self.connections, pool_name=fip_pool_name1, vn_id=fvn_fixture1.vn_id)) assert fip_fixture1.verify_on_setup() fip_id = fip_fixture.create_and_assoc_fip( fvn_fixture.vn_id, vm1_fixture.vm_id) assert fip_fixture.verify_fip(fip_id, vm1_fixture, fvn_fixture) fip_id1 = fip_fixture.create_and_assoc_fip( fvn_fixture1.vn_id, vm1_fixture.vm_id) assert fip_fixture1.verify_fip(fip_id1, vm1_fixture, fvn_fixture1) # Check the communication from borrower VM to all 2 networks if not vm1_fixture.ping_with_certainty(fvm_fixture.vm_ip): result = result and False if not vm1_fixture.ping_with_certainty(fvm_fixture1.vm_ip): result = result and False # Check the floating IP provider VNs should commmunicate with each # other self.logger.info( 'Ping should fail here. %s and %s should not able to communicate with each oether' % (fvm_name1, fvm_name)) if fvm_fixture1.ping_to_ip(fvm_fixture.vm_ip): result = result and False # Check after disscocition of floating ip communication should and only # should stop from that network fip_fixture.disassoc_and_delete_fip(fip_id) self.logger.info( 'Ping should fail here as floating IP pool is already released') if vm1_fixture.ping_to_ip(fvm_fixture.vm_ip): result = result and False if not vm1_fixture.ping_with_certainty(fvm_fixture1.vm_ip): result = result and False fip_fixture1.disassoc_and_delete_fip(fip_id1) if not result: self.logger.error( 'Test to check multiple floating ip for single VM has failed') assert result return True # end test_floating_ip @preposttest_wrapper def test_ipam_add_delete(self): '''Test to validate IPAM creation, association of a VN and creating VMs in the VN. Ping b/w the VMs should be successful. 1. Create non-default IPAM 2. Create VN with user-created IPAM and verify 3. Launch 2 VM's within VN which is using non-default IPAM 4. Ping between these 2 VM's Pass criteria: Step 1,2,3 and 4 should pass ''' project_obj = self.useFixture( ProjectFixture(vnc_lib_h=self.vnc_lib, connections=self.connections)) ipam_obj = self.useFixture( IPAMFixture(project_obj=project_obj, name='my-ipam')) assert ipam_obj vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name='vn22', inputs=self.inputs, subnets=['22.1.1.0/24'], ipam_fq_name=ipam_obj.fq_name)) assert vn_fixture.verify_on_setup() vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_fixture.obj, vm_name='vm1')) vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_fixture.obj, vm_name='vm2')) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() assert vm1_fixture.ping_with_certainty(vm2_fixture.vm_ip) return True # end test_ipam_add_delete @preposttest_wrapper def test_remove_policy_with_ref(self): ''' This tests the following scenarios. 1. Test to validate that policy removal will fail when it referenced with VN. 2. validate vn_policy data in api-s against quantum-vn data, when created and unbind policy from VN thru quantum APIs. 3. validate policy data in api-s against quantum-policy data, when created and deleted thru quantum APIs. ''' # vn1_name='vn4' # vn1_subnets=['10.1.1.0/24'] vn1_name = self.res.vn1_name vn1_subnets = self.res.vn1_subnets policy_name = 'policy1' rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'icmp', 'source_network': vn1_name, 'dest_network': vn1_name, }, ] project_obj = self.useFixture( ProjectFixture(vnc_lib_h=self.vnc_lib, connections=self.connections)) policy_fixture = self.useFixture( PolicyFixture( policy_name=policy_name, rules_list=rules, inputs=self.inputs, connections=self.connections)) vn1_fixture = self.res.get_vn1_fixture() #policy_fq_names = [self.quantum_fixture.get_policy_fq_name(policy_fixture.policy_obj)] #vn1_fixture.bind_policies( policy_fq_names,vn1_fixture.vn_id) vn1_fixture.bind_policies( [policy_fixture.policy_fq_name], vn1_fixture.vn_id) assert vn1_fixture.verify_on_setup() # try to remove policy which was referenced with VN. policy_removal = True pol_list = self.quantum_fixture.list_policys() pol_id = None for policy in pol_list['policys']: if policy['name'] == policy_name: pol_id = policy['id'] policy_removal = self.quantum_fixture.delete_policy( policy['id']) # In failure screnario clearing the Policy from the VN for # further test case if policy_removal: vn1_fixture.unbind_policies( vn1_fixture.vn_id, [policy_fixture.policy_fq_name]) break self.assertFalse( policy_removal, 'Policy removal succeed as not expected since policy is referenced with VN') assert vn1_fixture.verify_on_setup() policy_fixture.verify_policy_in_api_server() if vn1_fixture.policy_objs: policy_fq_names = [ self.quantum_fixture.get_policy_fq_name(x) for x in vn1_fixture.policy_objs] # unbind the policy from VN vn1_fixture.unbind_policies( vn1_fixture.vn_id, [policy_fixture.policy_fq_name]) # Verify policy ref is removed from VN vn_pol_found = vn1_fixture.verify_vn_policy_not_in_api_server( policy_name) self.assertFalse( vn_pol_found, 'policy not removed from VN after policy unbind from VN') # remove the policy using quantum API policy_removal = self.quantum_fixture.delete_policy(pol_id) # TODO This code is not working because of bug#1056. Need to test once bug is Fixed. #pol_found = policy_fixture.verify_policy_not_in_api_server() #self.assertFalse(pol_found,'policy not removed from API server when policy removed from Quantum') return True @preposttest_wrapper def test_verify_generator_collector_connections(self): ''' Description: Verify generator:module connections to collector 1.Verify all generators connected to collector - fails otherwise 2.Get the xmpp peers in vrouter uve and get the active xmpp peer out of it 3.Verify from agent introspect that active xmpp matches with step 2 - fails otherwise 4.Get bgp peers from bgp-peer uve and verify from control node introspect that that matches - fails otherwise Maintainer: [email protected] ''' self.logger.info("START ...") # check collector-generator connections through uves. assert self.analytics_obj.verify_collector_uve() # Verify vrouter uve active xmpp connections assert self.analytics_obj.verify_active_xmpp_peer_in_vrouter_uve() # Verify vrouter uve for xmpp connections assert self.analytics_obj.verify_vrouter_xmpp_connections() # count of xmpp peer and bgp peer verification in bgp-router uve assert self.analytics_obj.verify_bgp_router_uve_xmpp_and_bgp_count() self.logger.info("END...") return True # end test_remove_policy_with_ref # end TestSanityFixture
43.623684
247
0.632603
49,296
0.991253
0
0
45,879
0.922543
0
0
14,347
0.288492
dfff599aef2fa931d79fa84797d0acce9a216f5a
5,407
py
Python
murder.py
lgrn/murder
1e4582cc5fa8c31c35e70997daebd111f1badf4d
[ "Unlicense" ]
null
null
null
murder.py
lgrn/murder
1e4582cc5fa8c31c35e70997daebd111f1badf4d
[ "Unlicense" ]
null
null
null
murder.py
lgrn/murder
1e4582cc5fa8c31c35e70997daebd111f1badf4d
[ "Unlicense" ]
null
null
null
#!/usr/bin/env python3 # murder 0.2.3 import sys if sys.version_info[0] != (3): sys.stdout.write("Sorry this software requires Python 3. This is Python {}.\n".format(sys.version_info[0])) sys.exit(1) import time import requests import json import re # Your "filename" file should contain one word per row. Don't worry about # newlines and whitespace, it will be stripped. Any names containing anything # but A-Z/a-z, underscores and numbers will be skipped and not queried. filename = "input.txt" try: with open(filename) as f: lines = [line.strip().strip('\n').lower() for line in open(filename)] lines = list(set(lines)) except FileNotFoundError: print("For this script to work, {} needs to exist in the working directory. Exiting.".format(filename)) raise SystemExit except UnicodeDecodeError: print("Oops! {} isn't UTF-8. Convert it, for example by running iconv. Exiting.".format(filename)) raise SystemExit unavailable_filename = "unavailable.txt" try: with open(unavailable_filename) as f: unavailable_lines = [line.strip().strip('\n') for line in open(unavailable_filename)] except FileNotFoundError: print("\n{} was not found. That's fine, probably there wasn't a previous run.".format(unavailable_filename)) available_filename = "output.txt" try: with open(available_filename) as f: available_lines = [line.strip().strip('\n') for line in open(available_filename)] except FileNotFoundError: print("\n{} was not found. That's fine, probably there wasn't a previous run.".format(available_filename)) pretty_amount = "{:,}".format(len(lines)) print("\n[>>>>>>>>>] Imported {} words from {}.".format(pretty_amount,filename)) # This regex pattern validates usernames. pattern = re.compile("^[a-zA-Z0-9]+([._]?[a-zA-Z0-9]+)*$") sys.stdout.flush() # This function will check if a name is available: def is_available(username): url = ("https://twitter.com/users/username_available" "?scribeContext%5Bcomponent%5D=form&scribeContext%5B" "element%5D=screen_name&username=" + str(username.lower()) + "&value=" + str(username.lower())) response = requests.get(url) try: data = json.loads(response.text) reason = data.get("reason") except UnboundLocalError: print('[ JSON! ] Twitter refused to give us a decent response for this request: ') print(url) print('[ JSON! ] Assuming its unavailable and attempting to move on.') reason = "unavailable" pass except ValueError: print('[ JSON! ] UH-OH! You\'re probably being rate limited :( ) ') print('[ JSON! ] You should stop for now and/or adjust your sleep_timer ) ') print('[ JSON! ] ValueError for this request: ') print(url) raise SystemExit if reason == "available": return True else: return False def write_available(i): f = open("output.txt", "a") f.write(i) f.close() def write_unavailable(i): f = open("unavailable.txt", "a") f.write(i) f.close() failed_tries = 0 ok_tries = 0 # Let's clean up our "lines" array first so it only contains stuff we # actually want to throw at the API. clean_lines = [] for i in lines: if pattern.match(i) and len(str(i)) == 5: clean_lines.append(i) # NOTE: "Compliant" below is decided by the for loop above. pretty_amount = "{:,}".format(len(clean_lines)) print("[>>>>>>>>>] Cleaned up import to only include compliant words. We now have {} words.".format(pretty_amount) + "\n") # Clean the array further by removing already checked names (failed and succeeded). try: for i in unavailable_lines: if i in clean_lines: clean_lines.remove(i) print("[ CLEANUP ] '{}' will not be checked, we already know it's taken.".format(i.lower())) except NameError: # If there wasn't a previous run, this won't exist. That's fine. pass try: for i in available_lines: if i in clean_lines: clean_lines.remove(i) print("[ CLEANUP ] '{}' will not be checked, we already know it's available.".format(i.lower())) except NameError: # If there wasn't a previous run, this won't exist. That's fine. pass try: if unavailable_lines or available_lines: pretty_amount = "{:,}".format(len(clean_lines)) print("[>>>>>>>>>] Done cross-checking txt files from previous runs, we now have {} words.".format(pretty_amount) + "\n") except NameError: pass # NOTE: time.sleep waits because twitter has a rate limit of 150/15min (?) <- bad guess print("[>>>>>>>>>] Making API calls now." + "\n") sleep_seconds = 10 for i in clean_lines: sys.stdout.flush() if is_available(i): print("[AVAILABLE] '{}'! Saving to output.txt, stalling for next API call.".format(i.lower())) ok_tries += 1 write_available(i.lower() + '\n') sys.stdout.flush() time.sleep(sleep_seconds) else: print("[ TAKEN ] '{}'. Too bad. Stalling for next API call.".format(i.lower())) failed_tries += 1 #delete_row(i) write_unavailable(i.lower() + '\n') time.sleep(sleep_seconds) total_tries = failed_tries + ok_tries print("Script finished. Twitter was hit with " "{} queries. We found {} available names, saved to output.txt".format(total_tries,ok_tries))
32.769697
129
0.653227
0
0
0
0
0
0
0
0
2,448
0.452746
dfff777451f2b530e80b5323a7284116b77ea627
703
py
Python
cfn_review_bot/merge.py
biochimia/cfn-review-bot
1c8a84b51f7c398c21725cb888a9ab694ddfbb56
[ "Apache-2.0" ]
1
2019-04-04T12:09:16.000Z
2019-04-04T12:09:16.000Z
cfn_review_bot/merge.py
biochimia/cfn-review-bot
1c8a84b51f7c398c21725cb888a9ab694ddfbb56
[ "Apache-2.0" ]
null
null
null
cfn_review_bot/merge.py
biochimia/cfn-review-bot
1c8a84b51f7c398c21725cb888a9ab694ddfbb56
[ "Apache-2.0" ]
null
null
null
def _deep_merge_mapping(old, new): merged = {} merged.update(old) for k, nv in new.items(): try: ov = merged[k] except KeyError: merged[k] = nv continue merged[k] = deep_merge(ov, nv) return merged def _deep_merge_sequence(old, new): return old + new def deep_merge(old, new): if (isinstance(old, dict) and isinstance(new, dict)): return _deep_merge_mapping(old, new) if (isinstance(old, list) and isinstance(new, list)): return _deep_merge_sequence(old, new) if old == new: return old raise Exception('Unable to merge {} with {}'.format(old, new))
20.676471
66
0.571835
0
0
0
0
0
0
0
0
28
0.039829
5f0133420725ce23664fd5aac6eace5b4be90d9b
324
py
Python
02_module/package_test/module1/my_sum.py
zzz0072/Python_Exercises
9918aa8197a77ef237e5e60306c7785eca5cb1d3
[ "BSD-2-Clause" ]
null
null
null
02_module/package_test/module1/my_sum.py
zzz0072/Python_Exercises
9918aa8197a77ef237e5e60306c7785eca5cb1d3
[ "BSD-2-Clause" ]
null
null
null
02_module/package_test/module1/my_sum.py
zzz0072/Python_Exercises
9918aa8197a77ef237e5e60306c7785eca5cb1d3
[ "BSD-2-Clause" ]
null
null
null
#/usr/bin/env python from ..module2 import my_print def my_sum(x, y): result = x + y my_print.my_print(result) # To run method alone if __name__ == "__main__": import sys if len(sys.argv) != 3: print("%s str1 str2" % sys.argv[0]) raise SystemExit(1) my_sum(sys.argv[1], sys.argv[2])
18
43
0.608025
0
0
0
0
0
0
0
0
65
0.200617
5f018a5353d8adb9d68568f7a0b49dde04ed193e
75
py
Python
storch/models/__init__.py
STomoya/storch
47754eecd5fb5404dd345f06fb0f8d3270a9e5b9
[ "MIT" ]
null
null
null
storch/models/__init__.py
STomoya/storch
47754eecd5fb5404dd345f06fb0f8d3270a9e5b9
[ "MIT" ]
null
null
null
storch/models/__init__.py
STomoya/storch
47754eecd5fb5404dd345f06fb0f8d3270a9e5b9
[ "MIT" ]
null
null
null
from multiscale import MultiScale from patchgan import PatchDiscriminator
18.75
39
0.88
0
0
0
0
0
0
0
0
0
0
5f033434eab634732c27a8827763d152ae9391a1
1,054
py
Python
repos/system_upgrade/el7toel8/actors/preparepythonworkround/tests/test_preparepythonworkaround.py
AloisMahdal/leapp-repository
9ac2b8005750e8e56e5fde61e8762044d0f16257
[ "Apache-2.0" ]
null
null
null
repos/system_upgrade/el7toel8/actors/preparepythonworkround/tests/test_preparepythonworkaround.py
AloisMahdal/leapp-repository
9ac2b8005750e8e56e5fde61e8762044d0f16257
[ "Apache-2.0" ]
9
2020-01-07T12:48:59.000Z
2020-01-16T10:44:34.000Z
repos/system_upgrade/el7toel8/actors/preparepythonworkround/tests/test_preparepythonworkaround.py
AloisMahdal/leapp-repository
9ac2b8005750e8e56e5fde61e8762044d0f16257
[ "Apache-2.0" ]
null
null
null
from os import symlink, path, access, X_OK import pytest from leapp.libraries.actor import workaround from leapp.libraries.common.utils import makedirs def fake_symlink(basedir): def impl(source, target): source_path = str(basedir.join(*source.lstrip('/').split('/'))) makedirs(source_path) symlink(source_path, target) return impl def test_apply_python3_workaround(monkeypatch, tmpdir): leapp_home = tmpdir.mkdir('tmp_leapp_py3') monkeypatch.setattr(workaround.os, 'symlink', fake_symlink(tmpdir.mkdir('lib'))) monkeypatch.setattr(workaround, 'LEAPP_HOME', str(leapp_home)) # Ensure double invocation doesn't cause a problem workaround.apply_python3_workaround() workaround.apply_python3_workaround() # Ensure creation of all required elements assert path.islink(str(leapp_home.join('leapp'))) assert path.isfile(str(leapp_home.join('leapp3'))) assert access(str(leapp_home.join('leapp3')), X_OK) assert str(leapp_home) in leapp_home.join('leapp3').read_text('utf-8')
32.9375
84
0.734345
0
0
0
0
0
0
0
0
177
0.167932
5f03df5d79ef568c79e0a3f2f05ab7cc845b03d5
707
py
Python
codility/equi_leader.py
py-in-the-sky/challenges
4a36095de8cb56b4f9f83c241eafb13dfbeb4065
[ "MIT" ]
null
null
null
codility/equi_leader.py
py-in-the-sky/challenges
4a36095de8cb56b4f9f83c241eafb13dfbeb4065
[ "MIT" ]
null
null
null
codility/equi_leader.py
py-in-the-sky/challenges
4a36095de8cb56b4f9f83c241eafb13dfbeb4065
[ "MIT" ]
null
null
null
""" https://codility.com/programmers/task/equi_leader/ """ from collections import Counter, defaultdict def solution(A): def _is_equi_leader(i): prefix_count_top = running_counts[top] suffix_count_top = total_counts[top] - prefix_count_top return (prefix_count_top * 2 > i + 1) and (suffix_count_top * 2 > len(A) - i - 1) total_counts = Counter(A) running_counts = defaultdict(int) top = A[0] result = 0 for i in xrange(len(A) - 1): n = A[i] running_counts[n] += 1 top = top if running_counts[top] >= running_counts[n] else n if _is_equi_leader(i): result += 1 return result
24.37931
89
0.595474
0
0
0
0
0
0
0
0
58
0.082037
5f049724d72ac2de8c5b11138f1e4b59bdb512ad
1,744
py
Python
src/harness/cu_pass/dpa_calculator/helpers/list_distributor/list_distributor.py
NSF-Swift/Spectrum-Access-System
02cf3490c9fd0cec38074d3bdb3bca63bb7d03bf
[ "Apache-2.0" ]
null
null
null
src/harness/cu_pass/dpa_calculator/helpers/list_distributor/list_distributor.py
NSF-Swift/Spectrum-Access-System
02cf3490c9fd0cec38074d3bdb3bca63bb7d03bf
[ "Apache-2.0" ]
null
null
null
src/harness/cu_pass/dpa_calculator/helpers/list_distributor/list_distributor.py
NSF-Swift/Spectrum-Access-System
02cf3490c9fd0cec38074d3bdb3bca63bb7d03bf
[ "Apache-2.0" ]
null
null
null
from abc import ABC, abstractmethod from typing import Any, List, TypeVar from cu_pass.dpa_calculator.helpers.list_distributor.fractional_distribution.fractional_distribution import \ FractionalDistribution RETURN_TYPE = TypeVar('RETURN_TYPE') class ListDistributor(ABC): def __init__(self, items_to_distribute: List[Any]): self._items = items_to_distribute def distribute(self) -> List[List[RETURN_TYPE]]: return [self._modify_group(distribution=distribution, group=group) for distribution, group in zip(self._distributions, self._groups)] @abstractmethod def _modify_group(self, distribution: FractionalDistribution, group: List[Any]) -> List[RETURN_TYPE]: return group @property def _groups(self) -> List[List[Any]]: groups = [] for distribution in self._distributions: next_index = sum(len(group) for group in groups) remaining_items = self._items[next_index:] items_in_group = self._get_items_in_distribution(distribution=distribution, items=remaining_items) groups.append(items_in_group) return groups @property @abstractmethod def _distributions(self) -> List[FractionalDistribution]: raise NotImplementedError def _get_items_in_distribution(self, distribution: FractionalDistribution, items: List[Any]) -> List[Any]: number_at_this_distribution = round(self._total_number_of_items * distribution.fraction) is_last_distribution = distribution == self._distributions[-1] return items if is_last_distribution else items[:number_at_this_distribution] @property def _total_number_of_items(self) -> int: return len(self._items)
38.755556
110
0.725344
1,491
0.854931
0
0
764
0.438073
0
0
13
0.007454
5f05166068ffa658a5a11fcc559025940e70a85b
1,419
py
Python
downloader.py
Luonic/tf-cnn-lstm-ocr-captcha
9ac6202d546093d95083a32c71cdccb800dfdea2
[ "MIT" ]
10
2017-08-08T22:57:32.000Z
2020-04-07T21:50:20.000Z
downloader.py
Luonic/tf-cnn-lstm-ocr-captcha
9ac6202d546093d95083a32c71cdccb800dfdea2
[ "MIT" ]
null
null
null
downloader.py
Luonic/tf-cnn-lstm-ocr-captcha
9ac6202d546093d95083a32c71cdccb800dfdea2
[ "MIT" ]
5
2018-07-17T16:47:21.000Z
2021-11-06T15:03:56.000Z
import urllib import requests import multiprocessing.pool from multiprocessing import Pool import uuid import os images_dir = os.path.join("data", "train") small_letters = map(chr, range(ord('a'), ord('f')+1)) digits = map(chr, range(ord('0'), ord('9')+1)) base_16 = digits + small_letters MAX_THREADS = 100 def captcha(code): try: r = requests.get("https://local.thedrhax.pw/rucaptcha/?" + code) filename = code + "_" + str(uuid.uuid1().time) + ".png" path = os.path.join(images_dir, filename) with open(path, "wb") as png: png.write(bytes(r.content)) print("Downloaded " + str(code)) except Exception as e: print(str(e)) if __name__ == "__main__": labels = [] for i in range(0, len(base_16)): for j in range(0, len(base_16)): for m in range(0, len(base_16)): for n in range(0, len(base_16)): try: label = base_16[i] + base_16[j] + base_16[m] + base_16[n] labels.append(label) # urllib.urlretrieve("https://local.thedrhax.pw/rucaptcha/?" + str(label), str(label) + ".png") except Exception as e: print(str(e)) print(labels) p = Pool(MAX_THREADS) while 1: p.map(captcha, labels) print("Finished all downloads")
30.191489
143
0.547569
0
0
0
0
0
0
0
0
243
0.171247
5f05920c4f06c4b47bf5845e7dd08b41ac585c06
7,679
py
Python
code/Models.py
IGLICT/CMIC-Retrieval
d2f452517360f127d0a8175d55ba9f9491c152c2
[ "MIT" ]
29
2021-10-01T12:05:54.000Z
2022-03-16T02:40:19.000Z
code/Models.py
IGLICT/CMIC-Retrieval
d2f452517360f127d0a8175d55ba9f9491c152c2
[ "MIT" ]
5
2021-12-20T12:25:58.000Z
2022-03-10T19:08:32.000Z
code/Models.py
IGLICT/CMIC-Retrieval
d2f452517360f127d0a8175d55ba9f9491c152c2
[ "MIT" ]
1
2022-01-04T05:52:49.000Z
2022-01-04T05:52:49.000Z
import jittor as jt from jittor import nn, models if jt.has_cuda: jt.flags.use_cuda = 1 # jt.flags.use_cuda class QueryEncoder(nn.Module): def __init__(self, out_dim=128): super(QueryEncoder, self).__init__() self.dim = out_dim self.resnet = models.resnet50(pretrained=False) self.resnet.conv1 = nn.Conv2d(4, 64, kernel_size=7, stride=2, padding=3, bias=False) fc_features = self.resnet.fc.in_features self.resnet.fc = nn.Sequential( nn.BatchNorm1d(fc_features*1), nn.Linear(fc_features*1, self.dim), ) def execute(self, input): embeddings = self.resnet(input) embeddings = jt.normalize(embeddings, p=2, dim=1) return embeddings class RenderingEncoder(nn.Module): def __init__(self, out_dim=128): super(RenderingEncoder, self).__init__() self.dim = out_dim self.resnet = models.resnet18(pretrained=False) self.resnet.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False) fc_features = self.resnet.fc.in_features self.resnet.fc = nn.Sequential( nn.BatchNorm1d(fc_features*1), nn.Linear(fc_features*1, self.dim), ) def execute(self, inputs): embeddings = self.resnet(inputs) embeddings = jt.normalize(embeddings, p=2, dim=1) return embeddings class Attention(nn.Module): ''' Revised from pytorch version: <https://github.com/IBM/pytorch-seq2seq/blob/master/LICENSE> ''' """ Applies attention mechanism on the `context` using the `query`. **Thank you** to IBM for their initial implementation of :class:`Attention`. Here is their `License <https://github.com/IBM/pytorch-seq2seq/blob/master/LICENSE>`__. Args: dimensions (int): Dimensionality of the query and context. attention_type (str, optional): How to compute the attention score: * dot: :math:`score(H_j,q) = H_j^T q` * general: :math:`score(H_j, q) = H_j^T W_a q` Example: >>> attention = Attention(256) >>> query = torch.randn(5, 1, 256) >>> context = torch.randn(5, 5, 256) >>> output, weights = attention(query, context) >>> output.size() torch.Size([5, 1, 256]) >>> weights.size() torch.Size([5, 1, 5]) """ def __init__(self, dimensions, attention_type='general'): super(Attention, self).__init__() if attention_type not in ['dot', 'general']: raise ValueError('Invalid attention type selected.') self.attention_type = attention_type if self.attention_type == 'general': self.linear_in = nn.Linear(dimensions, dimensions, bias=False) self.linear_out = nn.Linear(dimensions * 2, dimensions, bias=False) self.softmax = nn.Softmax(dim=-1) self.tanh = nn.Tanh() def execute(self, query, context): """ Args: query (:class:`torch.FloatTensor` [batch size, output length, dimensions]): Sequence of queries to query the context. context (:class:`torch.FloatTensor` [batch size, query length, dimensions]): Data overwhich to apply the attention mechanism. Returns: :class:`tuple` with `output` and `weights`: * **output** (:class:`torch.LongTensor` [batch size, output length, dimensions]): Tensor containing the attended features. * **weights** (:class:`torch.FloatTensor` [batch size, output length, query length]): Tensor containing attention weights. """ batch_size, output_len, dimensions = query.size() query_len = context.size(1) if self.attention_type == "general": query = query.view(batch_size * output_len, dimensions) query = self.linear_in(query) query = query.view(batch_size, output_len, dimensions) # TODO: Include mask on PADDING_INDEX? # (batch_size, output_len, dimensions) * (batch_size, query_len, dimensions) -> # (batch_size, output_len, query_len) # attention_scores = nn.bmm(query, context.transpose(1, 2).contiguous()) attention_scores = nn.bmm(query, context.transpose(0, 2, 1)) # Compute weights across every context sequence attention_scores = attention_scores.view(batch_size * output_len, query_len) attention_weights = self.softmax(attention_scores) attention_weights = attention_weights.view(batch_size, output_len, query_len) # (batch_size, output_len, query_len) * (batch_size, query_len, dimensions) -> # (batch_size, output_len, dimensions) mix = nn.bmm(attention_weights, context) # concat -> (batch_size * output_len, 2*dimensions) combined = jt.concat((mix, query), dim=2) combined = combined.view(batch_size * output_len, 2 * dimensions) # Apply linear_out on every 2nd dimension of concat # output -> (batch_size, output_len, dimensions) output = self.linear_out(combined).view(batch_size, output_len, dimensions) output = self.tanh(output) return output, attention_weights class RetrievalNet(nn.Module): ''' QueryEncoder RenderingEncoder Attention ''' def __init__(self, cfg): super(RetrievalNet, self).__init__() self.dim = cfg.models.z_dim self.size = cfg.data.pix_size self.view_num = cfg.data.view_num self.query_encoder = QueryEncoder(self.dim) self.rendering_encoder = RenderingEncoder(self.dim) self.attention = Attention(self.dim) def execute(self, query, rendering): query_ebd = self.get_query_ebd(query) bs = query_ebd.shape[0] rendering = rendering.view(-1, 1, self.size, self.size) rendering_ebds = self.get_rendering_ebd(rendering).view(-1, self.view_num, self.dim) #(shape, image, ebd) -> (bs, bs, 128) query_ebd = query_ebd.unsqueeze(0).repeat(bs, 1, 1) # query_ebd: bs, bs, dim # rendering_ebds: bs, 12, dim _, weights = self.attention_query(query_ebd, rendering_ebds) # weights: bxxbsx12 # rendering_ebds: bsx12x128 # queried_rendering_ebd: bsxbsx128 (shape, model, 128) # reference to https://pytorchnlp.readthedocs.io/en/latest/_modules/torchnlp/nn/attention.html#Attentionl queried_rendering_ebd = nn.bmm(weights, rendering_ebds) return query_ebd, queried_rendering_ebd def get_query_ebd(self, inputs): return self.query_encoder(inputs) def get_rendering_ebd(self, inputs): return self.rendering_encoder(inputs) def attention_query(self, ebd, pool_ebd): return self.attention(ebd, pool_ebd) if __name__ == '__main__': import yaml import argparse with open('./configs/pix3d.yaml', 'r') as f: config = yaml.load(f) def dict2namespace(config): namespace = argparse.Namespace() for key, value in config.items(): if isinstance(value, dict): new_value = dict2namespace(value) else: new_value = value setattr(namespace, key, new_value) return namespace config = dict2namespace(config) models = RetrievalNet(config) img = jt.random([2,4,224,224]).stop_grad() mask = jt.random([2,12,224,224]).stop_grad() # mm = models.resnet50(pretrained=False) # # print(mm) # a = mm(img) outputs = models(img, mask)
36.393365
113
0.625602
6,796
0.885011
0
0
0
0
0
0
2,775
0.361375
5f05a35db2bf24e5cd3d450829e44e1d6868265e
2,348
py
Python
apps/agendas/tests/unit/selectors/test_doctor_profile_selector.py
victoraguilarc/agendas
31b24a2d6350605b638b59062f297ef3f58e9879
[ "MIT" ]
2
2020-06-06T23:10:27.000Z
2020-10-06T19:12:26.000Z
apps/agendas/tests/unit/selectors/test_doctor_profile_selector.py
victoraguilarc/medical-appointment
31b24a2d6350605b638b59062f297ef3f58e9879
[ "MIT" ]
3
2021-04-08T20:44:38.000Z
2021-09-22T19:04:16.000Z
apps/agendas/tests/unit/selectors/test_doctor_profile_selector.py
victoraguilarc/agendas
31b24a2d6350605b638b59062f297ef3f58e9879
[ "MIT" ]
1
2020-10-10T14:07:37.000Z
2020-10-10T14:07:37.000Z
# -*- coding: utf-8 -*- import pytest from django.db.models import QuerySet from rest_framework.exceptions import NotFound from apps.accounts.response_codes import INVALID_TOKEN from apps.accounts.selectors.pending_action_selector import PendingActionSelector from apps.accounts.tests.factories.pending_action import PendingActionFactory from apps.accounts.tests.factories.user import UserFactory from apps.agendas.models import DoctorProfile from apps.agendas.response_codes import DOCTOR_NOT_FOUND from apps.agendas.selectors.appointment import AppointmentSelector from apps.agendas.selectors.doctor_profile import DoctorProfileSelector from apps.agendas.tests.factories.doctor_profile import DoctorProfileFactory from apps.contrib.api.exceptions import SimpleValidationError from faker import Factory from faker.providers import misc faker = Factory.create() faker.add_provider(misc) @pytest.mark.django_db class DoctorProfileSelectorTests: @staticmethod def test_get_by_uuid(): doctor_profile = DoctorProfileFactory() selected_doctor_profile = DoctorProfileSelector.get_by_uuid(str(doctor_profile.uuid)) assert isinstance(doctor_profile, DoctorProfile) assert selected_doctor_profile == doctor_profile @staticmethod def test_get_by_uuid_not_found(): with pytest.raises(NotFound) as exec_info: DoctorProfileSelector.get_by_uuid(faker.uuid4()) assert exec_info.value.detail.code == DOCTOR_NOT_FOUND['code'] @staticmethod def test_get_enabled_doctors(test_user): inactive_user = UserFactory(is_active=False) active_doctor = DoctorProfileFactory(user=test_user) DoctorProfileFactory(user=inactive_user) doctors = DoctorProfileSelector.get_enabled_doctors() assert isinstance(doctors, QuerySet) assert doctors.count() == 1 assert doctors.first() == active_doctor @staticmethod def test_get_enabled_doctors_empty(): inactive_user = UserFactory(is_active=False) DoctorProfileFactory(user=inactive_user) doctors = DoctorProfileSelector.get_enabled_doctors() assert isinstance(doctors, QuerySet) assert doctors.count() == 0 def test_get_by_username_or_email(self): pass def test_get_by_username_or_email_not_found(self): pass
35.044776
93
0.774702
1,429
0.608603
0
0
1,452
0.618399
0
0
29
0.012351
5f0603321cb19a9d08d78984f4e1439bd2f1a90c
121
py
Python
python/testData/findUsages/GlobalUsages.py
jnthn/intellij-community
8fa7c8a3ace62400c838e0d5926a7be106aa8557
[ "Apache-2.0" ]
2
2019-04-28T07:48:50.000Z
2020-12-11T14:18:08.000Z
python/testData/findUsages/GlobalUsages.py
Cyril-lamirand/intellij-community
60ab6c61b82fc761dd68363eca7d9d69663cfa39
[ "Apache-2.0" ]
173
2018-07-05T13:59:39.000Z
2018-08-09T01:12:03.000Z
python/testData/findUsages/GlobalUsages.py
Cyril-lamirand/intellij-community
60ab6c61b82fc761dd68363eca7d9d69663cfa39
[ "Apache-2.0" ]
2
2020-03-15T08:57:37.000Z
2020-04-07T04:48:14.000Z
<caret>search_variable = 1 def function(): global search_variable search_variable = 2 print(search_variable)
20.166667
26
0.735537
0
0
0
0
0
0
0
0
0
0
5f06913d44d8487508a5267f1e736e022aea0e78
379
py
Python
backend/api/tests/models/location_tests.py
Pachwenko/ember-django-example
cfed8a4519e307ea72a097336f9b07bfa5ee576f
[ "MIT" ]
null
null
null
backend/api/tests/models/location_tests.py
Pachwenko/ember-django-example
cfed8a4519e307ea72a097336f9b07bfa5ee576f
[ "MIT" ]
1
2022-01-17T00:51:15.000Z
2022-01-17T00:51:15.000Z
backend/api/tests/models/location_tests.py
Pachwenko/ember-django-example
cfed8a4519e307ea72a097336f9b07bfa5ee576f
[ "MIT" ]
null
null
null
from decimal import Decimal import pytest from api.tests.factories.location import LocationFactory # potentially helpful fixtures provided by pytest-django # https://pytest-django.readthedocs.io/en/latest/helpers.html#fixtures @pytest.mark.django_db() def test_create_rental(): LocationFactory( lat=Decimal(20.123456789), lng=Decimal(20.123456789), )
23.6875
70
0.759894
0
0
0
0
147
0.387863
0
0
126
0.332454
5f073a6e60f359858de246c60af2ab6ba1d0660b
293
py
Python
dias/dia.py
GU1LH3RME-LIMA/pythonWebjs
4786ef3b900f3b45522a0d3f0c4b83e1e68ae25b
[ "MIT" ]
null
null
null
dias/dia.py
GU1LH3RME-LIMA/pythonWebjs
4786ef3b900f3b45522a0d3f0c4b83e1e68ae25b
[ "MIT" ]
null
null
null
dias/dia.py
GU1LH3RME-LIMA/pythonWebjs
4786ef3b900f3b45522a0d3f0c4b83e1e68ae25b
[ "MIT" ]
null
null
null
import datetime from flask import Flask, render_template ''' algoritmo simples para definir se o dia é par ou impar ''' app = Flask(__name__) @app.route("/") def index(): hoje=datetime.datetime.now()#objeto recebera a data atual return render_template("index.html",dia=hoje.day)
22.538462
61
0.723549
0
0
0
0
145
0.493197
0
0
111
0.377551
5f0795f4ecbd539f9866bfa75241bdbacd313bed
1,532
py
Python
catalog/views/api.py
iraquitan/catalog-app-flask
563981ddc8d55c62428cd4811bdea73ee8f8a846
[ "MIT" ]
null
null
null
catalog/views/api.py
iraquitan/catalog-app-flask
563981ddc8d55c62428cd4811bdea73ee8f8a846
[ "MIT" ]
null
null
null
catalog/views/api.py
iraquitan/catalog-app-flask
563981ddc8d55c62428cd4811bdea73ee8f8a846
[ "MIT" ]
null
null
null
# -*- coding: utf-8 -*- """ * Created by PyCharm. * Project: catalog * Author name: Iraquitan Cordeiro Filho * Author login: pma007 * File: api * Date: 2/26/16 * Time: 11:26 * To change this template use File | Settings | File Templates. """ from flask import Blueprint, jsonify from catalog.models import Category, Item # Define api Blueprint for JSON endpoints api = Blueprint('api', __name__) @api.route('/catalog.json') def catalog_api(): categories = Category.query.all() all_result = [] for category in categories: items = Item.query.filter_by(category_id=category.id).all() result = category.serialize result['Item'] = [i.serialize for i in items] all_result.append(result) return jsonify(Category=all_result) @api.route('/category/<string:category_slug>.json') def category_api(category_slug): category = Category.query.filter_by(slugfield=category_slug).first_or_404() return jsonify(category=category.serialize) @api.route('/category/<string:category_slug>/items.json') def category_items_api(category_slug): category = Category.query.filter_by(slugfield=category_slug).first_or_404() items = Item.query.filter_by(category_id=category.id).all() result = category.serialize result['item'] = [i.serialize for i in items] return jsonify(category=result) @api.route('/item/<string:item_slug>.json') def item_api(item_slug): item = Item.query.filter_by(slugfield=item_slug).first_or_404() return jsonify(item=item.serialize)
30.039216
79
0.719321
0
0
0
0
1,114
0.727154
0
0
436
0.284595
5f0912cfcdcc52bdc014aa57f2387fcc7c7c1a0f
1,854
py
Python
tests/test_debug.py
HazemElAgaty/psycopg2-pgevents
c0952608777052ea2cb90d8c78802ad03f8f3da1
[ "MIT" ]
11
2019-07-12T17:25:36.000Z
2021-06-07T12:51:31.000Z
tests/test_debug.py
HazemElAgaty/psycopg2-pgevents
c0952608777052ea2cb90d8c78802ad03f8f3da1
[ "MIT" ]
5
2020-06-21T14:58:21.000Z
2021-09-06T09:34:32.000Z
tests/test_debug.py
HazemElAgaty/psycopg2-pgevents
c0952608777052ea2cb90d8c78802ad03f8f3da1
[ "MIT" ]
4
2019-07-12T17:25:37.000Z
2021-07-13T13:26:58.000Z
from pytest import raises from psycopg2_pgevents import debug from psycopg2_pgevents.debug import log, set_debug class TestDebug: def test_set_debug_disabled(self): debug._DEBUG_ENABLED = True set_debug(False) assert not debug._DEBUG_ENABLED def test_set_debug_enabled(self): debug._DEBUG_ENABLED = False set_debug(True) assert debug._DEBUG_ENABLED def test_log_invalid_category(self, log_capture): with raises(ValueError): log("foo", category="warningwarningwarning") logs = log_capture.actual() assert len(logs) == 0 def test_log_debug_disabled(self, log_capture): set_debug(False) log("foo") logs = log_capture.actual() # Only log should be the one notifying that logging is being disabled assert len(logs) == 1 def test_log_info(self, log_capture): log("foo") logs = log_capture.actual() assert len(logs) == 1 assert ("pgevents", "INFO", "foo") == logs.pop() def test_log_error(self, log_capture): log("foo", category="error") logs = log_capture.actual() assert len(logs) == 1 assert ("pgevents", "ERROR", "foo") == logs.pop() def test_log_args(self, log_capture): log("foo %s %s %d", "bar", "baz", 1) log("foo %(word1)s %(word2)s %(num)d", {"word2": "baz", "num": 1, "word1": "bar"}) logs = log_capture.actual() assert len(logs) == 2 assert ("pgevents", "INFO", "foo bar baz 1") == logs.pop(0) assert ("pgevents", "INFO", "foo bar baz 1") == logs.pop(0) def test_log_custom_logger(self, log_capture): log("foo", logger_name="test") logs = log_capture.actual() assert len(logs) == 1 assert ("test", "INFO", "foo") == logs.pop()
27.264706
90
0.600863
1,737
0.936893
0
0
0
0
0
0
338
0.182309
5f0a52e79ef2f2c527b1cb664f5e0e589f53a413
1,148
py
Python
abstracto-application/installer/src/main/docker/deployment/python/templates_deploy.py
Sheldan/abstracto
cef46737c5f34719c80c71aa9cd68bc53aea9a68
[ "MIT" ]
5
2020-05-27T14:18:51.000Z
2021-03-24T09:23:09.000Z
abstracto-application/installer/src/main/docker/deployment/python/templates_deploy.py
Sheldan/abstracto
cef46737c5f34719c80c71aa9cd68bc53aea9a68
[ "MIT" ]
5
2020-05-29T21:53:53.000Z
2021-05-26T12:19:16.000Z
abstracto-application/installer/src/main/docker/deployment/python/templates_deploy.py
Sheldan/abstracto
cef46737c5f34719c80c71aa9cd68bc53aea9a68
[ "MIT" ]
null
null
null
import glob import os import sqlalchemy as db from sqlalchemy.sql import text def deploy_template_folder(db_config, folder): engine = db.create_engine('postgresql://%s:%s@%s:%s/%s' % (db_config.user, db_config.password, db_config.host, db_config.port, db_config.database)) if not os.path.isdir(folder): print("Given path was not a folder. Exiting.") exit(1) files = glob.glob(folder + '/**/*.ftl', recursive=True) templates = [] for file in files: with open(file) as template_file: file_content = template_file.read() template_key = os.path.splitext(os.path.basename(file))[0] template = {'key': template_key, 'content': file_content} templates.append(template) print('Deploying %s templates from folder %s' % (len(templates), folder)) with engine.connect() as con: with con.begin(): statement = text("""INSERT INTO template(key, content, last_modified) VALUES(:key, :content, NOW()) ON CONFLICT (key) DO UPDATE SET content = :content""") for line in templates: con.execute(statement, **line)
37.032258
166
0.642857
0
0
0
0
0
0
0
0
268
0.233449
5f0a965a14ab29cfb59691e71680ca0613d8037e
8,466
py
Python
src/external.py
erick-dsnk/Electric
7e8aad1f792321d7839717ed97b641bee7a4a64e
[ "Apache-2.0" ]
null
null
null
src/external.py
erick-dsnk/Electric
7e8aad1f792321d7839717ed97b641bee7a4a64e
[ "Apache-2.0" ]
null
null
null
src/external.py
erick-dsnk/Electric
7e8aad1f792321d7839717ed97b641bee7a4a64e
[ "Apache-2.0" ]
null
null
null
###################################################################### # EXTERNAL # ###################################################################### from Classes.Metadata import Metadata from subprocess import PIPE, Popen from extension import * from colorama import * from utils import * import mslex import halo import sys def handle_python_package(package_name: str, mode: str, metadata: Metadata): command = '' valid = Popen(mslex.split('pip --version'), stdin=PIPE, stdout=PIPE, stderr=PIPE) _, err = valid.communicate() if err: click.echo(click.style('Python Is Not Installed. Exit Code [0011]', fg='red')) disp_error_msg(get_error_message('0011', 'install')) handle_exit('ERROR', None, metadata) if mode == 'install': command = 'python -m pip install --upgrade --no-input' command += f' {package_name}' proc = Popen(mslex.split(command), stdin=PIPE, stdout=PIPE, stderr=PIPE) py_version = sys.version.split() for line in proc.stdout: line = line.decode('utf-8') if f'Collecting {package_name}' in line: write(f'Python v{py_version[0]} :: Collecting {package_name}', 'green', metadata) if 'Downloading' in line and package_name in line: write( f'Python v{py_version[0]} :: Downloading {package_name}', 'green', metadata) if 'Installing collected packages' in line and package_name in line: write( f'Python v{py_version[0]} :: Installing {package_name}', 'green', metadata) if f'Requirement already satisfied: {package_name} ' in line and package_name in line: write( f'Python v{py_version[0]} :: {package_name} Is Already Installed And On The Latest Version ==> {line.split()[-1]}', 'yellow', metadata) if 'Successfully installed' in line and package_name in line: ver = line.split('-')[1] write( f'Python v{py_version[0]} :: Successfully Installed {package_name} {ver}', 'green', metadata) if 'You should consider upgrading via' in line: wants = click.confirm( 'Would you like to upgrade your pip version?') if wants: write('Updating Pip Version', 'green', metadata) Popen(mslex.split('python -m pip install --upgrade pip')) elif mode == 'uninstall': command = 'python -m pip uninstall --no-input --yes' command += f' {package_name}' proc = Popen(mslex.split(command), stdin=PIPE, stdout=PIPE, stderr=PIPE) py_version = sys.version.split() for line in proc.stdout: line = line.decode('utf-8') if 'Uninstalling' in line and package_name in line: write( f'Python v{py_version[0]} :: Uninstalling {package_name}', 'green', metadata) if 'Successfully uninstalled' in line and package_name in line: ver = line.split('-')[1] write( f'Python v{py_version[0]} :: Successfully Uninstalled {package_name} {ver}', 'green', metadata) _, err = proc.communicate() if err: err = err.decode('utf-8') if f'WARNING: Skipping {package_name}' in err: write( f'Python v{py_version[0]} :: Could Not Find Any Installations Of {package_name}', 'yellow', metadata) def handle_node_package(package_name: str, mode: str, metadata: Metadata): version_proc = Popen(mslex.split('npm --version'), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) version, err = version_proc.communicate() version = version.decode().strip() if err: click.echo(click.style('npm Or node Is Not Installed. Exit Code [0011]', fg='bright_yellow')) disp_error_msg(get_error_message('0011', 'install')) handle_exit('ERROR', None, metadata) if mode == 'install': proc = Popen(mslex.split(f'npm i {package_name} -g'), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) write(f'npm v{version} :: Collecting {package_name}', 'green', metadata) package_version = None for line in proc.stdout: line = line.decode() if 'node install.js' in line: write(f'npm v{version} :: Running `node install.js` for {package_name}', 'green', metadata) if package_name in line and '@' in line and 'install' in line or ' postinstall' in line: package_version = line.split()[1] write(f'npm v{version} :: {package_version} Installing To <=> "{line.split()[3]}"', 'green', metadata) if 'Success' in line and package_name in line or 'added' in line: write(f'npm v{version} :: Successfully Installed {package_version}', 'green', metadata) if 'updated' in line: if package_version: write(f'npm v{version} :: Sucessfully Updated {package_version}', 'green', metadata) else: write(f'npm v{version} :: Sucessfully Updated {package_name}', 'green', metadata) else: proc = Popen(mslex.split(f'npm uninstall -g {package_name}'), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) for line in proc.stdout: line = line.decode() if 'up to date' in line: write(f'npm v{version} :: Could Not Find Any Existing Installations Of {package_name}', 'yellow', metadata) if 'removed' in line: number = line.split(' ')[1].strip() time = line.split(' ')[4].strip() write(f'npm v{version} :: Sucessfully Uninstalled {package_name} And {number} Other Dependencies in {time}', 'green', metadata) def handle_vscode_extension(package_name: str, mode: str, metadata: Metadata): try: version_proc = Popen(mslex.split('code --version'), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) except FileNotFoundError: click.echo(click.style('Visual Studio Code Or vscode Is Not Installed. Exit Code [0111]', fg='bright_yellow')) disp_error_msg(get_error_message('0111', 'install')) handle_exit('ERROR', None, metadata) version, err = version_proc.communicate() version = version.decode().strip().split('\n')[0] if err: click.echo(click.style('Visual Studio Code Or vscode Is Not Installed. Exit Code [0111]', fg='bright_yellow')) disp_error_msg(get_error_message('0111', 'install')) handle_exit('ERROR', None, metadata) if mode == 'install': command = f'code --install-extension {package_name} --force' proc = Popen(mslex.split(command), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) for line in proc.stdout: line = line.decode() if 'Installing extensions' in line: write(f'Code v{version} :: Installing {Fore.MAGENTA}{package_name}{Fore.RESET}', 'green', metadata) if 'is already installed' in line: write(f'{Fore.GREEN}Code v{version} :: {Fore.MAGENTA}{package_name}{Fore.YELLOW} is already installed!', 'white', metadata) if 'was successfully installed' in line: write(f'{Fore.GREEN}Code v{version} :: Successfully Installed {Fore.MAGENTA}{package_name}{Fore.RESET}', 'green', metadata) if mode == 'uninstall': command = f'code --uninstall-extension {package_name} --force' proc = Popen(mslex.split(command), stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True) for line in proc.stdout: line = line.decode() if 'Uninstalling' in line: write(f'Code v{version} :: Uninstalling {Fore.MAGENTA}{package_name}{Fore.RESET}', 'green', metadata) if 'is not installed' in line: write(f'{Fore.GREEN}Code v{version} :: {Fore.MAGENTA}{package_name}{Fore.YELLOW} is not installed!', 'white', metadata) if 'was successfully uninstalled' in line: write(f'{Fore.GREEN}Code v{version} :: Successfully Uninstalled {Fore.MAGENTA}{package_name}{Fore.RESET}', 'green', metadata)
46.516484
155
0.583038
0
0
0
0
0
0
0
0
3,375
0.398653
5f0b1b6f16ccc30241e064e1c6cda37d2700becb
3,242
py
Python
testing/regrid/testGhostedDistArray.py
xylar/cdat
8a5080cb18febfde365efc96147e25f51494a2bf
[ "BSD-3-Clause" ]
62
2018-03-30T15:46:56.000Z
2021-12-08T23:30:24.000Z
testing/regrid/testGhostedDistArray.py
xylar/cdat
8a5080cb18febfde365efc96147e25f51494a2bf
[ "BSD-3-Clause" ]
114
2018-03-21T01:12:43.000Z
2021-07-05T12:29:54.000Z
testing/regrid/testGhostedDistArray.py
CDAT/uvcdat
5133560c0c049b5c93ee321ba0af494253b44f91
[ "BSD-3-Clause" ]
14
2018-06-06T02:42:47.000Z
2021-11-26T03:27:00.000Z
import distarray import numpy import unittest from mpi4py import MPI class TestGhostedDistArray(unittest.TestCase): """ Test distributed array """ def setUp(self): pass def test_test0(self): """ Test constructors """ da = distarray.ghZeros( (2,3), numpy.float64 ) da.free() da = distarray.ghOnes( (2,3), numpy.float64 ) da.free() da = distarray.ghArray( [1,2,3] ) da.free() def test_test1(self): """ 1D, float64 """ dtyp = numpy.float64 # MPI stuff comm = MPI.COMM_WORLD rk = comm.Get_rank() sz = comm.Get_size() # create the dist array n = 10 da = distarray.ghZeros( (n,), dtyp, ghostWidth=1 ) # set data da[:] = 100*rk + numpy.array([i for i in range(n)], dtyp) # access remote data leftRk = (rk - 1) % sz print 'proc %d tries to access data from %d' % (rk, leftRk) leftData = da.get(pe=leftRk, winID=(1,)) print 'leftData for rank %d = %s' % (rk, str(leftData)) # check if leftRk < rk: self.assertEqual(leftData[0], da[-1] - 100) else: self.assertEqual(leftData[0], da[-1] + 100*(sz-1)) # free da.free() def test_test2(self): """ 1D, float32 """ dtyp = numpy.float64 # MPI stuff comm = MPI.COMM_WORLD rk = comm.Get_rank() sz = comm.Get_size() # create the dist array n = 10 da = distarray.ghZeros( (n,), dtyp, ghostWidth=1 ) # set data da[:] = 100*rk + numpy.array([i for i in range(n)], dtyp) # access remote data leftRk = (rk - 1) % sz print 'proc %d tries to access data from %d' % (rk, leftRk) leftData = da.get(pe=leftRk, winID=(1,)) print 'leftData for rank %d = %s' % (rk, str(leftData)) # check if leftRk < rk: self.assertEqual(leftData[0], da[-1] - 100) else: self.assertEqual(leftData[0], da[-1] + 100*(sz-1)) # free da.free() def test_test3(self): """ 1D, int """ dtyp = numpy.int64 # MPI stuff comm = MPI.COMM_WORLD rk = comm.Get_rank() sz = comm.Get_size() # create the dist array n = 10 da = distarray.ghZeros( (n,), dtyp, ghostWidth=1 ) # set data da[:] = 100*rk + numpy.array([i for i in range(n)], dtyp) # access remote data leftRk = (rk - 1) % sz print 'proc %d tries to access data from %d' % (rk, leftRk) leftData = da.get(pe=leftRk, winID=(1,)) print 'leftData for rank %d = %s' % (rk, str(leftData)) # check if leftRk < rk: self.assertEqual(leftData[0], da[-1] - 100) else: self.assertEqual(leftData[0], da[-1] + 100*(sz-1)) # free da.free() if __name__ == '__main__': print "" # Spacer suite = unittest.TestLoader().loadTestsFromTestCase(TestGhostedDistArray) unittest.TextTestRunner(verbosity = 1).run(suite) MPI.Finalize()
26.57377
77
0.507403
2,947
0.909007
0
0
0
0
0
0
627
0.193399
5f0b9146ca28c5866c71c4fff522e7ed582731d7
3,900
py
Python
cir/user_views.py
wafield/cir
123d4bfe3e5bb4b0d605de486a91a0cb7eb34e4c
[ "MIT" ]
null
null
null
cir/user_views.py
wafield/cir
123d4bfe3e5bb4b0d605de486a91a0cb7eb34e4c
[ "MIT" ]
null
null
null
cir/user_views.py
wafield/cir
123d4bfe3e5bb4b0d605de486a91a0cb7eb34e4c
[ "MIT" ]
1
2018-06-23T21:11:53.000Z
2018-06-23T21:11:53.000Z
import json from django.contrib.auth import authenticate, login, logout from django.http import HttpResponse from django.utils import timezone from django.contrib.auth.signals import user_logged_in from cir.models import * VISITOR_ROLE = 'visitor' def login_view(request): response = {} email = request.REQUEST.get('email').lower() password = request.REQUEST.get('password') users = User.objects.filter(username=email) if users.count() != 1: return HttpResponse("Your user name and/or password is incorrect.", status=403) user = authenticate(username=users[0].username, password=password) if user: login(request, user) # request.session['user_id'] = user.id response['user_id'] = user.id response['user_name'] = user.get_full_name() request.session['role'] = VISITOR_ROLE try: forum = Forum.objects.get(id=request.session['forum_id']) if request.session['forum_id'] != -1: request.session['role'] = Role.objects.get(user=user, forum=forum).role except: pass response['role'] = request.session['role'] return HttpResponse(json.dumps(response), mimetype='application/json') else: return HttpResponse("Your user name and/or password is incorrect.", status=403) def register(request): response = {} email = request.REQUEST.get('email').lower() if User.objects.filter(username=email).count() > 0: return HttpResponse("This user already exists; please sign in.", status=403) password = request.POST['password'] description = request.POST['description'] user = User.objects.create_user(email, email, password) user.first_name = request.POST['first-name'] user.last_name = request.POST['last-name'] user.save() userinfo = UserInfo(user=user, description=description, last_visited_forum=None) userinfo.save() user = authenticate(username=email, password=password) if user: login(request, user) # request.session['user_id'] = user.id response['user_id'] = user.id response['user_name'] = user.get_full_name() response['role'] = VISITOR_ROLE return HttpResponse(json.dumps(response), mimetype='application/json') else: return HttpResponse("Unknown error.", status=403) def logout_view(request): forum_id = request.session['forum_id'] logout(request) # request.session['user_id'] = -1 request.session['forum_id'] = forum_id return HttpResponse(json.dumps({}), mimetype='application/json') def change_info(request): if not request.user.is_authenticated(): return HttpResponse("Please log in first.", status=403) user = request.user action = request.REQUEST.get('action') if action == 'get': response = {} response['first_name'] = user.first_name response['last_name'] = user.last_name response['email'] = user.email response['description'] = user.info.description return HttpResponse(json.dumps(response), mimetype='application/json') if action == 'set-pw': old_pw = request.REQUEST.get('old_password') if not user.check_password(old_pw): return HttpResponse("Password incorrect.", status=403) new_pw = request.REQUEST.get('new_password') user.set_password(new_pw) user.save() return HttpResponse(json.dumps({}), mimetype='application/json') if action == 'set-info': response = {} user.first_name = request.REQUEST.get('first-name') user.last_name = request.REQUEST.get('last-name') user.info.description = request.REQUEST.get('description') user.info.save() user.save() response['user_name'] = user.get_full_name() return HttpResponse(json.dumps(response), mimetype='application/json')
39
87
0.661282
0
0
0
0
0
0
0
0
749
0.192051
5f0bcf77d0e89f7eeb81cfefde1fb86ef9a0fc3f
2,844
py
Python
LeetCode/Python3/HashTable/451. Sort Characters By Frequency.py
WatsonWangZh/CodingPractice
dc057dd6ea2fc2034e14fd73e07e73e6364be2ae
[ "MIT" ]
11
2019-09-01T22:36:00.000Z
2021-11-08T08:57:20.000Z
LeetCode/Python3/HashTable/451. Sort Characters By Frequency.py
WatsonWangZh/LeetCodePractice
dc057dd6ea2fc2034e14fd73e07e73e6364be2ae
[ "MIT" ]
null
null
null
LeetCode/Python3/HashTable/451. Sort Characters By Frequency.py
WatsonWangZh/LeetCodePractice
dc057dd6ea2fc2034e14fd73e07e73e6364be2ae
[ "MIT" ]
2
2020-05-27T14:58:52.000Z
2020-05-27T15:04:17.000Z
# Given a string, sort it in decreasing order based on the frequency of characters. # Example 1: # Input: # "tree" # Output: # "eert" # Explanation: # 'e' appears twice while 'r' and 't' both appear once. # So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer. # Example 2: # Input: # "cccaaa" # Output: # "cccaaa" # Explanation: # Both 'c' and 'a' appear three times, so "aaaccc" is also a valid answer. # Note that "cacaca" is incorrect, as the same characters must be together. # Example 3: # Input: # "Aabb" # Output: # "bbAa" # Explanation: # "bbaA" is also a valid answer, but "Aabb" is incorrect. # Note that 'A' and 'a' are treated as two different characters. import collections import heapq class Solution: def frequencySort(self, s: str) -> str: # M1. 模拟 O(nlogn) O(n) if not s: return s # Convert s to a list. s = list(s) # Sort the characters in s. s.sort() # Make a list of strings, one for each unique char. all_strings = [] cur_sb = [s[0]] for c in s[1:]: # If the last character on string builder is different... if cur_sb[-1] != c: all_strings.append("".join(cur_sb)) cur_sb = [] cur_sb.append(c) all_strings.append("".join(cur_sb)) # Sort the strings by length from *longest* to shortest. all_strings.sort(key=lambda string : len(string), reverse=True) # Convert to a single string to return. # Converting a list of strings to a string is often done # using this rather strange looking python idiom. return "".join(all_strings) # ==================================== # M2. 哈希表+排序 O(nlogn) O(n) # Count the occurence on each character cnt = collections.defaultdict(int) for c in s: cnt[c] += 1 # Sort and Build string res = [] for k, v in sorted(cnt.items(), key = lambda x: -x[1]): res += [k] * v return "".join(res) # ==================================== # O(nlogk) O(n) # Count the occurence on each character cnt = collections.Counter(s) # Build string res = [] for k, v in cnt.most_common(): res += [k] * v return "".join(res) # ==================================== # M3.哈希表 + 优先级队列 O(nlogk) O(n) # Count the occurence on each character cnt = collections.Counter(s) # Build heap heap = [(-v, k) for k, v in cnt.items()] heapq.heapify(heap) # Build string res = [] while heap: v, k = heapq.heappop(heap) res += [k] * -v return ''.join(res)
27.61165
86
0.522504
2,137
0.743563
0
0
0
0
0
0
1,461
0.508351
5f0bf2755cfa5ea302283c30bc9e0ccfd4f8893d
1,837
py
Python
ttkinter_app.py
bombero2020/python_tools
393092609c4555e47b9789eb3fcb614ea25fdef9
[ "MIT" ]
null
null
null
ttkinter_app.py
bombero2020/python_tools
393092609c4555e47b9789eb3fcb614ea25fdef9
[ "MIT" ]
null
null
null
ttkinter_app.py
bombero2020/python_tools
393092609c4555e47b9789eb3fcb614ea25fdef9
[ "MIT" ]
null
null
null
#!/usr/bin/env python # -*- coding: utf-8 -*- import tkinter as tk from tkinter import ttk class HashCorpFrame(ttk.Frame): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.name_entry = ttk.Entry(self) self.name_entry.pack() self.greet_button = ttk.Button( self, text="Saludar", command=self.say_hello) self.greet_button.pack() self.greet_label = ttk.Label(self) self.greet_label.pack() def say_hello(self): self.greet_label["text"] = \ "¡Hola, {}!".format(self.name_entry.get()) class AboutFrame(ttk.Frame): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.label = ttk.Label(self) self.label["text"] = ("Visitanos en recursospython.com y " "foro.recursospython.com.") self.label.pack() self.web_button = ttk.Button(self, text="Visitar web") self.web_button.pack(pady=10) self.forum_button = ttk.Button(self, text="Visitar foro") self.forum_button.pack() class Application(ttk.Frame): def __init__(self, main_window): super().__init__(main_window) main_window.title("Hashing Coorp.") main_window.geometry('700x400') # anchura x altura main_window.configure(bg = 'beige') self.notebook = ttk.Notebook(self) self.hashcorp_frame = HashCorpFrame(self.notebook) self.notebook.add( self.hashcorp_frame, text="Saludos", padding=10) self.about_frame = AboutFrame(self.notebook) self.notebook.add( self.about_frame, text="Acerca de", padding=10) self.notebook.pack(padx=10, pady=10) self.pack() main_window = tk.Tk() app = Application(main_window) app.mainloop()
27.41791
66
0.616222
1,668
0.907508
0
0
0
0
0
0
237
0.128945
5f0dcd6e6a26bb27177e11fcbcba91b603bd720d
8,513
py
Python
api/src/dojo.py
mosoriob/dojo
71bba04c4fdc4224320087b4c400fcba91b6597d
[ "MIT" ]
1
2021-10-08T00:47:58.000Z
2021-10-08T00:47:58.000Z
api/src/dojo.py
mosoriob/dojo
71bba04c4fdc4224320087b4c400fcba91b6597d
[ "MIT" ]
null
null
null
api/src/dojo.py
mosoriob/dojo
71bba04c4fdc4224320087b4c400fcba91b6597d
[ "MIT" ]
null
null
null
import uuid from typing import List from elasticsearch import Elasticsearch from elasticsearch.exceptions import NotFoundError from fastapi import APIRouter, Response, status from validation import DojoSchema from src.settings import settings import logging logger = logging.getLogger(__name__) router = APIRouter() es = Elasticsearch([settings.ELASTICSEARCH_URL], port=settings.ELASTICSEARCH_PORT) def search_by_model(model_id): q = {"query": {"term": {"model_id.keyword": {"value": model_id, "boost": 1.0}}}} return q def search_and_scroll(index, query=None, size=10, scroll_id=None): if query: q = { "query": { "query_string": { "query": query, } }, } else: q = {"query": {"match_all": {}}} if not scroll_id: # we need to kick off the query results = es.search(index=index, body=q, scroll="2m", size=size) else: # otherwise, we can use the scroll results = es.scroll(scroll_id=scroll_id, scroll="2m") # get count count = es.count(index=index, body=q) # if results are less than the page size (10) don't return a scroll_id if len(results["hits"]["hits"]) < size: scroll_id = None else: scroll_id = results.get("_scroll_id", None) return { "hits": count["count"], "scroll_id": scroll_id, "results": [i["_source"] for i in results["hits"]["hits"]], } @router.post("/dojo/directive") def create_directive(payload: DojoSchema.ModelDirective): """ Create a `directive` for a model. This is the command which is used to execute the model container. The `directive` is templated out using Jinja, where each templated `{{ item }}` maps directly to the name of a specific `parameter. """ try: es.update(index="directives", body={"doc": payload.dict()}, id=payload.model_id) return Response( status_code=status.HTTP_200_OK, headers={"location": f"/dojo/directive/{payload.model_id}"}, content=f"Created directive for model with id = {payload.model_id}", ) except NotFoundError: es.index(index="directives", body=payload.json(), id=payload.model_id) return Response( status_code=status.HTTP_201_CREATED, headers={"location": f"/dojo/directive/{payload.model_id}"}, content=f"Created directive for model with id = {payload.model_id}", ) @router.get("/dojo/directive/{model_id}") def get_directive(model_id: str) -> DojoSchema.ModelDirective: results = es.search(index="directives", body=search_by_model(model_id)) try: directive = results["hits"]["hits"][-1]["_source"] return directive except: return Response( status_code=status.HTTP_404_NOT_FOUND, content=f"Directive for model {model_id} not found.", ) @router.post("/dojo/config") def create_configs(payload: List[DojoSchema.ModelConfig]): """ Create one or more model `configs`. A `config` is a settings file which is used by the model to set a specific parameter level. Each `config` is stored to S3, templated out using Jinja, where each templated `{{ item }}` maps directly to the name of a specific `parameter. """ for p in payload: es.index(index="configs", body=p.json(), id=p.id) return Response( status_code=status.HTTP_201_CREATED, headers={"location": f"/api/dojo/config/{p.id}"}, content=f"Created config(s) for model with id = {p.model_id}", ) @router.get("/dojo/config/{model_id}") def get_configs(model_id: str) -> List[DojoSchema.ModelConfig]: results = es.search(index="configs", body=search_by_model(model_id)) try: return [i["_source"] for i in results["hits"]["hits"]] except: return Response( status_code=status.HTTP_404_NOT_FOUND, content=f"Config(s) for model {model_id} not found.", ) @router.post("/dojo/outputfile") def create_outputfiles(payload: List[DojoSchema.ModelOutputFile]): """ Create an `outputfile` for a model. Each `outputfile` represents a single file that is created upon each model execution. Here we store key metadata about the `outputfile` which enables us to find it within the container and normalize it into a CauseMos compliant format. """ for p in payload: es.index(index="outputfiles", body=p.json(), id=p.id) return Response( status_code=status.HTTP_201_CREATED, headers={"location": f"/api/dojo/outputfile/{p.id}"}, content=f"Created outputfile(s) for model with id = {p.model_id}", ) @router.get("/dojo/outputfile/{model_id}") def get_outputfiles(model_id: str) -> List[DojoSchema.ModelOutputFile]: results = es.search(index="outputfiles", body=search_by_model(model_id)) try: return [i["_source"] for i in results["hits"]["hits"]] except: return Response( status_code=status.HTTP_404_NOT_FOUND, content=f"Outputfile(s) for model {model_id} not found.", ) ### Accessories Endpoints @router.get("/dojo/accessories/{model_id}") def get_accessory_files(model_id: str) -> List[DojoSchema.ModelAccessory]: """ Get the `accessory files` for a model. Each `accessory file` represents a single file that is created to be associated with the model. Here we store key metadata about the `accessory file` which enables us to find it within the container and provide it to Uncharted. """ try: results = es.search(index="accessories", body=search_by_model(model_id)) return [i["_source"] for i in results["hits"]["hits"]] except: return Response( status_code=status.HTTP_404_NOT_FOUND, content=f"Accessory file(s) for model {model_id} not found.", ) @router.post("/dojo/accessories") def create_accessory_file(payload: DojoSchema.ModelAccessory): """ Create or update an `accessory file` for a model. `id` is optional and will be assigned a uuid by the API. Each `accessory file` represents a single file that is created to be associated with the model. Here we store key metadata about the `accessory file` which enables us to find it within the container and provide it to Uncharted. """ try: payload.id = uuid.uuid4() # update payload with uuid es.update(index="accessories", body={"doc": payload.dict()}, id=payload.id) return Response( status_code=status.HTTP_200_OK, headers={"location": f"/dojo/accessory/{payload.model_id}"}, content=f"Created accessory for model with id = {payload.model_id}", ) except NotFoundError: es.index(index="accessories", body=payload.json(), id=payload.id) return Response( status_code=status.HTTP_201_CREATED, headers={"location": f"/dojo/accessory/{payload.model_id}"}, content=f"Created accessory for model with id = {payload.model_id}", ) @router.put("/dojo/accessories") def create_accessory_files(payload: List[DojoSchema.ModelAccessory]): """ The PUT would overwrite the entire array with a new array. For each, create an `accessory file` for a model. `id` is optional and will be assigned a uuid by the API. Each `accessory file` represents a single file that is created to be associated with the model. Here we store key metadata about the `accessory file` which enables us to find it within the container and provide it to Uncharted. """ if len(payload) == 0: return Response(status_code=status.HTTP_400_BAD_REQUEST,content=f"No payload") # Delete previous entries. try: results = es.search(index="accessories", body=search_by_model(payload[0].model_id)) for i in results["hits"]["hits"]: es.delete(index="accessories", id=i["_source"]["id"]) except Exception as e: logger.error(e) # Add the new entries. for p in payload: p.id = uuid.uuid4() # update payload with uuid es.index(index="accessories", body=p.json(), id=p.id) return Response( status_code=status.HTTP_201_CREATED, headers={"location": f"/api/dojo/accessory/{p.id}"}, content=f"Created accessories(s) for model with id = {p.model_id}", )
35.470833
127
0.649595
0
0
0
0
6,966
0.818278
0
0
3,808
0.447316
5f0f752c5211938014f35ccb9166c1413d779264
3,313
py
Python
test/test_prob_models.py
sylar233/de-identification
44731e9c22de647063bd82a19936b4c5a144ea6e
[ "Apache-2.0" ]
5
2016-11-07T12:54:51.000Z
2018-12-15T00:20:26.000Z
test/test_prob_models.py
sylar233/de-identification
44731e9c22de647063bd82a19936b4c5a144ea6e
[ "Apache-2.0" ]
5
2016-07-05T06:06:31.000Z
2016-07-27T05:21:36.000Z
test/test_prob_models.py
sylar233/de-identification
44731e9c22de647063bd82a19936b4c5a144ea6e
[ "Apache-2.0" ]
3
2018-07-18T07:32:43.000Z
2021-11-05T05:25:55.000Z
from django.test import TestCase from common.data_utilities import DataUtils from prob_models.dep_graph import DependencyGraph from prob_models.jtree import JunctionTree import common.constant as c TESTING_FILE = c.TEST_DATA_PATH """ The test file has for fields, and the dependency graph would be a complete graph. The junction Tree has only one clique """ class DependencyGraphTests(TestCase): def setUp(self): self.data = DataUtils(TESTING_FILE) def test_dep_graph_edges_length_is_6(self): """ Test the Dependency graph computation """ dep_graph = DependencyGraph(self.data) edges = dep_graph.get_dep_edges() #print self.data.get_domain() self.assertEqual(len(edges) == 3, True) def test_dep_graph_with_white_list(self): dep_graph = DependencyGraph(self.data, white_list = [['Age', 'Income', 'TRV'], ['DGF', 'HTN']]) edges = dep_graph.get_dep_edges() def dep_graph_without_noise(self): dep_graph = DependencyGraph(self.data, noise_flag = False) self.assertEqual( dep_graph.get_dep_edges() == [['Height', 'HTN'], ['Weight', 'HTN'], ['Income', 'TRV']], True) def test_dep_graph_contruct_from_edges(self): edges = [['A','B'], ['B','C'], ['C', 'D'], ['D', 'E']] dep_graph = DependencyGraph(edges = edges) self.assertEqual(dep_graph.get_dep_edges() == edges, True) def test_dep_graph_add_white_list(self): edges = [['A','B'], ['B','C'], ['C', 'D'], ['D', 'E'], ['F']] white_list = [['A','B', 'C'], ['C', 'D', 'F']] dep_graph = DependencyGraph(edges = edges) self.assertEqual(dep_graph.set_white_list(white_list).get_dep_edges() == [['A', 'B'], ['B', 'C'], ['C', 'D'], ['D', 'E'], ['F'], ('A', 'B'), ('A', 'C'), ('B', 'C'), ('C', 'D'), ('C', 'F'), ('D', 'F')], True) class JunctionTreeTests(TestCase): def setUp(self): self.data = DataUtils(TESTING_FILE) self.dep_graph = DependencyGraph(self.data) self.edges = self.dep_graph.get_dep_edges() self.nodes = self.data.get_nodes_name() self.jtree_path = c.TEST_JTREE_FILE_PATH def test_jtree_without_noise(self): dep_graph = DependencyGraph(self.data, noise_flag = False) edges = dep_graph.get_dep_edges() jtree = JunctionTree(edges, self.nodes, self.jtree_path) cliques = jtree.get_jtree()['cliques'] self.assertEqual(cliques == [['HTN', 'Height'], ['HTN', 'Weight'], ['Income', 'TRV'], ['Age'], ['DGF']], True) def test_jtree_with_white_list(self): dep_graph = DependencyGraph(self.data, white_list = [['Age', 'Income', 'TRV'], ['DGF', 'HTN']]) edges = dep_graph.get_dep_edges() jtree = JunctionTree(edges, self.nodes, self.jtree_path) cliques = jtree.get_jtree()['cliques'] self.assertEqual(cliques == [['HTN', 'Height'], ['HTN', 'Weight'], ['HTN', 'DGF'], ['Income', 'TRV', 'Age']], True) def test_build_jtree_then_check_jtree_file(self): self.TestA() self.TestB() def TestA(self): """ The dependency graph is a complete graph, so there is only one clique in the junction tree """ jtree = JunctionTree(self.edges, self.nodes, self.jtree_path) jtreepy = jtree.get_jtree() #print jtreepy self.assertEqual(len(jtreepy) == 3, True) def TestB(self): import os, time from stat import * st = os.stat(self.jtree_path) now = time.time() # TODO: Need to know this file is new modified #self.assertEqual((st.st_mtime - now) < 100000, True)
35.244681
209
0.677634
2,948
0.889828
0
0
0
0
0
0
772
0.233021
5f10c305acc4e613b5656eb25e050b130ecbb7b2
631
py
Python
examples/house_prices_kaggle.py
ChillBoss/ml_automation
50d42b3cd5a3bb2f7a91e4c53bf3bbfe7a3b1741
[ "MIT" ]
null
null
null
examples/house_prices_kaggle.py
ChillBoss/ml_automation
50d42b3cd5a3bb2f7a91e4c53bf3bbfe7a3b1741
[ "MIT" ]
null
null
null
examples/house_prices_kaggle.py
ChillBoss/ml_automation
50d42b3cd5a3bb2f7a91e4c53bf3bbfe7a3b1741
[ "MIT" ]
null
null
null
# Regression Task, assumption is that the data is in the right directory # data can be taken from https://www.kaggle.com/c/house-prices-advanced-regression-techniques/data import os import ml_automation if __name__ == '__main__': data_dir = os.path.join(os.path.dirname(__file__), 'data') f_train = os.path.join(data_dir, 'train.csv') f_test = os.path.join(data_dir, 'test.csv') #training ml_automation.automate(path=f_train, ignore_cols=['Id'], out_dir='model') #predictions preds = ml_automation.predict(f_test, model_dir='model') print(preds)
30.047619
98
0.66561
0
0
0
0
0
0
0
0
246
0.389857
5f10f60ec6549819aee0320bd7db378dfb94aabf
3,232
py
Python
src/bel_commons/explorer_toolbox.py
cthoyt/pybel-web
a27f30617b9209d5531a6b65760597f8d45e9957
[ "MIT" ]
2
2019-07-17T16:17:44.000Z
2019-07-18T17:05:36.000Z
src/bel_commons/explorer_toolbox.py
cthoyt/pybel-web
a27f30617b9209d5531a6b65760597f8d45e9957
[ "MIT" ]
3
2020-04-25T17:30:58.000Z
2020-04-25T17:32:11.000Z
src/bel_commons/explorer_toolbox.py
cthoyt/pybel-web
a27f30617b9209d5531a6b65760597f8d45e9957
[ "MIT" ]
null
null
null
# -*- coding: utf-8 -*- """Constants for building the biological network explorer's transformations toolbox.""" from typing import List, Tuple from pybel.struct.pipeline.decorators import mapped # Default NetworkX explorer toolbox functions (name, button text, description) _explorer_toolbox = ( ('collapse_to_genes', 'Collapse to Genes', 'Collapse proteins and RNAs to genes'), ('collapse_all_variants', 'Collapse Variants', 'Collapse Variants to their Parent Nodes'), ('collapse_to_protein_interactions', 'Protein Interaction Network', 'Reduce the Network to Interactions between Proteins'), ('enrich_protein_and_rna_origins', 'Expand Protein Origins', 'Adds RNAs corresponding to Proteins, then adds Genes corresponding to RNAs and miRNAs'), ('prune_protein_rna_origins', 'Prune Genes/RNAs', 'Delete genes/RNAs that only have transcription/translation edges'), ('expand_periphery', 'Expand Periphery', 'Expand the periphery of the network'), ('expand_internal', 'Expand Internal', 'Adds missing edges between nodes in the network'), ('remove_isolated_nodes', 'Remove Isolated Nodes', 'Remove from the network all isolated nodes'), ('get_largest_component', 'Get Largest Component', 'Retain only the largest component and removes all others'), ('enrich_unqualified', 'Enrich unqualified edges', 'Adds unqualified edges from the universe'), ('remove_associations', 'Remove Associations', 'Remove associative relations'), ('remove_pathologies', 'Remove Pathologies', 'Removes all pathology nodes'), ('remove_biological_processes', 'Remove Biological Processes', 'Removes all biological process nodes'), ) _bio2bel_functions = ( ( 'enrich_rnas', 'Enrich RNA controllers from miRTarBase', 'Adds the miRNA controllers of RNA nodes from miRTarBase' ), ( 'enrich_mirnas', 'Enrich miRNA targets', 'Adds the RNA targets of miRNA nodes from miRTarBase' ), ( 'enrich_genes_with_families', 'Enrich Genes with Gene Family Membership', 'Adds the parents of HGNC Gene Families' ), ( 'enrich_families_with_genes', 'Enrich Gene Family Membership', 'Adds the children to HGNC gene familes' ), ( 'enrich_bioprocesses', 'Enrich Biological Process Hierarchy', 'Adds parent biological processes' ), ( 'enrich_chemical_hierarchy', 'Enrich Chemical Hierarchy', 'Adds parent chemical entries' ), ( 'enrich_proteins_with_enzyme_families', 'Add Enzyme Class Members', 'Adds enzyme classes for each protein' ), ( 'enrich_enzymes', 'Enrich Enzyme Classes', 'Adds proteins corresponding to present ExPASy Enzyme codes' ) ) def _function_is_registered(name: str) -> bool: return name in mapped def get_explorer_toolbox() -> List[Tuple[str, str, str]]: """Get the explorer toolbox list.""" explorer_toolbox = list(_explorer_toolbox) explorer_toolbox.extend( (func_name, title, description) for func_name, title, description in _bio2bel_functions if _function_is_registered(func_name) ) return explorer_toolbox
40.911392
115
0.697401
0
0
0
0
0
0
0
0
2,213
0.684715
5f140a8d48047d7ddb5cd0c7677d6976d0a7cec0
827
py
Python
threatstack/v1/client.py
giany/threatstack-python-client
c9e0a4bed55685d3a032c6f1a03261d44de64c4a
[ "MIT" ]
4
2018-03-14T21:51:46.000Z
2020-01-06T17:25:53.000Z
threatstack/v1/client.py
giany/threatstack-python-client
c9e0a4bed55685d3a032c6f1a03261d44de64c4a
[ "MIT" ]
4
2018-01-17T19:58:29.000Z
2018-04-13T17:03:01.000Z
threatstack/v1/client.py
giany/threatstack-python-client
c9e0a4bed55685d3a032c6f1a03261d44de64c4a
[ "MIT" ]
6
2018-01-15T18:46:25.000Z
2022-02-17T10:13:35.000Z
""" V1 Client """ from threatstack.base import BaseClient from threatstack.v1 import resources class Client(BaseClient): BASE_URL = "https://app.threatstack.com/api/v1/" def __init__(self, api_key=None, org_id=None, user_id=None, timeout=None): BaseClient.__init__(self, api_key=api_key, timeout=timeout) self.org_id = org_id self.user_id = user_id self.agents = resources.Agents(self) self.alerts = resources.Alerts(self) self.logs = resources.Logs(self) self.organizations = resources.Organizations(self) self.policies = resources.Policies(self) def request_headers(self, _method, _url): headers = { "Authorization": self.api_key } if self.org_id: headers["Organization"] = self.org_id return headers
27.566667
78
0.665054
726
0.877872
0
0
0
0
0
0
83
0.100363
5f14372008e665aac666215605a53db7e9d8af9a
5,930
py
Python
djangocms_newsletter/admin/mailinglist.py
nephila/djangocms-newsletter
5ebd8d3e1e2c85b2791d0261a954469f2548c840
[ "BSD-3-Clause" ]
null
null
null
djangocms_newsletter/admin/mailinglist.py
nephila/djangocms-newsletter
5ebd8d3e1e2c85b2791d0261a954469f2548c840
[ "BSD-3-Clause" ]
null
null
null
djangocms_newsletter/admin/mailinglist.py
nephila/djangocms-newsletter
5ebd8d3e1e2c85b2791d0261a954469f2548c840
[ "BSD-3-Clause" ]
2
2021-03-15T13:33:53.000Z
2021-05-18T20:34:47.000Z
"""ModelAdmin for MailingList""" from datetime import datetime from django.contrib import admin from django.conf.urls.defaults import url from django.conf.urls.defaults import patterns from django.utils.encoding import smart_str from django.core.urlresolvers import reverse from django.shortcuts import get_object_or_404 from django.utils.translation import ugettext_lazy as _ from django.http import HttpResponseRedirect from emencia.django.newsletter.models import Contact from emencia.django.newsletter.models import MailingList from emencia.django.newsletter.settings import USE_WORKGROUPS from emencia.django.newsletter.utils.workgroups import request_workgroups from emencia.django.newsletter.utils.workgroups import request_workgroups_contacts_pk from emencia.django.newsletter.utils.workgroups import request_workgroups_mailinglists_pk from emencia.django.newsletter.utils.vcard import vcard_contacts_export_response from emencia.django.newsletter.utils.excel import ExcelResponse class MailingListAdmin(admin.ModelAdmin): date_hierarchy = 'creation_date' list_display = ('creation_date', 'name', 'description', 'subscribers_count', 'unsubscribers_count', 'exportation_links') list_editable = ('name', 'description') list_filter = ('creation_date', 'modification_date') search_fields = ('name', 'description',) filter_horizontal = ['subscribers', 'unsubscribers'] fieldsets = ((None, {'fields': ('name', 'description',)}), (None, {'fields': ('subscribers',)}), (None, {'fields': ('unsubscribers',)}), ) actions = ['merge_mailinglist'] actions_on_top = False actions_on_bottom = True def queryset(self, request): queryset = super(MailingListAdmin, self).queryset(request) if not request.user.is_superuser and USE_WORKGROUPS: mailinglists_pk = request_workgroups_mailinglists_pk(request) queryset = queryset.filter(pk__in=mailinglists_pk) return queryset def save_model(self, request, mailinglist, form, change): workgroups = [] if not mailinglist.pk and not request.user.is_superuser \ and USE_WORKGROUPS: workgroups = request_workgroups(request) mailinglist.save() for workgroup in workgroups: workgroup.mailinglists.add(mailinglist) def formfield_for_manytomany(self, db_field, request, **kwargs): if 'subscribers' in db_field.name and not request.user.is_superuser \ and USE_WORKGROUPS: contacts_pk = request_workgroups_contacts_pk(request) kwargs['queryset'] = Contact.objects.filter(pk__in=contacts_pk) return super(MailingListAdmin, self).formfield_for_manytomany( db_field, request, **kwargs) def merge_mailinglist(self, request, queryset): """Merge multiple mailing list""" if queryset.count() == 1: self.message_user(request, _('Please select a least 2 mailing list.')) return None subscribers = {} unsubscribers = {} for ml in queryset: for contact in ml.subscribers.all(): subscribers[contact] = '' for contact in ml.unsubscribers.all(): unsubscribers[contact] = '' when = str(datetime.now()).split('.')[0] new_mailing = MailingList(name=_('Merging list at %s') % when, description=_('Mailing list created by merging at %s') % when) new_mailing.save() new_mailing.subscribers = subscribers.keys() new_mailing.unsubscribers = unsubscribers.keys() if not request.user.is_superuser and USE_WORKGROUPS: for workgroup in request_workgroups(request): workgroup.mailinglists.add(new_mailing) self.message_user(request, _('%s succesfully created by merging.') % new_mailing) return HttpResponseRedirect(reverse('admin:newsletter_mailinglist_change', args=[new_mailing.pk])) merge_mailinglist.short_description = _('Merge selected mailinglists') def exportation_links(self, mailinglist): """Display links for exportation""" return u'<a href="%s">%s</a> / <a href="%s">%s</a>' % ( reverse('admin:newsletter_mailinglist_export_excel', args=[mailinglist.pk]), _('Excel'), reverse('admin:newsletter_mailinglist_export_vcard', args=[mailinglist.pk]), _('VCard')) exportation_links.allow_tags = True exportation_links.short_description = _('Export') def exportion_vcard(self, request, mailinglist_id): """Export subscribers in the mailing in VCard""" mailinglist = get_object_or_404(MailingList, pk=mailinglist_id) name = 'contacts_%s' % smart_str(mailinglist.name) return vcard_contacts_export_response(mailinglist.subscribers.all(), name) def exportion_excel(self, request, mailinglist_id): """Export subscribers in the mailing in Excel""" mailinglist = get_object_or_404(MailingList, pk=mailinglist_id) name = 'contacts_%s' % smart_str(mailinglist.name) return ExcelResponse(mailinglist.subscribers.all(), name) def get_urls(self): urls = super(MailingListAdmin, self).get_urls() my_urls = patterns('', url(r'^export/vcard/(?P<mailinglist_id>\d+)/$', self.admin_site.admin_view(self.exportion_vcard), name='newsletter_mailinglist_export_vcard'), url(r'^export/excel/(?P<mailinglist_id>\d+)/$', self.admin_site.admin_view(self.exportion_excel), name='newsletter_mailinglist_export_excel')) return my_urls + urls
47.063492
96
0.663238
4,936
0.832378
0
0
0
0
0
0
1,062
0.179089
5f18561e37fb0a33a844c99a5051aea7c8863cea
4,263
py
Python
lib/train/recorder.py
rurusasu/OrigNet
3b3384cb3d09b52c7c98bb264901285f006e51c1
[ "Apache-2.0" ]
null
null
null
lib/train/recorder.py
rurusasu/OrigNet
3b3384cb3d09b52c7c98bb264901285f006e51c1
[ "Apache-2.0" ]
null
null
null
lib/train/recorder.py
rurusasu/OrigNet
3b3384cb3d09b52c7c98bb264901285f006e51c1
[ "Apache-2.0" ]
1
2021-09-24T01:24:05.000Z
2021-09-24T01:24:05.000Z
import os import sys from collections import deque, defaultdict from typing import Dict, Union sys.path.append("../../") import torch import torchvision.utils as vutils from tensorboardX import SummaryWriter class SmoothedValue(object): """Track a series of values and provide access to smoothed values over a window or the global series average. """ def __init__(self, window_size=20): self.deque = deque(maxlen=window_size) self.total = 0.0 self.count = 0 def update(self, value): self.deque.append(value) self.count += 1 self.total += value @property def median(self): d = torch.tensor(list(self.deque)) return d.median().item() @property def avg(self): d = torch.tensor(list(self.deque)) return d.mean().item() @property def global_avg(self): return self.total / self.count class Recorder(object): def __init__(self, cfg): if "record_dir" not in cfg and "resume" not in cfg: raise ("The required parameter is not set.") # log_dir = os.path.join(pth.DATA_DIR, cfg.task, cfg.record_dir) log_dir = cfg.record_dir if not os.path.exists(log_dir): os.makedirs(log_dir) if not cfg.resume: os.system("rm -rf {}".format(log_dir)) self.writer = SummaryWriter(log_dir) # scalars self.epoch = 0 self.step = 0 self.loss_stats = defaultdict(SmoothedValue) self.batch_time = SmoothedValue() # images self.image_stats = defaultdict(object) def VisualizeNetwork(self, network: torch.nn, inputs: torch.Tensor) -> None: """TensorBoard 上でネットワークの構造を可視化するためのデータを作成するための関数. Args: network (torch.nn): 可視化したいモデル inputs (torch.Tensor): モデルの構造を定義するための入力データ """ self.writer.add_graph(network, inputs) def update_image_stats(self, image_stats: Dict) -> None: """ Arg: image_stats(Dict[batch_imgs]): 辞書の内部に保存される値は、 * 4D形状のミニバッチテンソル (B x C x H x W) * すべて同じサイズの画像のリスト。 """ for k, v in image_stats.items(): self.image_stats[k] = v.detach().cpu() def update_loss_stats(self, loss_dict: Dict) -> None: for k, v in loss_dict.items(): self.loss_stats[k].update(v.detach().cpu()) def record( self, prefix, step: int = -1, loss_stats: Union[Dict, None] = None, image_stats: Union[Dict, None] = None, ): pattern = prefix + "/{}" step = step if step >= 0 else self.step loss_stats = loss_stats if loss_stats else self.loss_stats image_stats = image_stats if image_stats else self.image_stats for k, v in loss_stats.items(): if isinstance(v, SmoothedValue): self.writer.add_scalar(pattern.format(k), v.median, step) else: self.writer.add_scalar(pattern.format(k), v, step) for k, v in self.image_stats.items(): # RGB かつ [0, 1] の範囲の値を持つ場合 if len(v.size()) == 3: b_size, h, w = v.size()[0], v.size()[1], v.size()[2] v = v.view(b_size, -1, h, w) v = v.float() if v.dtype != torch.float32 else v self.writer.add_image( pattern.format(k), vutils.make_grid(v, value_range=[0, 1]), step ) del loss_stats def state_dict(self): scalar_dict = {} scalar_dict["step"] = self.step return scalar_dict def load_state_dict(self, scalar_dict): self.step = scalar_dict["step"] def __str__(self): loss_state = [] for k, v in self.loss_stats.items(): loss_state.append("{}: {:.4f}".format(k, v.avg)) loss_state = " ".join(loss_state) recording_state = " ".join( ["epoch: {}", "step: {}", "{}", "batch_time: {:.3f} sec."] ) return recording_state.format( self.epoch, self.step, loss_state, # self.data_time.avg, self.batch_time.avg, ) def make_recorder(cfg): return Recorder(cfg)
29
80
0.569317
4,228
0.940601
0
0
283
0.062959
0
0
990
0.220245
5f1970116641c3a579674b0a3cde7a6940267ce4
5,642
py
Python
scrapytest/spiders.py
coderatchet/scrapy-test
4f5febfca05d267dc98df94e65a403210ce39d81
[ "Apache-2.0" ]
null
null
null
scrapytest/spiders.py
coderatchet/scrapy-test
4f5febfca05d267dc98df94e65a403210ce39d81
[ "Apache-2.0" ]
null
null
null
scrapytest/spiders.py
coderatchet/scrapy-test
4f5febfca05d267dc98df94e65a403210ce39d81
[ "Apache-2.0" ]
null
null
null
import logging import re from datetime import datetime import scrapy from scrapy.http import Response # noinspection PyUnresolvedReferences import scrapytest.db from scrapytest.config import config from scrapytest.types import Article from scrapytest.utils import merge_dict log = logging.getLogger(__name__) class GuardianNewsSpider(scrapy.spiders.CrawlSpider): """ Spider that crawls over the Guardian news website""" name = "guardian" _user_config = {} def __init__(self, **kwargs): super().__init__(**kwargs) if hasattr(self, '_user_config'): self._config = merge_dict(self._user_config, config['guardian_spider']) else: self._config = config['guardian_spider'] @classmethod def update_settings(cls, settings): super(GuardianNewsSpider, cls).update_settings(settings) # super impose user cmd line args onto the current spider configuration. if 'custom_guardian_config' in settings: cls._user_config = settings.get('custom_guardian_config') def start_requests(self): """ generator for requesting the content from each of the main news collection entry points """ urls = ['http://{host}/{path}'.format(host=self._config['host'], path=path) for path in self._config['collection_paths']] for url in urls: max_depth = self._config['max_depth'] yield scrapy.Request(url=url, callback=lambda response: self._parse_news_list(response, max_depth)) def _parse_news_list(self, response: Response, depth=10): """ handle the raw html :param depth: maximum depth we should search for articles :param response: the top level news response """ log.debug("Parsing news list link: {}".format(response.url)) for link in self._article_links(response): link = response.urljoin(link) yield scrapy.Request(url=link, callback=self._parse_article_link) # if next link exists and depth not exceeded, visit next link and yield results. next_page = response.css(self._config['next_page_selector']).extract_first() # we keep iterating through until our maximum depth is reached. if next_page is not None and depth > 0: next_page = response.urljoin(next_page) yield scrapy.Request(url=next_page, callback=lambda list_response: self._parse_news_list(list_response, depth - 1)) def _parse_article_link(self, article: Response): """ parses the article's main page :param Response article: top level article page. should search for existing article and store if not found. """ import re # some author elements have clickable links with the name and picture of author author_raw = article.css(self._config['author_selector']) log.debug("author_raw: {}".format(author_raw.extract_first())) try: if author_raw.css('a').extract_first() is not None: author = author_raw.css('a::text').extract_first() else: author = author_raw.css('*::text').extract_first() author = re.split(r"-", author)[0].strip() except: author = "The Guardian" log.debug("parsed author name: {}".format(author)) # author is in format of "name - email" date_time_string = article.css(self._config['date_time_selector']).extract_first() # remove the ':' from the date string as sftptime does not support this sub = re.sub(r':([0-9]{2})$', r'\1', date_time_string) date_time = datetime.strptime(sub, self._config['date_time_format']) # assemble the article object title = article.css(self._config['title_selector']).extract_first().strip() data = { 'title': title, 'author': author, 'date_time': date_time, 'content': '\n'.join(article.css(self._config['content_selector']).extract()).strip() } # don't save the article if nothing exists in it. if not data['content'].strip() == '': # persist it if it doesn't exist yet log.debug("Searching for existing article with the title '{}' and date_time '{}'".format(title, date_time)) existing_article = Article.objects(title__exact=title, date_time__exact=date_time).first() if existing_article is None: log.debug("Article not found for {} - {}, saving new article: {}".format(title, date_time, data)) new_article = Article(**data) new_article.save() else: log.debug("Article found, not saving") @staticmethod def _parse_author_tag(author_tag: Response): """ parse the author section for the name :param author_tag: the author/div tag to parse :return: the name of the author """ text = author_tag.css('.story-header__author-name::text').extract_first() return re.split(r"-", text)[0].strip() def _article_links(self, news_list_response: Response): """ Generator for iterating through articles :param scrapy.http.Response news_list_response: a top level news list page :yields: the next article in the news list """ for article_link in news_list_response.css(self._config['article_list_item_link_selector']): yield article_link.extract()
40.589928
119
0.63045
5,327
0.944169
1,927
0.341546
674
0.119461
0
0
2,091
0.370613
5f19f6344a219107ca416c8c6abd1b139dea3270
6,490
py
Python
src/lib/parsers/parseskipfish.py
Project-Prismatica/Prism-Shell
006d04fdabbe51c4a3fd642e05ba276251f1bba4
[ "MIT" ]
null
null
null
src/lib/parsers/parseskipfish.py
Project-Prismatica/Prism-Shell
006d04fdabbe51c4a3fd642e05ba276251f1bba4
[ "MIT" ]
null
null
null
src/lib/parsers/parseskipfish.py
Project-Prismatica/Prism-Shell
006d04fdabbe51c4a3fd642e05ba276251f1bba4
[ "MIT" ]
1
2018-02-22T02:18:48.000Z
2018-02-22T02:18:48.000Z
#!/usr/bin/python # parseskipfish.py # # By Adrien de Beaupre [email protected] | [email protected] # Copyright 2011 Intru-Shun.ca Inc. # v0.09 # 16 October 2011 # # The current version of these scripts are at: http://dshield.handers.org/adebeaupre/ossams-parser.tgz # # Parses skipfish HTML and JSON output # http://code.google.com/p/skipfish/ # # This file is part of the ossams-parser. # # The ossams-parser is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # The ossams-parser is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with the ossams-parser. If not, see <http://www.gnu.org/licenses/>. # """ Napping of tool field to OSSAMS database field: tool field: database field: sf_version tooloutput.version scan_date tooloutput.tooldate severity vulnerabilities.severity type vulnerabilities.vulnerabilityid name vulnerabilities.vulnerabilityname request vulnerabilities.httprequest response vulnerabilities.httpresponse url vulnerabilities.vulnerabilityuri extra vulnerabilities.vulnerabilityextra """ # parseskipfish function def parseskipfish(time, os, etree, sys, filetoread, db, dbconnection, projectname, projectid, separator): parser = etree.HTMLParser() newsamples = "" newsummary = "" counter = 0 descriptions = "" directory = "" skipfishfile = filetoread.split(separator) file = skipfishfile[-1] filetime = time.ctime(os.path.getmtime(filetoread)) timenow = time.ctime() skipfishfile.pop() for item in skipfishfile: directory = directory + item + separator samplesfilein = directory + "samples.js" summaryfilein = directory + "summary.js" samplesfileout = directory + "skipfishsamples.py" summaryfileout = directory + "skipfishsummary.py" descfileout = directory + "skipfishdesc.py" if os.path.isfile(samplesfilein): sampleshandle = open(samplesfilein, 'r') for line in sampleshandle: newsamples = newsamples + line.replace('var ','') samplesfilehandle = open(samplesfileout, 'w') samplesfilehandle.write(newsamples) samplesfilehandle.close() else: print "Could not locate the skipfish samples.js file in: ", directory return if os.path.isfile(summaryfilein): summaryhandle = open(summaryfilein, 'r') for line in summaryhandle: newsummary = newsummary + line.replace('var ','') summaryfilehandle = open(summaryfileout, 'w') summaryfilehandle.write(newsummary) summaryfilehandle.close() else: print "Could not locate the skipfish summary.js file in: ", directory return if os.path.isfile(filetoread): tree = etree.parse(filetoread, parser) root = tree.getroot() # Check to see if the document root is 'html', exit if it is not if root.tag: if root.tag != "html": print filetoread, "is not an skipfish HTML report file" return javascripts = root.findall('head/script') for javascript in javascripts: if javascript.text: contents = javascript.text splitcontents = contents.split('\n') for iterator in splitcontents: if 'var issue_desc' in iterator: firstcounter = counter if 'Simple HTML' in iterator: secondcounter = counter counter+=1 for i in range(firstcounter, secondcounter): if 'var' in splitcontents[i]: descriptions = descriptions + splitcontents[i].replace('var ','') else: descriptions = descriptions + splitcontents[i] descfilehandle = open(descfileout, 'w') descfilehandle.write(descriptions) descfilehandle.close() sys.path.append(directory) from skipfishdesc import issue_desc from skipfishsamples import issue_samples import skipfishsummary db.execute(""" INSERT INTO tooloutput (toolname, filename, OSSAMSVersion, filedate, version, inputtimestamp, tooldate, projectname, projectid) VALUES ('skipfish', '%s', 0.09, '%s', '%s', '%s', '%s', '%s', '%s') """ % (file, filetime, skipfishsummary.sf_version, timenow, skipfishsummary.scan_date, projectname, projectid) ) tooloutputnumber = int(db.lastrowid) print "Processed skipfish report number:", tooloutputnumber db.execute(""" INSERT INTO hosts (tooloutputnumber, recon, hostcriticality) VALUES ('%s', '1', '0') """ % (tooloutputnumber) ) hostnumber = int(db.lastrowid) for issue in range(len(issue_samples)): issuedict = issue_samples[issue] typenum = issuedict['type'] samplelist = issuedict['samples'] for sample in range(len(samplelist)): sampledict = samplelist[sample] if sampledict['dir'] != '': directory = directory + sampledict['dir'].replace('/', separator) requestfile = directory + '\\request.dat' if os.path.isfile(requestfile): requestfilehandle = open(requestfile, 'r') request = requestfilehandle.read() requestfilehandle.close() else: request = "" responsefile = directory + separator + 'response.dat' if os.path.isfile(responsefile): responsefilehandle = open(responsefile, 'r') response = responsefilehandle.read() responsefilehandle.close() else: response = "" db.execute(""" INSERT INTO vulnerabilities (tooloutputnumber, hostnumber, vulnerabilityid, vulnerabilityseverity, vulnerabilityname, vulnerabilityextra, vulnerabilityuri, httprequest, httpresponse, vulnerabilityvalidation) VALUES ('%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', 0) """ % (tooloutputnumber, hostnumber, typenum, issuedict['severity'], dbconnection.escape_string(issue_desc[str(typenum)]), dbconnection.escape_string(sampledict['extra']), dbconnection.escape_string(sampledict['url']), dbconnection.escape_string(request), dbconnection.escape_string(response)) ) vulnnumber = int(db.lastrowid) else: print "Could not locate the skipfish index.html file" return
38.402367
130
0.686441
0
0
0
0
0
0
0
0
2,774
0.427427
5f1c1c275c8674c941378ad94c7d52f05e79ddd2
14,861
py
Python
userge/plugins/admin/gban.py
wildyvpn-network/bot
87459495000bd6004b8f62a9cb933c164da9ef29
[ "MIT" ]
null
null
null
userge/plugins/admin/gban.py
wildyvpn-network/bot
87459495000bd6004b8f62a9cb933c164da9ef29
[ "MIT" ]
null
null
null
userge/plugins/admin/gban.py
wildyvpn-network/bot
87459495000bd6004b8f62a9cb933c164da9ef29
[ "MIT" ]
null
null
null
""" setup gban """ # Copyright (C) 2020 by UsergeTeam@Github, < https://github.com/UsergeTeam >. # # This file is part of < https://github.com/UsergeTeam/Userge > project, # and is released under the "GNU v3.0 License Agreement". # Please see < https://github.com/uaudith/Userge/blob/master/LICENSE > # # All rights reserved import json import asyncio from typing import Union import aiohttp import spamwatch from spamwatch.types import Ban from pyrogram.errors.exceptions.bad_request_400 import ( ChatAdminRequired, UserAdminInvalid, ChannelInvalid) from userge import userge, Message, Config, get_collection, filters, pool SAVED_SETTINGS = get_collection("CONFIGS") GBAN_USER_BASE = get_collection("GBAN_USER") WHITELIST = get_collection("WHITELIST_USER") CHANNEL = userge.getCLogger(__name__) LOG = userge.getLogger(__name__) async def _init() -> None: s_o = await SAVED_SETTINGS.find_one({'_id': 'ANTISPAM_ENABLED'}) if s_o: Config.ANTISPAM_SENTRY = s_o['data'] @userge.on_cmd("antispam", about={ 'header': "enable / disable antispam", 'description': "Toggle API Auto Bans"}, allow_channels=False) async def antispam_(message: Message): """ enable / disable antispam """ if Config.ANTISPAM_SENTRY: Config.ANTISPAM_SENTRY = False await message.edit("`antispam disabled !`", del_in=3) else: Config.ANTISPAM_SENTRY = True await message.edit("`antispam enabled !`", del_in=3) await SAVED_SETTINGS.update_one( {'_id': 'ANTISPAM_ENABLED'}, {"$set": {'data': Config.ANTISPAM_SENTRY}}, upsert=True) @userge.on_cmd("gban", about={ 'header': "Globally Ban A User", 'description': "Adds User to your GBan List. " "Bans a Globally Banned user if they join or message. " "[NOTE: Works only in groups where you are admin.]", 'examples': "{tr}gban [userid | reply] [reason for gban] (mandatory)"}, allow_channels=False, allow_bots=False) async def gban_user(message: Message): """ ban a user globally """ await message.edit("`GBanning...`") user_id, reason = message.extract_user_and_text if not user_id: await message.edit( "`no valid user_id or message specified,`" "`don't do .help gban for more info. " "Coz no one's gonna help ya`(。ŏ_ŏ) ⚠", del_in=0) return get_mem = await message.client.get_user_dict(user_id) firstname = get_mem['fname'] if not reason: await message.edit( f"**#Aborted**\n\n**Gbanning** of [{firstname}](tg://user?id={user_id}) " "Aborted coz No reason of gban provided by banner", del_in=5) return user_id = get_mem['id'] if user_id == (await message.client.get_me()).id: await message.edit(r"LoL. Why would I GBan myself ¯\(°_o)/¯") return if user_id in Config.SUDO_USERS: await message.edit( "That user is in my Sudo List, Hence I can't ban him.\n\n" "**Tip:** Remove them from Sudo List and try again. (¬_¬)", del_in=5) return found = await GBAN_USER_BASE.find_one({'user_id': user_id}) if found: await message.edit( "**#Already_GBanned**\n\nUser Already Exists in My Gban List.\n" f"**Reason For GBan:** `{found['reason']}`", del_in=5) return await message.edit(r"\\**#GBanned_User**//" f"\n\n**First Name:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`\n**Reason:** `{reason}`") # TODO: can we add something like "GBanned by {any_sudo_user_fname}" if message.client.is_bot: chats = [message.chat] else: chats = await message.client.get_common_chats(user_id) gbanned_chats = [] for chat in chats: try: await chat.kick_member(user_id) gbanned_chats.append(chat.id) await CHANNEL.log( r"\\**#Antispam_Log**//" f"\n**User:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`\n" f"**Chat:** {chat.title}\n" f"**Chat ID:** `{chat.id}`\n" f"**Reason:** `{reason}`\n\n$GBAN #id{user_id}") except (ChatAdminRequired, UserAdminInvalid, ChannelInvalid): pass await GBAN_USER_BASE.insert_one({'firstname': firstname, 'user_id': user_id, 'reason': reason, 'chat_ids': gbanned_chats}) if message.reply_to_message: await CHANNEL.fwd_msg(message.reply_to_message) await CHANNEL.log(f'$GBAN #prid{user_id} ⬆️') LOG.info("G-Banned %s", str(user_id)) @userge.on_cmd("ungban", about={ 'header': "Globally Unban an User", 'description': "Removes an user from your Gban List", 'examples': "{tr}ungban [userid | reply]"}, allow_channels=False, allow_bots=False) async def ungban_user(message: Message): """ unban a user globally """ await message.edit("`UnGBanning...`") user_id, _ = message.extract_user_and_text if not user_id: await message.err("user-id not found") return get_mem = await message.client.get_user_dict(user_id) firstname = get_mem['fname'] user_id = get_mem['id'] found = await GBAN_USER_BASE.find_one({'user_id': user_id}) if not found: await message.err("User Not Found in My Gban List") return if 'chat_ids' in found: for chat_id in found['chat_ids']: try: await userge.unban_chat_member(chat_id, user_id) await CHANNEL.log( r"\\**#Antispam_Log**//" f"\n**User:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`\n\n" f"$UNGBAN #id{user_id}") except (ChatAdminRequired, UserAdminInvalid, ChannelInvalid): pass await message.edit(r"\\**#UnGbanned_User**//" f"\n\n**First Name:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`") await GBAN_USER_BASE.delete_one({'firstname': firstname, 'user_id': user_id}) LOG.info("UnGbanned %s", str(user_id)) @userge.on_cmd("glist", about={ 'header': "Get a List of Gbanned Users", 'description': "Get Up-to-date list of users Gbanned by you.", 'examples': "Lol. Just type {tr}glist"}, allow_channels=False) async def list_gbanned(message: Message): """ vies gbanned users """ msg = '' async for c in GBAN_USER_BASE.find(): msg += ("**User** : " + str(c['firstname']) + "-> with **User ID** -> " + str(c['user_id']) + " is **GBanned for** : " + str(c['reason']) + "\n\n") await message.edit_or_send_as_file( f"**--Globally Banned Users List--**\n\n{msg}" if msg else "`glist empty!`") @userge.on_cmd("whitelist", about={ 'header': "Whitelist a User", 'description': "Use whitelist to add users to bypass API Bans", 'useage': "{tr}whitelist [userid | reply to user]", 'examples': "{tr}whitelist 5231147869"}, allow_channels=False, allow_bots=False) async def whitelist(message: Message): """ add user to whitelist """ user_id, _ = message.extract_user_and_text if not user_id: await message.err("user-id not found") return get_mem = await message.client.get_user_dict(user_id) firstname = get_mem['fname'] user_id = get_mem['id'] found = await WHITELIST.find_one({'user_id': user_id}) if found: await message.err("User Already in My WhiteList") return await asyncio.gather( WHITELIST.insert_one({'firstname': firstname, 'user_id': user_id}), message.edit( r"\\**#Whitelisted_User**//" f"\n\n**First Name:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`"), CHANNEL.log( r"\\**#Antispam_Log**//" f"\n**User:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`\n" f"**Chat:** {message.chat.title}\n" f"**Chat ID:** `{message.chat.id}`\n\n$WHITELISTED #id{user_id}") ) LOG.info("WhiteListed %s", str(user_id)) @userge.on_cmd("rmwhite", about={ 'header': "Removes a User from Whitelist", 'description': "Use it to remove users from WhiteList", 'useage': "{tr}rmwhite [userid | reply to user]", 'examples': "{tr}rmwhite 5231147869"}, allow_channels=False, allow_bots=False) async def rmwhitelist(message: Message): """ remove a user from whitelist """ user_id, _ = message.extract_user_and_text if not user_id: await message.err("user-id not found") return get_mem = await message.client.get_user_dict(user_id) firstname = get_mem['fname'] user_id = get_mem['id'] found = await WHITELIST.find_one({'user_id': user_id}) if not found: await message.err("User Not Found in My WhiteList") return await asyncio.gather( WHITELIST.delete_one({'firstname': firstname, 'user_id': user_id}), message.edit( r"\\**#Removed_Whitelisted_User**//" f"\n\n**First Name:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`"), CHANNEL.log( r"\\**#Antispam_Log**//" f"\n**User:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`\n" f"**Chat:** {message.chat.title}\n" f"**Chat ID:** `{message.chat.id}`\n\n$RMWHITELISTED #id{user_id}") ) LOG.info("WhiteListed %s", str(user_id)) @userge.on_cmd("listwhite", about={ 'header': "Get a List of Whitelisted Users", 'description': "Get Up-to-date list of users WhiteListed by you.", 'examples': "Lol. Just type {tr}listwhite"}, allow_channels=False) async def list_white(message: Message): """ list whitelist """ msg = '' async for c in WHITELIST.find(): msg += ("**User** : " + str(c['firstname']) + "-> with **User ID** -> " + str(c['user_id']) + "\n\n") await message.edit_or_send_as_file( f"**--Whitelisted Users List--**\n\n{msg}" if msg else "`whitelist empty!`") @userge.on_filters(filters.group & filters.new_chat_members, group=1, check_restrict_perm=True) async def gban_at_entry(message: Message): """ handle gbans """ chat_id = message.chat.id for user in message.new_chat_members: user_id = user.id first_name = user.first_name if await WHITELIST.find_one({'user_id': user_id}): continue gbanned = await GBAN_USER_BASE.find_one({'user_id': user_id}) if gbanned: if 'chat_ids' in gbanned: chat_ids = gbanned['chat_ids'] chat_ids.append(chat_id) else: chat_ids = [chat_id] await asyncio.gather( message.client.kick_chat_member(chat_id, user_id), message.reply( r"\\**#Userge_Antispam**//" "\n\nGlobally Banned User Detected in this Chat.\n\n" f"**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** `{gbanned['reason']}`\n\n" "**Quick Action:** Banned", del_in=10), CHANNEL.log( r"\\**#Antispam_Log**//" "\n\n**GBanned User $SPOTTED**\n" f"**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** {gbanned['reason']}\n**Quick Action:** " f"Banned in {message.chat.title}"), GBAN_USER_BASE.update_one( {'user_id': user_id, 'firstname': first_name}, {"$set": {'chat_ids': chat_ids}}, upsert=True) ) elif Config.ANTISPAM_SENTRY: async with aiohttp.ClientSession() as ses: async with ses.get(f'https://api.cas.chat/check?user_id={user_id}') as resp: res = json.loads(await resp.text()) if res['ok']: reason = ' | '.join( res['result']['messages']) if 'result' in res else None await asyncio.gather( message.client.kick_chat_member(chat_id, user_id), message.reply( r"\\**#Userge_Antispam**//" "\n\nGlobally Banned User Detected in this Chat.\n\n" "**$SENTRY CAS Federation Ban**\n" f"**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** `{reason}`\n\n" "**Quick Action:** Banned", del_in=10), CHANNEL.log( r"\\**#Antispam_Log**//" "\n\n**GBanned User $SPOTTED**\n" "**$SENRTY #CAS BAN**" f"\n**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** `{reason}`\n**Quick Action:**" f" Banned in {message.chat.title}\n\n$AUTOBAN #id{user_id}") ) elif Config.SPAM_WATCH_API: intruder = await _get_spamwatch_data(user_id) if intruder: await asyncio.gather( message.client.kick_chat_member(chat_id, user_id), message.reply( r"\\**#Userge_Antispam**//" "\n\nGlobally Banned User Detected in this Chat.\n\n" "**$SENTRY SpamWatch Federation Ban**\n" f"**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** `{intruder.reason}`\n\n" "**Quick Action:** Banned", del_in=10), CHANNEL.log( r"\\**#Antispam_Log**//" "\n\n**GBanned User $SPOTTED**\n" "**$SENRTY #SPAMWATCH_API BAN**" f"\n**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** `{intruder.reason}`\n" f"**Quick Action:** Banned in {message.chat.title}\n\n" f"$AUTOBAN #id{user_id}") ) message.continue_propagation() @pool.run_in_thread def _get_spamwatch_data(user_id: int) -> Union[Ban, bool]: return spamwatch.Client(Config.SPAM_WATCH_API).get_ban(user_id)
43.200581
95
0.554942
0
0
0
0
13,856
0.931433
12,002
0.806803
6,024
0.404948
5f203d4af3e16b58b2caf10d5df99a539d4f0417
41
py
Python
user/tests/test_verifycode.py
Hrsn2861/pysat-server
72224bb0e6af8ef825eaf3259587698b5639b8a5
[ "MIT" ]
null
null
null
user/tests/test_verifycode.py
Hrsn2861/pysat-server
72224bb0e6af8ef825eaf3259587698b5639b8a5
[ "MIT" ]
7
2020-06-06T01:55:39.000Z
2022-02-10T11:46:31.000Z
user/tests/test_verifycode.py
Hrsnnnn/pysat-server
72224bb0e6af8ef825eaf3259587698b5639b8a5
[ "MIT" ]
null
null
null
"""pytest for user.models.verifycode """
13.666667
36
0.707317
0
0
0
0
0
0
0
0
40
0.97561
5f20ed53742e88f3bc18e3804150cf7252de73ee
7,638
py
Python
src/python/codebay/common/runcommand.py
nakedible/vpnease-l2tp
0fcda6a757f2bc5c37f4753b3cd8b1c6d282db5c
[ "WTFPL" ]
5
2015-04-16T08:36:17.000Z
2017-05-12T17:20:12.000Z
src/python/codebay/common/runcommand.py
nakedible/vpnease-l2tp
0fcda6a757f2bc5c37f4753b3cd8b1c6d282db5c
[ "WTFPL" ]
null
null
null
src/python/codebay/common/runcommand.py
nakedible/vpnease-l2tp
0fcda6a757f2bc5c37f4753b3cd8b1c6d282db5c
[ "WTFPL" ]
4
2015-03-19T14:39:51.000Z
2019-01-23T08:22:55.000Z
""" Codebay process running utils. @group Running commands: run, call @group Preexec functions: chroot, cwd @var PASS: Specifies that the given file descriptor should be passed directly to the parent. Given as an argument to run. @var FAIL: Specifies that if output is received for the given file descriptor, an exception should be signalled. Given as an argument to run. @var STDOUT: Specifies that standard error should be redirected to the same file descriptor as standard out. Given as an argument to run. """ __docformat__ = 'epytext en' import os from codebay.common import subprocess PASS = -1 FAIL = -2 STDOUT = -3 class RunException(Exception): """Running command failed. @ivar rv: Return value of the command. @ivar stdout: Captured stdout of the command or None. @ivar stderr: Captured stderr of the command or None. """ class chroot: """Returns a function that will do a chroot to path when invoked.""" def __init__(self, path): self.path = path def __call__(self): os.chroot(self.path) def __repr__(self): return '%s(%s)' % (str(self.__class__), repr(self.path)) class cwd: """Returns a function that will do a cwd to path when invoked.""" def __init__(self, path): self.path = path def __call__(self): os.chdir(self.path) def __repr__(self): return '%s(%s)' % (str(self.__class__), repr(self.path)) def call(*args, **kw): """Convenience wrapper for calling run. Positional arguments are converted to a list and given to run as an argument. Keyword arguments are passed as is to run. >>> call('echo','-n','foo') [0, 'foo', ''] >>> call('exit 1', shell=True) [1, '', ''] """ return run(list(args), **kw) def run(args, executable=None, cwd=None, env=None, stdin=None, stdout=None, stderr=None, shell=False, preexec=None, retval=None): """Wrapper for running commands. run takes a lot of arguments and they are explained here. >>> run(['echo','-n','foo']) [0, 'foo', ''] >>> run('exit 1', shell=True) [1, '', ''] @param args: List of strings or a single string specifying the program and the arguments to execute. It is mandatory. @param executable: Name of the executable to be passed in argv[0]. Defaults to the first value of args. @param cwd: Working directory to execute the program in. Defaults to no change. Executes before preexec. @param env: Environment to execute the process with. Defaults to inheriting the environment of the current process. @param stdin: If None, process is executed with a pipe with no data given. If a string, process is executed with a pipe with the string as input. If PASS, process stdin is inherited from the current process. Defaults to None. @param stdout: If None, process stdout is captured with a pipe and returned. If PASS, process stdout is inherited from the current process. If FAIL, process stdout is captured with a pipe and an exception is raised if the process prints to stdout. Defaults to None. @param stderr: Same as above with one addition. If STDOUT, then stderr is redirected to the same destination as stdout. @param shell: If False, the command is executed directly. If True, the arguments are passed to the shell for interpretation. Defaults to False. @param preexec: Can be used to specify things to do just before starting the new child process. The argument should be a list or tuple, all of the callables in the list are executed just before starting the child process. Defaults to no function executed. @param retval: If None, no checks are performed on the child process' return value. If FAIL, an exception is raised if the child process return value is not zero. If a callable, the callable is invoked with the child process return value as an argument and an exception is raised if the callable returned False. @return: List of retval, stdout output string and stderr output string. If stdout or stderr is not captured, None is returned instead. @raise RunException: Raised if stdout output, stderr output or return value check triggered a failure. @raise ValueError: Raised if illegal arguments are detected. @raise OSError: Raised if starting the child process failed. """ if isinstance(args, list): popen_args = args elif isinstance(args, str): popen_args = [args] else: raise ValueError('Unknown value %s passed as args.' % repr(args)) if preexec is None: preexec_fn = None elif isinstance(preexec, (list, tuple)): def do_preexec(): for f in preexec: f() preexec_fn = do_preexec else: raise ValueError('Unknown value %s passed as preexec.' % repr(preexec)) if stdin is None: popen_stdin = subprocess.PIPE popen_input = None elif stdin is PASS: popen_stdin = None popen_input = None elif isinstance(stdin, str): popen_stdin = subprocess.PIPE popen_input = stdin else: raise ValueError('Unknown value %s passed as stdin.' % repr(stdin)) if stdout is None: popen_stdout = subprocess.PIPE elif stdout is PASS: popen_stdout = None elif stdout is FAIL: popen_stdout = subprocess.PIPE else: raise ValueError('Unknown value %s passed as stdout.' % repr(stdout)) if stderr is None: popen_stderr = subprocess.PIPE elif stderr is PASS: popen_stderr = None elif stderr is FAIL: popen_stderr = subprocess.PIPE elif stderr is STDOUT: popen_stderr = subprocess.STDOUT else: raise ValueError('Unknown value %s passed as stderr.' % repr(stderr)) if retval is None: rvcheck = None elif retval is FAIL: def do_check(i): return i == 0 rvcheck = do_check elif callable(retval): rvcheck = retval else: raise ValueError('Unknown value %s passed as retval.' % repr(retval)) handle, rv = None, None try: handle = subprocess.Popen(popen_args, executable=executable, stdin=popen_stdin, stdout=popen_stdout, stderr=popen_stderr, close_fds=True, cwd=cwd, env=env, shell=shell, preexec_fn=preexec_fn) stdout, stderr = handle.communicate(input=popen_input) finally: if handle is not None: rv = handle.wait() if stdout is FAIL: if stdout != '': e = RunException('Process printed to stdout.') e.rv = rv e.stdout = stdout e.stderr = stderr raise e if stderr is FAIL: if stderr != '': e = RunException('Process printed to stderr.') e.rv = rv e.stdout = stdout e.stderr = stderr raise e if rvcheck is not None: if not rvcheck(rv): e = RunException('Process return value check failed.') e.rv = rv e.stdout = stdout e.stderr = stderr raise e return [rv, stdout, stderr]
32.092437
129
0.615213
794
0.103954
0
0
0
0
0
0
4,086
0.534957
5f268730f61e34ddeec03c49cb3a27cf05cffa58
545
py
Python
SourceCode/Module2/escape_sequences.py
hackettccp/CIS106SampleCode
0717fa0f6dc0c48bc51f16ab44e7425b186a35c3
[ "MIT" ]
1
2019-10-23T03:25:43.000Z
2019-10-23T03:25:43.000Z
SourceCode/Module2/escape_sequences.py
hackettccp/CIS106
0717fa0f6dc0c48bc51f16ab44e7425b186a35c3
[ "MIT" ]
null
null
null
SourceCode/Module2/escape_sequences.py
hackettccp/CIS106
0717fa0f6dc0c48bc51f16ab44e7425b186a35c3
[ "MIT" ]
null
null
null
""" Demonstrates escape sequences in strings """ #Line Feed escape sequence. output1 = "First part \n Second part" print(output1) #********************************# print() #Double quotes escape sequence. output2 = "The book \"War and Peace\" is very long" print(output2) #********************************# print() #Single quote escape sequence. output3 = 'That is Tom\'s bike' print(output3) #********************************# print() #Backslash escape sequence. output4 = "A single backslash \\ will be inserted" print(output4)
18.793103
51
0.577982
0
0
0
0
0
0
0
0
394
0.722936